public void CalendarHalfyearTest()
{
int currentYear = ClockProxy.Clock.Now.Year;
TimeCalendar calendar = TimeCalendar.New(TimeSpan.Zero, TimeSpan.Zero);
Halfyear h1 = new Halfyear(currentYear, YearHalfyear.First, calendar);
Assert.True(h1.IsReadOnly);
Assert.True(h1.IsCalendarHalfyear);
Assert.Equal(h1.YearBaseMonth, TimeSpec.CalendarYearStartMonth);
Assert.Equal(YearHalfyear.First, h1.YearHalfyear);
Assert.Equal(h1.BaseYear, currentYear);
Assert.Equal(h1.Start, new DateTime(currentYear, 1, 1));
Assert.Equal(h1.End, new DateTime(currentYear, 7, 1));
Halfyear h2 = new Halfyear(currentYear, YearHalfyear.Second, calendar);
Assert.True(h2.IsReadOnly);
Assert.True(h2.IsCalendarHalfyear);
Assert.Equal(h2.YearBaseMonth, TimeSpec.CalendarYearStartMonth);
Assert.Equal(YearHalfyear.Second, h2.YearHalfyear);
Assert.Equal(h2.BaseYear, currentYear);
Assert.Equal(h2.Start, new DateTime(currentYear, 7, 1));
Assert.Equal(h2.End, new DateTime(currentYear + 1, 1, 1));
} // CalendarHalfyearTest
public void DefaultHalfyearTest()
{
int currentYear = ClockProxy.Clock.Now.Year;
const YearMonth yearStartMonth = YearMonth.April;
TimeCalendar calendar = TimeCalendar.New(TimeSpan.Zero, TimeSpan.Zero, yearStartMonth);
Halfyear h1 = new Halfyear(currentYear, YearHalfyear.First, calendar);
Assert.True(h1.IsReadOnly);
Assert.False(h1.IsCalendarHalfyear);
Assert.Equal(h1.YearBaseMonth, yearStartMonth);
Assert.Equal(YearHalfyear.First, h1.YearHalfyear);
Assert.Equal(h1.BaseYear, currentYear);
Assert.Equal(h1.Start, new DateTime(currentYear, 4, 1));
Assert.Equal(h1.End, new DateTime(currentYear, 10, 1));
Halfyear h2 = new Halfyear(currentYear, YearHalfyear.Second, calendar);
Assert.True(h2.IsReadOnly);
Assert.False(h2.IsCalendarHalfyear);
Assert.Equal(h2.YearBaseMonth, yearStartMonth);
Assert.Equal(YearHalfyear.Second, h2.YearHalfyear);
Assert.Equal(h2.BaseYear, currentYear);
Assert.Equal(h2.Start, new DateTime(currentYear, 10, 1));
Assert.Equal(h2.End, new DateTime(currentYear + 1, 4, 1));
} // DefaultHalfyearTest
public void YearBaseMonthTest()
{
int currentYear = ClockProxy.Clock.Now.Year;
Halfyear halfyear = new Halfyear(currentYear, YearHalfyear.First, TimeCalendar.New(YearMonth.April));
Assert.Equal(YearMonth.April, halfyear.YearBaseMonth);
Assert.Equal(YearMonth.January, new Halfyear(currentYear, YearHalfyear.Second).YearBaseMonth);
} // YearBaseMonthTest
public void GetFiscalQuartersTest()
{
Halfyear halfyear = new Halfyear(2006, YearHalfyear.First, GetFiscalYearCalendar(FiscalYearAlignment.LastDay));
ITimePeriodCollection quarters = halfyear.GetQuarters();
Assert.NotNull(quarters);
Assert.Equal(quarters.Count, TimeSpec.QuartersPerHalfyear);
Assert.Equal(quarters[0].Start.Date, halfyear.Start);
Assert.Equal(quarters[TimeSpec.QuartersPerHalfyear - 1].End, halfyear.End);
} // GetFiscalQuartersTest
public void AddHalfyearsTest()
{
int currentYear = ClockProxy.Clock.Now.Year;
const YearMonth yearStartMonth = YearMonth.April;
TimeCalendar calendar = TimeCalendar.New(TimeSpan.Zero, TimeSpan.Zero, yearStartMonth);
DateTime calendarStartDate = new DateTime(currentYear, 4, 1);
Halfyear calendarHalfyear = new Halfyear(currentYear, YearHalfyear.First, calendar);
Assert.Equal(calendarHalfyear.AddHalfyears(0), calendarHalfyear);
Halfyear prevH1 = calendarHalfyear.AddHalfyears(-1);
Assert.Equal(YearHalfyear.Second, prevH1.YearHalfyear);
Assert.Equal(prevH1.BaseYear, currentYear - 1);
Assert.Equal(prevH1.Start, calendarStartDate.AddMonths(-6));
Assert.Equal(prevH1.End, calendarStartDate);
Halfyear prevH2 = calendarHalfyear.AddHalfyears(-2);
Assert.Equal(YearHalfyear.First, prevH2.YearHalfyear);
Assert.Equal(prevH2.BaseYear, currentYear - 1);
Assert.Equal(prevH2.Start, calendarStartDate.AddMonths(-12));
Assert.Equal(prevH2.End, calendarStartDate.AddMonths(-6));
Halfyear prevH3 = calendarHalfyear.AddHalfyears(-3);
Assert.Equal(YearHalfyear.Second, prevH3.YearHalfyear);
Assert.Equal(prevH3.BaseYear, currentYear - 2);
Assert.Equal(prevH3.Start, calendarStartDate.AddMonths(-18));
Assert.Equal(prevH3.End, calendarStartDate.AddMonths(-12));
Halfyear futureH1 = calendarHalfyear.AddHalfyears(1);
Assert.Equal(YearHalfyear.Second, futureH1.YearHalfyear);
Assert.Equal(futureH1.BaseYear, currentYear);
Assert.Equal(futureH1.Start, calendarStartDate.AddMonths(6));
Assert.Equal(futureH1.End, calendarStartDate.AddMonths(12));
Halfyear futureH2 = calendarHalfyear.AddHalfyears(2);
Assert.Equal(YearHalfyear.First, futureH2.YearHalfyear);
Assert.Equal(futureH2.BaseYear, currentYear + 1);
Assert.Equal(futureH2.Start, calendarStartDate.AddMonths(12));
Assert.Equal(futureH2.End, calendarStartDate.AddMonths(18));
Halfyear futureH3 = calendarHalfyear.AddHalfyears(3);
Assert.Equal(YearHalfyear.Second, futureH3.YearHalfyear);
Assert.Equal(futureH3.BaseYear, currentYear + 1);
Assert.Equal(futureH3.Start, calendarStartDate.AddMonths(18));
Assert.Equal(futureH3.End, calendarStartDate.AddMonths(24));
} // AddHalfyearsTest
} // Clear
// ----------------------------------------------------------------------
private void SelectPeriod(PeriodSelectType periodSelectType)
{
int offset = 0;
switch (periodSelectType)
{
case PeriodSelectType.Previous:
offset = -1;
break;
case PeriodSelectType.Current:
ResetWorkingPeriod();
return;
case PeriodSelectType.Next:
offset = 1;
break;
}
switch (WorkingTimePeriod)
{
case TimePeriodMode.Year:
Year year = new Year(WorkingPeriodStartDate);
SetWorkingPeriod(year.AddYears(offset));
break;
case TimePeriodMode.Halfyear:
Halfyear halfyear = new Halfyear(WorkingPeriodStartDate);
SetWorkingPeriod(halfyear.AddHalfyears(offset));
break;
case TimePeriodMode.Quarter:
Quarter quarter = new Quarter(WorkingPeriodStartDate);
SetWorkingPeriod(quarter.AddQuarters(offset));
break;
case TimePeriodMode.Month:
Month month = new Month(WorkingPeriodStartDate);
SetWorkingPeriod(month.AddMonths(offset));
break;
case TimePeriodMode.Week:
Week week = new Week(WorkingPeriodStartDate);
SetWorkingPeriod(week.AddWeeks(offset));
break;
case TimePeriodMode.Day:
Day day = new Day(WorkingPeriodStartDate);
SetWorkingPeriod(day.AddDays(offset));
break;
}
} // SelectPeriod
public void DefaultCalendarTest()
{
DateTime yearStart = new DateTime(ClockProxy.Clock.Now.Year, 1, 1);
foreach (YearHalfyear yearHalfyear in Enum.GetValues(typeof(YearHalfyear)))
{
int offset = (int)yearHalfyear - 1;
Halfyear halfyear = new Halfyear(yearStart.AddMonths(TimeSpec.MonthsPerHalfyear * offset));
Assert.Equal(YearMonth.January, halfyear.YearBaseMonth);
Assert.Equal(halfyear.BaseYear, yearStart.Year);
Assert.Equal(halfyear.Start, yearStart.AddMonths(TimeSpec.MonthsPerHalfyear * offset).Add(halfyear.Calendar.StartOffset));
Assert.Equal(halfyear.End, yearStart.AddMonths(TimeSpec.MonthsPerHalfyear * (offset + 1)).Add(halfyear.Calendar.EndOffset));
}
} // DefaultCalendarTest
} // ShowCompactHalfyear
// ----------------------------------------------------------------------
public static void ShowHalfyear(Halfyear halfyear, string caption = "Halfyear")
{
WriteLine("{0}: {1}", caption, halfyear);
WriteIndentLine("YearBaseMonth: {0}", halfyear.YearBaseMonth);
WriteIndentLine("StartMonth: {0}", halfyear.StartMonth);
WriteIndentLine("Year: {0}", halfyear.Year);
WriteIndentLine("YearHalfyear: {0}", halfyear.YearHalfyear);
WriteIndentLine("IsCalendarHalfyear: {0}", halfyear.IsCalendarHalfyear);
WriteIndentLine("MultipleCalendarYears: {0}", halfyear.MultipleCalendarYears);
WriteIndentLine("HalfyearName: {0}", halfyear.HalfyearName);
WriteIndentLine("HalfyearOfYearName: {0}", halfyear.HalfyearOfYearName);
WriteIndentLine("FirstDayStart: {0}", Format(halfyear.FirstDayStart));
WriteIndentLine("LastDayStart: {0}", Format(halfyear.LastDayStart));
WriteLine();
} // ShowHalfyear
public void FiscalYearGetMonthsTest()
{
Halfyear halfyear = new Halfyear(2006, YearHalfyear.First, GetFiscalYearCalendar(FiscalYearAlignment.LastDay));
ITimePeriodCollection months = halfyear.GetMonths();
Assert.NotNull(months);
Assert.Equal(months.Count, TimeSpec.MonthsPerHalfyear);
Assert.Equal(months[0].Start, new DateTime(2006, 8, 27));
for (int i = 0; i < months.Count; i++)
{
Assert.Equal(months[i].Duration.Subtract(TimeCalendar.DefaultEndOffset).Days,
(i + 1) % 3 == 0 ? TimeSpec.FiscalDaysPerLongMonth : TimeSpec.FiscalDaysPerShortMonth);
}
Assert.Equal(months[TimeSpec.MonthsPerHalfyear - 1].End, halfyear.End);
} // FiscalYearGetMonthsTest
// ----------------------------------------------------------------------
public static void ShowAll(int periodCount, int startYear, YearHalfyear yearHalfyear, TimeCalendarConfig calendarConfig)
{
WriteLine("Input: count={0}, year={1}, halfyear={2}", periodCount, startYear, yearHalfyear);
WriteLine();
HalfyearTimeRange halfyearTimeRange;
if (periodCount == 1)
{
Halfyear halfyear = new Halfyear(startYear, yearHalfyear, new TimeCalendar(calendarConfig));
halfyearTimeRange = halfyear;
Halfyear previousHalfyear = halfyear.GetPreviousHalfyear();
Halfyear nextHalfyear = halfyear.GetNextHalfyear();
ShowHalfyear(halfyear);
ShowCompactHalfyear(previousHalfyear, "Previous Halfyear");
ShowCompactHalfyear(nextHalfyear, "Next Halfyear");
WriteLine();
}
else
{
Halfyears halfyears = new Halfyears(startYear, yearHalfyear, periodCount, new TimeCalendar(calendarConfig));
halfyearTimeRange = halfyears;
ShowHalfyears(halfyears);
WriteLine();
foreach (Halfyear halfyear in halfyears.GetHalfyears())
{
ShowCompactHalfyear(halfyear);
}
WriteLine();
}
foreach (Quarter quarter in halfyearTimeRange.GetQuarters())
{
QuarterDemo.ShowCompactQuarter(quarter);
}
WriteLine();
foreach (Month month in halfyearTimeRange.GetMonths())
{
MonthDemo.ShowCompactMonth(month);
}
WriteLine();
} // ShowAll
public void GetMonthsTest()
{
int currentYear = ClockProxy.Clock.Now.Year;
TimeCalendar timeCalendar = TimeCalendar.New(YearMonth.October);
Halfyear halfyear = new Halfyear(currentYear, YearHalfyear.First, timeCalendar);
ITimePeriodCollection months = halfyear.GetMonths();
Assert.NotNull(months);
int index = 0;
foreach (Month month in months)
{
Assert.Equal(month.Start, halfyear.Start.AddMonths(index));
Assert.Equal(month.End, month.Calendar.MapEnd(month.Start.AddMonths(1)));
index++;
}
Assert.Equal(index, TimeSpec.MonthsPerHalfyear);
} // GetMonthsTest
public void GetQuartersTest()
{
int currentYear = ClockProxy.Clock.Now.Year;
TimeCalendar timeCalendar = TimeCalendar.New(YearMonth.October);
Halfyear h1 = new Halfyear(currentYear, YearHalfyear.First, timeCalendar);
ITimePeriodCollection h1Quarters = h1.GetQuarters();
Assert.NotNull(h1Quarters);
int h1Index = 0;
foreach (Quarter h1Quarter in h1Quarters)
{
Assert.Equal(h1Quarter.BaseYear, h1.BaseYear);
Assert.Equal(h1Quarter.YearQuarter, h1Index == 0 ? YearQuarter.First : YearQuarter.Second);
Assert.Equal(h1Quarter.Start, h1.Start.AddMonths(h1Index * TimeSpec.MonthsPerQuarter));
Assert.Equal(h1Quarter.End, h1Quarter.Calendar.MapEnd(h1Quarter.Start.AddMonths(TimeSpec.MonthsPerQuarter)));
h1Index++;
}
Assert.Equal(h1Index, TimeSpec.QuartersPerHalfyear);
Halfyear h2 = new Halfyear(currentYear, YearHalfyear.Second, timeCalendar);
ITimePeriodCollection h2Quarters = h2.GetQuarters();
Assert.NotNull(h2Quarters);
int h2Index = 0;
foreach (Quarter h2Quarter in h2Quarters)
{
Assert.Equal(h2Quarter.BaseYear, h2.BaseYear);
Assert.Equal(h2Quarter.YearQuarter, h2Index == 0 ? YearQuarter.Third : YearQuarter.Fourth);
Assert.Equal(h2Quarter.Start, h2.Start.AddMonths(h2Index * TimeSpec.MonthsPerQuarter));
Assert.Equal(h2Quarter.End, h2Quarter.Calendar.MapEnd(h2Quarter.Start.AddMonths(TimeSpec.MonthsPerQuarter)));
h2Index++;
}
Assert.Equal(h2Index, TimeSpec.QuartersPerHalfyear);
} // GetQuartersTest
public void InitValuesTest()
{
DateTime now = ClockProxy.Clock.Now;
DateTime firstHalfyear = new DateTime(now.Year, 1, 1);
DateTime secondHalfyear = new DateTime(now.Year, 7, 1);
Halfyear halfyear = new Halfyear(now.Year, YearHalfyear.First, TimeCalendar.NewEmptyOffset());
Assert.Equal(halfyear.Start.Year, firstHalfyear.Year);
Assert.Equal(halfyear.Start.Month, firstHalfyear.Month);
Assert.Equal(halfyear.Start.Day, firstHalfyear.Day);
Assert.Equal(0, halfyear.Start.Hour);
Assert.Equal(0, halfyear.Start.Minute);
Assert.Equal(0, halfyear.Start.Second);
Assert.Equal(0, halfyear.Start.Millisecond);
Assert.Equal(halfyear.End.Year, secondHalfyear.Year);
Assert.Equal(halfyear.End.Month, secondHalfyear.Month);
Assert.Equal(halfyear.End.Day, secondHalfyear.Day);
Assert.Equal(0, halfyear.End.Hour);
Assert.Equal(0, halfyear.End.Minute);
Assert.Equal(0, halfyear.End.Second);
Assert.Equal(0, halfyear.End.Millisecond);
} // InitValuesTest
} // ShowAll
// ----------------------------------------------------------------------
public static void ShowCompactHalfyear(Halfyear halfyear, string caption = "Halfyear")
{
WriteLine("{0}: {1}", caption, halfyear);
} // ShowCompactHalfyear
} // NotifyPropertyChanged
// ----------------------------------------------------------------------
private void UpdateSelectedPeriodInfo()
{
TimeCalendar timeCalendar = TimeCalendar.New(SelectedYearBaseMonth);
switch (SelectedPeriodMode)
{
case TimePeriodMode.Year:
Year year = new Year(WorkingDate, timeCalendar);
periodInfo.Clear();
periodInfo.AddItem("Year", year);
periodInfo.AddItem("YearBaseMonth", year.YearBaseMonth);
periodInfo.AddItem("IsCalendarYear", year.IsCalendarYear);
periodInfo.AddItem("StartYear", year.StartYear);
periodInfo.AddItem("FirstDayStart", year.FirstDayStart);
periodInfo.AddItem("LastDayStart", year.LastDayStart);
periodInfo.AddItem("LastMonthStart", year.LastMonthStart);
periodInfo.AddItem("YearName", year.YearName);
periodInfo.AddSection("Previous/Next");
periodInfo.AddItem("Previous", year.GetPreviousYear());
periodInfo.AddItem("Next", year.GetNextYear());
periodInfo.AddSubitems("Halfyears", year.GetHalfyears());
periodInfo.AddSubitems("Quarters", year.GetQuarters());
periodInfo.AddSubitems("Months", year.GetMonths());
SelectedPeriodInfo = periodInfo.ToString();
break;
case TimePeriodMode.Halfyear:
Halfyear halfyear = new Halfyear(WorkingDate, timeCalendar);
periodInfo.Clear();
periodInfo.AddItem("Halfyear", halfyear);
periodInfo.AddItem("YearBaseMonth", halfyear.YearBaseMonth);
periodInfo.AddItem("StartMonth", halfyear.StartMonth);
periodInfo.AddItem("Year", halfyear.Year);
periodInfo.AddItem("YearHalfyear", halfyear.YearHalfyear);
periodInfo.AddItem("IsCalendarHalfyear", halfyear.IsCalendarHalfyear);
periodInfo.AddItem("MultipleCalendarYears", halfyear.MultipleCalendarYears);
periodInfo.AddItem("HalfyearName", halfyear.HalfyearName);
periodInfo.AddItem("HalfyearOfYearName", halfyear.HalfyearOfYearName);
periodInfo.AddItem("LastDayStart", halfyear.LastDayStart);
periodInfo.AddItem("LastMonthStart", halfyear.LastMonthStart);
periodInfo.AddSection("Previous/Next");
periodInfo.AddItem("Previousr", halfyear.GetPreviousHalfyear());
periodInfo.AddItem("Next", halfyear.GetNextHalfyear());
periodInfo.AddSubitems("Quarters", halfyear.GetQuarters());
periodInfo.AddSubitems("Months", halfyear.GetMonths());
SelectedPeriodInfo = periodInfo.ToString();
break;
case TimePeriodMode.Quarter:
Quarter quarter = new Quarter(WorkingDate, timeCalendar);
periodInfo.Clear();
periodInfo.AddItem("Quarter", quarter);
periodInfo.AddItem("YearBaseMonth", quarter.YearBaseMonth);
periodInfo.AddItem("StartMonth", quarter.StartMonth);
periodInfo.AddItem("Year", quarter.Year);
periodInfo.AddItem("YearQuarter", quarter.YearQuarter);
periodInfo.AddItem("IsCalendarQuarter", quarter.IsCalendarQuarter);
periodInfo.AddItem("MultipleCalendarYears", quarter.MultipleCalendarYears);
periodInfo.AddItem("QuarterName", quarter.QuarterName);
periodInfo.AddItem("QuarterOfYearName", quarter.QuarterOfYearName);
periodInfo.AddItem("LastDayStart", quarter.FirstDayStart);
periodInfo.AddItem("LastMonthStart", quarter.LastDayStart);
periodInfo.AddSection("Previous/Next");
periodInfo.AddItem("Previous", quarter.GetPreviousQuarter());
periodInfo.AddItem("Next", quarter.GetNextQuarter());
periodInfo.AddSubitems("Months", quarter.GetMonths());
SelectedPeriodInfo = periodInfo.ToString();
break;
case TimePeriodMode.Month:
Month month = new Month(WorkingDate, timeCalendar);
periodInfo.Clear();
periodInfo.AddItem("Month", month);
periodInfo.AddItem("YearBaseMonth", month.YearMonth);
periodInfo.AddItem("Year", month.Year);
periodInfo.AddItem("DaysInMonth", month.DaysInMonth);
periodInfo.AddItem("MonthName", month.MonthName);
periodInfo.AddItem("MonthOfYearName", month.MonthOfYearName);
periodInfo.AddItem("LastDayStart", month.FirstDayStart);
periodInfo.AddItem("LastMonthStart", month.LastDayStart);
periodInfo.AddSection("Previous/Next");
periodInfo.AddItem("Previous", month.GetPreviousMonth());
periodInfo.AddItem("Next", month.GetNextMonth());
periodInfo.AddSubitems("Days", month.GetDays());
SelectedPeriodInfo = periodInfo.ToString();
break;
case TimePeriodMode.Week:
Week week = new Week(WorkingDate, timeCalendar);
periodInfo.Clear();
periodInfo.AddItem("Week", week);
periodInfo.AddItem("MultipleCalendarYears", week.MultipleCalendarYears);
periodInfo.AddItem("FirstDayStart", week.FirstDayStart);
periodInfo.AddItem("FirstDayOfWeek", week.FirstDayOfWeek);
periodInfo.AddItem("LastDayStart", week.LastDayStart);
periodInfo.AddItem("LastDayOfWeek", week.LastDayOfWeek);
periodInfo.AddItem("WeekOfYear", week.WeekOfYear);
periodInfo.AddItem("WeekOfYearName", week.WeekOfYearName);
periodInfo.AddSection("Previous/Next");
periodInfo.AddItem("Previous", week.GetPreviousWeek());
periodInfo.AddItem("Next", week.GetNextWeek());
periodInfo.AddSubitems("Days", week.GetDays());
SelectedPeriodInfo = periodInfo.ToString();
break;
case TimePeriodMode.Day:
Day day = new Day(WorkingDate, timeCalendar);
periodInfo.Clear();
periodInfo.AddItem("Day", day);
periodInfo.AddItem("Year", day.Year);
periodInfo.AddItem("FirstDayStart", day.FirstDayStart);
periodInfo.AddItem("Month", day.Month);
periodInfo.AddItem("DayValue", day.DayValue);
periodInfo.AddItem("DayOfWeek", day.DayOfWeek);
periodInfo.AddItem("DayName", day.DayName);
periodInfo.AddItem("FirstHourStart", day.FirstHourStart);
periodInfo.AddItem("LastHourStart", day.LastHourStart);
periodInfo.AddSection("Previous/Next");
periodInfo.AddItem("Previous", day.GetPreviousDay());
periodInfo.AddItem("Next", day.GetNextDay());
periodInfo.AddSubitems("Hours", day.GetHours());
SelectedPeriodInfo = periodInfo.ToString();
break;
case TimePeriodMode.Hour:
Hour hour = new Hour(WorkingDate, timeCalendar);
periodInfo.Clear();
periodInfo.AddItem("Hour", hour);
periodInfo.AddItem("Year", hour.Year);
periodInfo.AddItem("Month", hour.Month);
periodInfo.AddItem("Day", hour.Day);
periodInfo.AddItem("HourValue", hour.HourValue);
periodInfo.AddItem("FirstMinuteStart", hour.FirstMinuteStart);
periodInfo.AddItem("LastMinuteStart", hour.LastMinuteStart);
periodInfo.AddSection("Previous/Next");
periodInfo.AddItem("Previous", hour.GetPreviousHour());
periodInfo.AddItem("Next", hour.GetNextHour());
periodInfo.AddSubitems("Minutes", hour.GetMinutes());
SelectedPeriodInfo = periodInfo.ToString();
break;
case TimePeriodMode.Minute:
Minute minute = new Minute(WorkingDate, timeCalendar);
periodInfo.Clear();
periodInfo.AddItem("Minute", minute);
periodInfo.AddItem("Year", minute.Year);
periodInfo.AddItem("Month", minute.Month);
periodInfo.AddItem("Day", minute.Day);
periodInfo.AddItem("Hour", minute.Hour);
periodInfo.AddItem("MinuteValue", minute.MinuteValue);
periodInfo.AddSection("Previous/Next");
periodInfo.AddItem("Previous", minute.GetPreviousMinute());
periodInfo.AddItem("Next", minute.GetNextMinute());
SelectedPeriodInfo = periodInfo.ToString();
break;
}
} // UpdateSelectedPeriodInfo
