/// <summary>
        /// Determines the number of days from one DayOfWeek till the next.
        /// </summary>
        /// <param name="self">the starting DayOfWeek</param>
        /// <param name="next">The ending DayOfWeek</param>
        /// <returns>the number of days from <paramref name="self"/> to <paramref name="next"/></returns>
        /// <exception cref="ArgumentOutOfRangeException">If either DayOfWeek is not 
        /// <see cref="DayOfWeekExtensions.InRange"/></exception>
        /// <example>
        /// Debug.Assert(DayOfWeek.Monday.DaysTill(DayOfWeek.Tuesday) == 1);
        /// </example>
        public static int DaysTill(this DayOfWeek self, DayOfWeek next)
        {
            self.CheckRange();
            next.CheckRange();

            return DaysBetween((int)next, (int)self);
        }

 public bool IsWorkingDay(DayOfWeek dayOfWeek)
 {
     if (dayOfWeek == DayOfWeek.Friday || dayOfWeek == DayOfWeek.Saturday) {
         return false;
     }
     return true;
 }

 /// <summary>
 /// Returns the first day of week with in the month.
 /// </summary>
 /// <param name="obj">DateTime Base, from where the calculation will be preformed.</param>
 /// <param name="dow">What day of week to find the first one of in the month.</param>
 /// <returns>Returns DateTime object that represents the first day of week with in the month.</returns>
 public static DateTime FirstDayOfWeekInMonth(this DateTime obj, DayOfWeek dow)
 {
     var firstDay = new DateTime(obj.Year, obj.Month, 1);
     int diff = firstDay.DayOfWeek - dow;
     if (diff > 0) diff -= 7;
     return firstDay.AddDays(diff * -1);
 }

        public static DayOfWeek GetNextDay(DayOfWeek currentDay)
        {
            if ((int)currentDay == 6) 
                return (DayOfWeek)0;

            return (DayOfWeek)(currentDay + 1);
        }

        /// <summary>
        /// Determines the number of days since one DayOfWeek since the previous.
        /// </summary>
        /// <param name="self">the starting DayOfWeek</param>
        /// <param name="prev">The previous DayOfWeek</param>
        /// <returns>the number of days since <paramref name="self"/> to <paramref name="prev"/></returns>
        /// <exception cref="ArgumentOutOfRangeException">If either DayOfWeek is not 
        /// <see cref="DayOfWeekExtensions.InRange"/></exception>
        /// <example>
        /// Debug.Assert(DayOfWeek.Tuesday.DaysSince(DayOfWeek.Monday) == 1);
        /// </example>
        public static int DaysSince(this DayOfWeek self, DayOfWeek prev)
        {
            self.CheckRange();
            prev.CheckRange();

            return DaysBetween((int)self, (int)prev);
        }

        static string ImeDana(DayOfWeek danUTjednu)
        {
            switch (danUTjednu)
            {
                case DayOfWeek.Monday:
                    return "ponedjeljak";
                case DayOfWeek.Tuesday:
                    return "utorak";
                case DayOfWeek.Wednesday:
                    return "srijeda";
                case DayOfWeek.Thursday:
                    return "četvrtak";
                case DayOfWeek.Friday:
                    return "petak";
                case DayOfWeek.Saturday:
                    return "subota";
                case DayOfWeek.Sunday:
                    return "nedjelja";

                // Dopisati grane case za svaki dan u tjednu (DayOfWeek.Tuesday = Utorak, itd.)

                default:
                    return "Neispravan dan u tjednu";
            }
        }

 public TimelineModel this[DayOfWeek i]
 {
     get
     {
         return Days[(int)i];
     }
 }

    /// <summary>
    /// Convert starting day of week from enum to number - passed to calendar jquery control.
    /// </summary>
    /// <param name="name">Day name</param>
    protected int ConvertFirstDayToNumber(DayOfWeek name)
    {
        switch (name)
        {
            case DayOfWeek.Monday:
                return 1;

            case DayOfWeek.Tuesday:
                return 2;

            case DayOfWeek.Wednesday:
                return 3;

            case DayOfWeek.Thursday:
                return 4;

            case DayOfWeek.Friday:
                return 5;

            case DayOfWeek.Saturday:
                return 6;

            default:
                return 0;
        }
    }

        /// <summary>
        /// Initializes a new instance of the <see cref="LocationWorkHour"/> class.
        /// </summary>
        /// <param name="dayOfWeek">The day of week.</param>
        /// <param name="workHourTimeRange">The work hour time range.</param>
        public LocationWorkHour(DayOfWeek dayOfWeek, TimeRange workHourTimeRange)
        {
            Check.IsNotNull(dayOfWeek, () => DayOfWeek);

            _dayOfWeek = dayOfWeek;
            _workHourTimeRange = workHourTimeRange;
        }

        public MonthView()
        {
            SetStyle(ControlStyles.Opaque, true);
            DoubleBuffered = true;

            _dayNamesFormat = "ddd";
            _monthTitleFormat = "MMMM yyyy";
            _selectionMode = MonthViewSelection.Manual;
            _workWeekStart = DayOfWeek.Monday;
            _workWeekEnd = DayOfWeek.Friday;
            _weekStart = DayOfWeek.Sunday;
            _dayNamesVisible = true;
            _dayNamesLength = 2;
            _viewStart = DateTime.Now;
            _itemPadding = new Padding(2);
            _monthTitleColor = SystemColors.ActiveCaption;
            _monthTitleColorInactive = SystemColors.InactiveCaption;
            _monthTitleTextColor = SystemColors.ActiveCaptionText;
            _monthTitleTextColorInactive = SystemColors.InactiveCaptionText;
            _dayBackgroundColor = Color.Empty;
            _daySelectedBackgroundColor = SystemColors.Highlight;
            _dayTextColor = SystemColors.WindowText;
            _daySelectedTextColor = SystemColors.HighlightText;
            _arrowsColor = SystemColors.Window;
            _arrowsSelectedColor = Color.Gold;
            _dayGrayedText = SystemColors.GrayText;
            _todayBorderColor = Color.Maroon;

            UpdateMonthSize();
            UpdateMonths();
        }

 /// <summary>
 /// Creates a new range with the specified information
 /// </summary>
 /// <param name="day"></param>
 /// <param name="startTime"></param>
 /// <param name="endTime"></param>
 public CalendarHighlightRange(DayOfWeek day, TimeSpan startTime, TimeSpan endTime)
     : this()
 {
     _dayOfWeek = day;
     _startTime = startTime;
     _endTime = endTime;
 }

 internal TimeCondition(ValueType valueType, CounterType counter, uint value, DayOfWeek dayOfWeek)
 {
     ValueType = valueType;
     CounterType = counter;
     Value = value;
     DayOfWeek = dayOfWeek;
 }

 public DayOfWeekAnnualReccurance(DayOfWeek dayOfWeek, WeekOfMonth week, Month month, bool substituteWeekend = true)
     : base(substituteWeekend)
 {
     DayOfWeek = dayOfWeek;
     Week = week;
     Month = month;
 }

 public TimeSlot(DayOfWeek dayOfWeek, int p1, int p2)
 {
     // TODO: Complete member initialization
     this.dayOfWeek = dayOfWeek;
     this.from = p1;
     this.to = p2;
 }

 public static uint DayToUint(DayOfWeek day)
 {
     for (int i = 0; i < days.Length; i++)
         if (days[i] == day)
             return (uint)i;
     return 0;
 }

    public static DateTime GetDateFromDynamic(DateMagnitude magnitude, int offset, bool isEndDate, DateTimeOffset todaysDate, DayOfWeek weekStart, TimeZoneInfo timeZone)
    {
      var localToday = TimeZoneInfo.ConvertTime(todaysDate, timeZone);
      DateTimeOffset result;

      if (isEndDate) offset++;
      switch (magnitude)
      {
        case DateMagnitude.BusinessDay:
          var offsetMagn = Math.Abs(offset);
          var offsetSign = Math.Sign(offset);
          var i = 0;
          result = localToday;
          while (i < offsetMagn)
          {
            result = result.AddDays(offsetSign);
            if (result.DayOfWeek != DayOfWeek.Sunday && result.DayOfWeek != DayOfWeek.Saturday)
              i++;
          }
          break;
        case DateMagnitude.Week:
          result = GetWeekStart(todaysDate, weekStart).AddDays(offset * 7);
          break;
        case DateMagnitude.Month:
          result = new DateTimeOffset(todaysDate.Year, todaysDate.Month, 1, 0, 0, 0, localToday.Offset).AddMonths(offset);
          break;
        case DateMagnitude.Quarter:
          switch (todaysDate.Month)
          {
            case 1:
            case 2:
            case 3:
              result = new DateTimeOffset(todaysDate.Year, 1, 1, 0, 0, 0, localToday.Offset).AddMonths(offset * 3);
              break;
            case 4:
            case 5:
            case 6:
              result = new DateTimeOffset(todaysDate.Year, 4, 1, 0, 0, 0, localToday.Offset).AddMonths(offset * 3);
              break;
            case 7:
            case 8:
            case 9:
              result = new DateTimeOffset(todaysDate.Year, 7, 1, 0, 0, 0, localToday.Offset).AddMonths(offset * 3);
              break;
            default:
              result = new DateTimeOffset(todaysDate.Year, 10, 1, 0, 0, 0, localToday.Offset).AddMonths(offset * 3);
              break;
          }
          break;
        case DateMagnitude.Year:
          result = new DateTimeOffset(todaysDate.Year, 1, 1, 0, 0, 0, localToday.Offset).AddYears(offset * 3);
          break;
        default:
          result = todaysDate.AddDays(offset);
          break;
      }

      if (isEndDate) return result.Date.AddMilliseconds(-1);
      return result.Date;
    }

        /// <summary>
        /// Gets the last.
        /// </summary>
        /// <param name="input">    The date/ time.</param>
        /// <param name="dayOfWeek">The day of week.</param>
        /// <returns>DateTime.</returns>
        public static DateTime GetLast(this DateTime input, DayOfWeek dayOfWeek)
        {
            Contract.Requires<ArgumentOutOfRangeException>(Enum.IsDefined(typeof(DayOfWeek), input));

            var daysToSubtract = input.DayOfWeek > dayOfWeek ? input.DayOfWeek - dayOfWeek : (7 - (int)dayOfWeek) + (int)input.DayOfWeek;
            return input.AddDays(daysToSubtract * -1);
        }

 public static int GetDayNumberOnAWeek(DayOfWeek dayOfWeek)
 {
     switch(dayOfWeek)
     {
         case DayOfWeek.Sunday:
             return 7;
             break;
         case DayOfWeek.Monday:
             return 1;
             break;
         case DayOfWeek.Tuesday:
             return 2;
             break;
         case DayOfWeek.Wednesday:
             return 3;
             break;
         case DayOfWeek.Thursday:
             return 4;
             break;
         case DayOfWeek.Friday:
             return 5;
             break;
         case DayOfWeek.Saturday:
             return 6;
             break;
         default:
             throw new ArgumentOutOfRangeException("dayOfWeek");
     }
 }

        public static List<TimeSlot> GetListBoxRoomDayTimeSlot(ListBox listBox, DayOfWeek dayOfWeek)
        {
            uint startHour = 0;
            uint endHour = 0;
            uint previousHour = 0;

            List<TimeSlot> result = new List<TimeSlot>();

            foreach (int selectedIndex in listBox.SelectedIndices)
            {
                uint hour = (uint) selectedIndex + 7;
                if (hour != previousHour + 1) // new Timeslot
                {
                    if (startHour != 0)
                    {
                        result.Add(new TimeSlot(dayOfWeek, startHour, endHour));
                    }
                    startHour = hour;
                }

                endHour = hour + 1;
                previousHour = hour;
            }
            if (startHour != 0)
            {
                result.Add(new TimeSlot(dayOfWeek, startHour, endHour));
            }

            return result;
        }

        public static bool TrueOnDayOfWeek(DayOfWeek dayOfWeek, string daysOfWeekGrid)
        {
            int index = DaysOfWeekGrid.IndexOfDayOfWeek(dayOfWeek);

            bool retValue = DaysOfWeekGrid.NOT_THIS_DAY != daysOfWeekGrid[index];
            return retValue;
        }