Files
mono/mcs/class/System.Web/System.Web.UI.WebControls/Calendar.cs
T
Gaurav Vaish 50378fcdd2 2002-03-26 Gaurav Vaish <[email protected]>
* Web/*.cs  -- Added attribute definitions.
* Web/ChangeLog -- Notification

* Web.UI.WebControls/*.cs -- Patches, to make build get going..

svn path=/trunk/mcs/; revision=3367
2002-03-26 17:49:40 +00:00

1112 lines
28 KiB
C#
Executable File

/**
* Namespace: System.Web.UI.WebControls
* Class: Calendar
*
* Author: Gaurav Vaish
* Maintainer: [email protected]
* Contact: <[email protected]>, <[email protected]>
* Implementation: yes
* Status: 98%
*
* (C) Gaurav Vaish (2001)
*/
using System;
using System.IO;
using System.Collections;
using System.Globalization;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Drawing;
using System.ComponentModel;
namespace System.Web.UI.WebControls
{
[DefaultEvent("SelectionChanged")]
[DefaultProperty("SelectedDate")]
//TODO: [Designer("??")]
//[DataBindingHandler("??")]
public class Calendar : WebControl, IPostBackEventHandler
{
//
private TableItemStyle dayHeaderStyle;
private TableItemStyle dayStyle;
private TableItemStyle nextPrevStyle;
private TableItemStyle otherMonthDayStyle;
private SelectedDatesCollection selectedDates;
private ArrayList selectedDatesList;
private TableItemStyle selectedDayStyle;
private TableItemStyle selectorStyle;
private TableItemStyle titleStyle;
private TableItemStyle todayDayStyle;
private TableItemStyle weekendDayStyle;
private static readonly object DayRenderEvent = new object();
private static readonly object SelectionChangedEvent = new object();
private static readonly object VisibleMonthChangedEvent = new object();
private Color defaultTextColor;
private System.Globalization.Calendar globCal;
private static int MASK_WEEKEND = (0x01 << 0);
private static int MASK_OMONTH = (0x01 << 1);
private static int MASK_TODAY = (0x01 << 2);
private static int MASK_SELECTED = (0x01 << 3);
private static int MASK_DAY = (0x01 << 4);
private static int MASK_UNIQUE = MASK_WEEKEND | MASK_OMONTH | MASK_TODAY | MASK_SELECTED;
public Calendar(): base()
{
//TODO: Initialization
}
public int CellPadding
{
get
{
object o = ViewState["CellPadding"];
if(o!=null)
return (int)o;
return 2;
}
set
{
ViewState["CellPadding"] = value;
}
}
public int CellSpacing
{
get
{
object o = ViewState["CellSpacing"];
if(o!=null)
return (int)o;
return 0;
}
set
{
if(value<-1)
throw new ArgumentOutOfRangeException();
ViewState["CellSpacing"] = value;
}
}
public TableItemStyle DayHeaderStyle
{
get
{
if(dayHeaderStyle==null)
dayHeaderStyle = new TableItemStyle();
if(IsTrackingViewState)
dayHeaderStyle.TrackViewState();
return dayHeaderStyle;
}
}
public DayNameFormat DayNameFormat
{
get
{
object o = ViewState["DayNameFormat"];
if(o!=null)
return (DayNameFormat)o;
return DayNameFormat.Short;
}
set
{
if(!System.Enum.IsDefined(typeof(DayNameFormat),value))
throw new ArgumentException();
ViewState["DayNameFormat"] = value;
}
}
public TableItemStyle DayStyle
{
get
{
if(dayStyle==null)
dayStyle = new TableItemStyle();
if(IsTrackingViewState)
dayStyle.TrackViewState();
return dayStyle;
}
}
public FirstDayOfWeek FirstDayOfWeek
{
get
{
object o = ViewState["FirstDayOfWeek"];
if(o!=null)
return (FirstDayOfWeek)o;
return FirstDayOfWeek.Default;
}
set
{
if(!System.Enum.IsDefined(typeof(FirstDayOfWeek), value))
throw new ArgumentException();
ViewState["FirstDayOfWeek"] = value;
}
}
public string NextMonthText
{
get
{
object o = ViewState["NextMonthText"];
if(o!=null)
return (string)o;
return "&gt;";
}
set
{
ViewState["NextMonthText"] = value;
}
}
public NextPrevFormat NextPrevFormat
{
get
{
object o = ViewState["NextPrevFormat"];
if(o!=null)
return (NextPrevFormat)o;
return NextPrevFormat.CustomText;
}
set
{
if(!System.Enum.IsDefined(typeof(NextPrevFormat), value))
throw new ArgumentException();
ViewState["NextPrevFormat"] = value;
}
}
public TableItemStyle NextPrevStyle
{
get
{
if(nextPrevStyle == null)
nextPrevStyle = new TableItemStyle();
if(IsTrackingViewState)
nextPrevStyle.TrackViewState();
return nextPrevStyle;
}
}
public TableItemStyle OtherMonthDayStyle
{
get
{
if(otherMonthDayStyle == null)
otherMonthDayStyle = new TableItemStyle();
if(IsTrackingViewState)
otherMonthDayStyle.TrackViewState();
return otherMonthDayStyle;
}
}
public string PrevMonthText
{
get
{
object o = ViewState["PrevMonthText"];
if(o!=null)
return (string)o;
return "&lt;";
}
set
{
ViewState["PrevMonthText"] = value;
}
}
public DateTime SelectedDate
{
get
{
if(SelectedDates.Count > 0)
{
return SelectedDates[0];
}
return DateTime.MinValue;
}
set
{
if(value == DateTime.MinValue)
{
SelectedDates.Clear();
} else
{
SelectedDates.SelectRange(value, value);
}
}
}
public SelectedDatesCollection SelectedDates
{
get
{
if(selectedDates==null)
{
if(selectedDatesList == null)
selectedDatesList = new ArrayList();
selectedDates = new SelectedDatesCollection(selectedDatesList);
}
return selectedDates;
}
}
public TableItemStyle SelectedDayStyle
{
get
{
if(selectedDayStyle==null)
selectedDayStyle = new TableItemStyle();
if(IsTrackingViewState)
selectedDayStyle.TrackViewState();
return selectedDayStyle;
}
}
public CalendarSelectionMode SelectionMode
{
get
{
object o = ViewState["SelectionMode"];
if(o!=null)
return (CalendarSelectionMode)o;
return CalendarSelectionMode.Day;
}
set
{
if(!System.Enum.IsDefined(typeof(CalendarSelectionMode), value))
throw new ArgumentException();
ViewState["SelectionMode"] = value;
}
}
public string SelectMonthText
{
get
{
object o = ViewState["SelectMonthText"];
if(o!=null)
return (string)o;
return "&gt;&gt;";
}
set
{
ViewState["SelectMonthText"] = value;
}
}
public TableItemStyle SelectorStyle
{
get
{
if(selectorStyle==null)
selectorStyle = new TableItemStyle();
return selectorStyle;
}
}
public string SelectWeekText
{
get
{
object o = ViewState["SelectWeekText"];
if(o!=null)
return (string)o;
return "&gt;";
}
set
{
ViewState["SelectWeekText"] = value;
}
}
public bool ShowDayHeader
{
get
{
object o = ViewState["ShowDayHeader"];
if(o!=null)
return (bool)o;
return true;
}
set
{
ViewState["ShowDayHeader"] = value;
}
}
public bool ShowGridLines
{
get
{
object o = ViewState["ShowGridLines"];
if(o!=null)
return (bool)o;
return false;
}
set
{
ViewState["ShowGridLines"] = value;
}
}
public bool ShowNextPrevMonth
{
get
{
object o = ViewState["ShowNextPrevMonth"];
if(o!=null)
return (bool)o;
return true;
}
set
{
ViewState["ShowNextPrevMonth"] = value;
}
}
public bool ShowTitle
{
get
{
object o = ViewState["ShowTitle"];
if(o!=null)
return (bool)o;
return true;
}
set
{
ViewState["ShowTitle"] = value;
}
}
public TitleFormat TitleFormat
{
get
{
object o = ViewState["TitleFormat"];
if(o!=null)
return (TitleFormat)o;
return TitleFormat.MonthYear;
}
set
{
if(!System.Enum.IsDefined(typeof(TitleFormat), value))
throw new ArgumentException();
ViewState["TitleFormat"] = value;
}
}
public TableItemStyle TitleStyle
{
get
{
if(titleStyle==null)
titleStyle = new TableItemStyle();
if(IsTrackingViewState)
titleStyle.TrackViewState();
return titleStyle;
}
}
public TableItemStyle TodayDayStyle
{
get
{
if(todayDayStyle==null)
todayDayStyle = new TableItemStyle();
if(IsTrackingViewState)
todayDayStyle.TrackViewState();
return todayDayStyle;
}
}
public DateTime TodaysDate
{
get
{
object o = ViewState["TodaysDate"];
if(o!=null)
return (DateTime)o;
return DateTime.Today;
}
set
{
ViewState["TodaysDate"] = value;
}
}
public DateTime VisibleDate
{
get
{
object o = ViewState["VisibleDate"];
if(o!=null)
return (DateTime)o;
return DateTime.MinValue;
}
set
{
ViewState["VisibleDate"] = value;
}
}
public TableItemStyle WeekendDayStyle
{
get
{
if(weekendDayStyle == null)
weekendDayStyle = new TableItemStyle();
if(IsTrackingViewState)
{
weekendDayStyle.TrackViewState();
}
return weekendDayStyle;
}
}
public event DayRenderEventHandler DayRender
{
add
{
Events.AddHandler(DayRenderEvent, value);
}
remove
{
Events.RemoveHandler(DayRenderEvent, value);
}
}
public event EventHandler SelectionChanged
{
add
{
Events.AddHandler(SelectionChangedEvent, value);
}
remove
{
Events.RemoveHandler(SelectionChangedEvent, value);
}
}
public event MonthChangedEventHandler VisibleMonthChanged
{
add
{
Events.AddHandler(VisibleMonthChangedEvent, value);
}
remove
{
Events.RemoveHandler(VisibleMonthChangedEvent, value);
}
}
protected virtual void OnDayRender(TableCell cell, CalendarDay day)
{
if(Events!=null)
{
DayRenderEventHandler dreh = (DayRenderEventHandler)(Events[DayRenderEvent]);
if(dreh!=null)
dreh(this, new DayRenderEventArgs(cell, day));
}
}
protected virtual void OnSelectionChanged()
{
if(Events!=null)
{
EventHandler eh = (EventHandler)(Events[SelectionChangedEvent]);
if(eh!=null)
eh(this, new EventArgs());
}
}
protected virtual void OnVisibleMonthChanged(DateTime newDate, DateTime prevDate)
{
if(Events!=null)
{
MonthChangedEventHandler mceh = (MonthChangedEventHandler)(Events[VisibleMonthChangedEvent]);
if(mceh!=null)
mceh(this, new MonthChangedEventArgs(newDate, prevDate));
}
}
/// <remarks>
/// See test6.aspx in Tests directory for verification
/// </remarks>
void IPostBackEventHandler.RaisePostBackEvent(string eventArgument)
{
globCal = DateTimeFormatInfo.CurrentInfo.Calendar;
DateTime visDate = GetEffectiveVisibleDate();
//FIXME: Should it be String.Compare(eventArgument, "nextMonth", false);
if(eventArgument == "nextMonth")
{
VisibleDate = globCal.AddMonths(visDate, 1);
OnVisibleMonthChanged(VisibleDate, visDate);
return;
}
if(eventArgument == "prevMonth")
{
VisibleDate = globCal.AddMonths(visDate, -1);
OnVisibleMonthChanged(VisibleDate, visDate);
return;
}
if(eventArgument == "selectMonth")
{
DateTime oldDate = new DateTime(globCal.GetYear(visDate), globCal.GetMonth(visDate), 1, globCal);
SelectRangeInternal(oldDate, globCal.AddDays(globCal.AddMonths(oldDate, 1), -1), visDate);
return;
}
if(String.Compare(eventArgument, 0, "selectWeek", 0, "selectWeek".Length)==0)
{
int week = -1;
try
{
week = Int32.Parse(eventArgument.Substring("selectWeek".Length));
} catch(Exception e)
{
}
if(week >= 0 && week <= 5)
{
DateTime weekStart = globCal.AddDays(GetFirstCalendarDay(visDate), week * 7);
SelectRangeInternal(weekStart, globCal.AddDays(weekStart, 6), visDate);
}
return;
}
if(String.Compare(eventArgument, 0, "selectDay", 0, "selectDay".Length)==0)
{
int day = -1;
try
{
day = Int32.Parse(eventArgument.Substring("selectDay".Length));
} catch(Exception e)
{
}
if(day >= 0 && day <= 42)
{
DateTime dayStart = globCal.AddDays(GetFirstCalendarDay(visDate), day);
SelectRangeInternal(dayStart, dayStart, visDate);
}
}
}
protected override void Render(HtmlTextWriter writer)
{
//TODO: Implement me
globCal = DateTimeFormatInfo.CurrentInfo.Calendar;
DateTime visDate = GetEffectiveVisibleDate();
DateTime firstDate = GetFirstCalendarDay(visDate);
bool isEnabled = false;
bool isHtmlTextWriter = false;
if(Page == null || Site == null)
{
isEnabled = false;
isHtmlTextWriter = false;
} else
{
isEnabled = Enabled;
isHtmlTextWriter = (writer.GetType() != typeof(HtmlTextWriter));
}
defaultTextColor = ForeColor;
if(defaultTextColor == Color.Empty)
defaultTextColor = Color.Black;
Table calTable = new Table();
calTable.ID = ID;
calTable.CopyBaseAttributes(this);
if(ControlStyleCreated)
ApplyStyle(ControlStyle);
calTable.Width = Width;
calTable.Height = Height;
calTable.CellSpacing = CellSpacing;
calTable.CellPadding = CellPadding;
if(ControlStyleCreated && ControlStyle.IsSet(WebControls.Style.BORDERWIDTH) && BorderWidth != Unit.Empty)
{
calTable.BorderWidth = BorderWidth;
} else
{
calTable.BorderWidth = Unit.Pixel(1);
}
if(ShowGridLines)
calTable.GridLines = GridLines.Both;
else
calTable.GridLines = GridLines.None;
calTable.RenderBeginTag(writer);
if(ShowTitle)
RenderTitle(writer, visDate, SelectionMode, isEnabled);
if(ShowDayHeader)
RenderHeader(writer, firstDate, SelectionMode, isEnabled, isHtmlTextWriter);
RenderAllDays(writer, firstDate, visDate, SelectionMode, isEnabled, isHtmlTextWriter);
calTable.RenderEndTag(writer);
}
protected override ControlCollection CreateControlCollection()
{
return new EmptyControlCollection(this);
}
protected override void LoadViewState(object savedState)
{
if(savedState!=null)
{
if(ViewState["_CalendarSelectedDates"] != null)
selectedDates = (SelectedDatesCollection)ViewState["_CalendarSelectedDates"];
object[] states = (object[]) savedState;
if(states[0] != null)
base.LoadViewState(states[0]);
if(states[1] != null)
DayHeaderStyle.LoadViewState(states[1]);
if(states[2] != null)
DayStyle.LoadViewState(states[2]);
if(states[3] != null)
NextPrevStyle.LoadViewState(states[3]);
if(states[4] != null)
OtherMonthDayStyle.LoadViewState(states[4]);
if(states[5] != null)
SelectedDayStyle.LoadViewState(states[5]);
if(states[6] != null)
SelectorStyle.LoadViewState(states[6]);
if(states[7] != null)
TitleStyle.LoadViewState(states[7]);
if(states[8] != null)
TodayDayStyle.LoadViewState(states[8]);
if(states[9] != null)
WeekendDayStyle.LoadViewState(states[9]);
}
}
protected override object SaveViewState()
{
ViewState["_CalendarSelectedDates"] = (SelectedDates.Count > 0 ? selectedDates : null);
object[] states = new object[11];
states[0] = base.SaveViewState();
states[1] = (dayHeaderStyle == null ? null : dayHeaderStyle.SaveViewState());
states[2] = (dayStyle == null ? null : dayStyle.SaveViewState());
states[3] = (nextPrevStyle == null ? null : nextPrevStyle.SaveViewState());
states[4] = (otherMonthDayStyle == null ? null : otherMonthDayStyle.SaveViewState());
states[5] = (selectedDayStyle == null ? null : selectedDayStyle.SaveViewState());
states[6] = (selectorStyle == null ? null : selectorStyle.SaveViewState());
states[7] = (titleStyle == null ? null : titleStyle.SaveViewState());
states[8] = (todayDayStyle == null ? null : todayDayStyle.SaveViewState());
states[9] = (weekendDayStyle == null ? null : weekendDayStyle.SaveViewState());
for(int i=0; i < states.Length; i++)
{
if(states[i]!=null)
return states;
}
return null;
}
protected override void TrackViewState()
{
TrackViewState();
if(titleStyle!=null)
{
titleStyle.TrackViewState();
}
if(nextPrevStyle!=null)
{
nextPrevStyle.TrackViewState();
}
if(dayStyle!=null)
{
dayStyle.TrackViewState();
}
if(dayHeaderStyle!=null)
{
dayHeaderStyle.TrackViewState();
}
if(todayDayStyle!=null)
{
todayDayStyle.TrackViewState();
}
if(weekendDayStyle!=null)
{
weekendDayStyle.TrackViewState();
}
if(otherMonthDayStyle!=null)
{
otherMonthDayStyle.TrackViewState();
}
if(selectedDayStyle!=null)
{
selectedDayStyle.TrackViewState();
}
if(selectorStyle!=null)
{
selectorStyle.TrackViewState();
}
}
[MonoTODO("RenderAllDays")]
private void RenderAllDays(HtmlTextWriter writer, DateTime firstDay, DateTime activeDate, CalendarSelectionMode mode, bool isActive, bool isDownLevel)
{
/*
TableItemStyle weeksStyle;
Unit size;
string weeksCellData;
bool isWeekMode = (mode == CalendarSelectionMode.DayWeek || mode == CalendarSelectionMode.DayWeekMonth);
if(isWeekMode)
{
weeksStyle = new TableItemStyle();
weeksStyle.Width = Unit.Percentage(12);
weeksStyle.HorizontalAlign = HorizontalAlign.Center;
weeksStyle.CopyFrom(SelectorStyle);
size = Unit.Percentage(14);
if(!isDownLevel)
weeksCellData = GetHtmlForCell(weeksCell, isActive);
}
bool dayRenderBool = false;
if(GetType() != typeof(Calendar) || Events[DayRenderEvent] != null || !isDownLevel)
dayRenderBool = true;
string[] content = new string[0x01 << 4];
int definedStyles = MASK_SELECTED;
if(weekendStyle != null && !weekendStyle.IsEmpty)
definedStyles |= MASK_WEEKEND;
if(otherMonthStyle != null && !otherMonthStyle.IsEmpty)
definedStyles |= MASK_OMONTH;
if(todayDayStyle != null && todayDayStyle.IsEmpty)
definedStyles |= MASK_TODAY;
if(dayStyle != null && !dayStyle.IsEmpty)
definedStyles |= MASK_DAY;
bool selectDayBool = false;
if(isActive && mode != CalendarSelectionMode.None)
{
selectDayBool = true;
}
for(int crr = 0; crr < 6; crr++)
{
writer.Write("<tr>");
if(isWeekMode)
{
if(isDownLevel)
{
string cellText = GetCalendarLinkText("selectWeek" + crr.ToString(), SelectWeekText, isActive, weeksCell.ForeColor);
weeksCell.Text = cellText;
RenderCalendarCell(writer, weeksCell, cellText);
} else
{
if(isActive)
{
writer.Write(String.Format(weeksCellData, "selectWeek" + crr.ToString(), SelectWeekText));
} else
{
writer.Write(String.Format(weeksCellData, "selectWeek" + crr.ToString()));
}
}
}
for(int crc = 0; crc < 7; crc++)
{
// have to display for each day in the week.
throw new NotImplementedException();
}
}
*/
throw new NotImplementedException();
}
private int GetMask(CalendarDay day)
{
int retVal = MASK_DAY;
if(day.IsSelected)
retVal |= MASK_SELECTED;
if(day.IsToday)
retVal |= MASK_TODAY;
if(day.IsOtherMonth)
retVal |= MASK_OMONTH;
if(day.IsWeekend)
retVal |= MASK_WEEKEND;
return retVal;
}
/// <remarks>
/// Refers to the second line of the calendar, that contains a link
/// to select whole month, and weekdays as defined by DayNameFormat
/// </remarks>
private void RenderHeader(HtmlTextWriter writer, DateTime firstDay, CalendarSelectionMode mode, bool isActive, bool isDownLevel)
{
writer.Write("<tr>");
bool isWeekMode = (mode == CalendarSelectionMode.DayWeek || mode == CalendarSelectionMode.DayWeekMonth);
TableCell headerCell = new TableCell();
headerCell.HorizontalAlign = HorizontalAlign.Center;
string selMthText = String.Empty;
if(isWeekMode)
{
headerCell.ApplyStyle(SelectorStyle);
selMthText = GetCalendarLinkText("selectMonth", SelectMonthText, SelectorStyle.ForeColor, isActive);
} else
{
headerCell.ApplyStyle(DayHeaderStyle);
}
RenderCalendarCell(writer, headerCell, selMthText);
TableCell dayHeaderCell = new TableCell();
dayHeaderCell.HorizontalAlign = HorizontalAlign.Center;
string content = null;
if(!isDownLevel)
{
content = GetHtmlForCell(dayHeaderCell, isActive);
}
int dayOfWeek = (int)globCal.GetDayOfWeek(firstDay);
DateTimeFormatInfo currDTInfo = DateTimeFormatInfo.CurrentInfo;
for(int currDay = dayOfWeek; currDay < dayOfWeek + 7; currDay++)
{
DayOfWeek effDay = (DayOfWeek) Enum.ToObject(typeof(DayOfWeek),currDay % 7);
string currDayContent = String.Empty;
switch(DayNameFormat)
{
case DayNameFormat.Full: currDayContent = currDTInfo.GetDayName(effDay);
break;
case DayNameFormat.FirstLetter: currDayContent = currDTInfo.GetDayName(effDay).Substring(0,1);
break;
case DayNameFormat.FirstTwoLetters: currDayContent = currDTInfo.GetDayName(effDay).Substring(0,2);
break;
case DayNameFormat.Short: goto default;
default: currDayContent = currDTInfo.GetAbbreviatedDayName(effDay);
break;
}
if(isDownLevel)
{
RenderCalendarCell(writer, dayHeaderCell, currDayContent);
} else
{
writer.Write(String.Format(content, currDayContent));
}
}
writer.Write("</tr>");
}
private void RenderTitle(HtmlTextWriter writer, DateTime visibleDate, CalendarSelectionMode mode, bool isActive)
{
writer.Write("<tr>");
Table innerTable = new Table();
TableCell titleCell = new TableCell();
bool isWeekMode = (mode == CalendarSelectionMode.DayWeek || mode == CalendarSelectionMode.DayWeekMonth);
titleCell.ColumnSpan = (isWeekMode ? 8 : 7);
titleCell.BackColor = Color.Silver;
innerTable.GridLines = GridLines.None;
innerTable.Width = Unit.Percentage(100);
innerTable.CellSpacing = 0;
ApplyTitleStyle(innerTable, titleCell, TitleStyle);
innerTable.RenderBeginTag(writer);
titleCell.RenderBeginTag(writer);
writer.Write("<tr>");
string prevContent = String.Empty;
if(ShowNextPrevMonth)
{
TableCell prevCell = new TableCell();
prevCell.Width = Unit.Percentage(15);
prevCell.HorizontalAlign = HorizontalAlign.Left;
if(NextPrevFormat == NextPrevFormat.CustomText)
{
prevContent = PrevMonthText;
} else
{
int pMthInt = globCal.GetMonth(globCal.AddMonths(visibleDate, -1));
if(NextPrevFormat == NextPrevFormat.FullMonth)
prevContent = DateTimeFormatInfo.CurrentInfo.GetMonthName(pMthInt);
else
prevContent = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedMonthName(pMthInt);
}
prevCell.ApplyStyle(NextPrevStyle);
RenderCalendarCell(writer, prevCell, GetCalendarLinkText("prevMonth", prevContent, NextPrevStyle.ForeColor, isActive));
}
TableCell currCell = new TableCell();
currCell.Width = Unit.Percentage(70);
if(TitleStyle.HorizontalAlign == HorizontalAlign.NotSet)
currCell.HorizontalAlign = HorizontalAlign.Center;
else
currCell.HorizontalAlign = TitleStyle.HorizontalAlign;
currCell.Wrap = TitleStyle.Wrap;
string currMonthContent = String.Empty;
if(TitleFormat == TitleFormat.Month)
{
currMonthContent = visibleDate.ToString("MMMM");
} else
{
string cmcFmt = DateTimeFormatInfo.CurrentInfo.YearMonthPattern;
if(cmcFmt.IndexOf(',') >= 0)
{
cmcFmt = "MMMM yyyy";
}
currMonthContent = visibleDate.ToString(cmcFmt);
}
string nextContent = String.Empty;
if(ShowNextPrevMonth)
{
TableCell nextCell = new TableCell();
nextCell.Width = Unit.Percentage(15);
nextCell.HorizontalAlign = HorizontalAlign.Left;
if(NextPrevFormat == NextPrevFormat.CustomText)
{
nextContent = PrevMonthText;
} else
{
int nMthInt = globCal.GetMonth(globCal.AddMonths(visibleDate, 1));
if(NextPrevFormat == NextPrevFormat.FullMonth)
nextContent = DateTimeFormatInfo.CurrentInfo.GetMonthName(nMthInt);
else
nextContent = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedMonthName(nMthInt);
}
nextCell.ApplyStyle(NextPrevStyle);
RenderCalendarCell(writer, nextCell, GetCalendarLinkText("nextMonth", nextContent, NextPrevStyle.ForeColor, isActive));
}
writer.Write("</tr>");
titleCell.RenderEndTag(writer);
innerTable.RenderEndTag(writer);
writer.Write("</tr>");
}
private void ApplyTitleStyle(Table table, TableCell cell, TableItemStyle style)
{
if(style.BackColor != Color.Empty)
{
cell.BackColor = style.BackColor;
}
if(style.BorderStyle != BorderStyle.NotSet)
{
cell.BorderStyle = style.BorderStyle;
}
if(style.BorderColor != Color.Empty)
{
cell.BorderColor = style.BorderColor;
}
if(style.BorderWidth != Unit.Empty)
{
cell.BorderWidth = style.BorderWidth;
}
if(style.Height != Unit.Empty)
{
cell.Height = style.Height;
}
if(style.VerticalAlign != VerticalAlign.NotSet)
{
cell.VerticalAlign = style.VerticalAlign;
}
if(style.ForeColor != Color.Empty)
{
table.ForeColor = style.ForeColor;
} else if(ForeColor != Color.Empty)
{
table.ForeColor = ForeColor;
}
table.Font.CopyFrom(style.Font);
table.Font.MergeWith(Font);
}
private void RenderCalendarCell(HtmlTextWriter writer, TableCell cell, string text)
{
cell.RenderBeginTag(writer);
writer.Write(text);
cell.RenderEndTag(writer);
}
private DateTime GetFirstCalendarDay(DateTime visibleDate)
{
DayOfWeek firstDay = DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek;
if(FirstDayOfWeek != FirstDayOfWeek.Default)
{
firstDay = (DayOfWeek) Enum.ToObject(typeof(DayOfWeek), (int)FirstDayOfWeek);
}
//FIXME: is (int)(Enum) correct?
int days = (int)globCal.GetDayOfWeek(visibleDate) - (int)firstDay;
if(days < 0)
{
days += 7;
}
return globCal.AddDays(visibleDate, -days);
}
private DateTime GetEffectiveVisibleDate()
{
DateTime dt = VisibleDate;
if(dt.Equals(DateTime.MinValue))
{
dt = TodaysDate;
}
return new DateTime(globCal.GetYear(dt), globCal.GetMonth(dt), globCal.GetDayOfMonth(dt), globCal);
}
/// <summary>
/// Creates text to be displayed, with all attributes if to be
/// shown as a hyperlink
/// </summary>
private string GetCalendarLinkText(string eventArg, string text, Color foreground, bool isLink)
{
if(isLink)
{
StringBuilder dispVal = new StringBuilder();
dispVal.Append("<a href=\"");
dispVal.Append(Page.GetPostBackClientHyperlink(this, eventArg));
dispVal.Append("\" style=\"color: ");
if(foreground.IsEmpty)
{
dispVal.Append(ColorTranslator.ToHtml(defaultTextColor));
} else
{
dispVal.Append(ColorTranslator.ToHtml(foreground));
}
dispVal.Append("\">");
dispVal.Append(text);
dispVal.Append("</a>");
return dispVal.ToString();
}
return text;
}
private string GetHtmlForCell(TableCell cell, bool showLinks)
{
StringWriter sw = new StringWriter();
HtmlTextWriter htw = new HtmlTextWriter(sw);
cell.RenderBeginTag(htw);
if(showLinks)
{
htw.Write(GetCalendarLinkText("{0}", "{1}", cell.ForeColor, showLinks));
} else
{
htw.Write("{0}");
}
cell.RenderEndTag(htw);
return sw.ToString();
}
internal void SelectRangeInternal(DateTime fromDate, DateTime toDate, DateTime visibleDate)
{
TimeSpan span = fromDate - toDate;
if(SelectedDates.Count != span.Days || SelectedDates[SelectedDates.Count - 1]!= toDate)
{
SelectedDates.SelectRange(fromDate, toDate);
OnSelectionChanged();
}
if(globCal.GetMonth(fromDate) == globCal.GetMonth(fromDate) && globCal.GetMonth(fromDate) != globCal.GetMonth(visibleDate))
{
VisibleDate = new DateTime(globCal.GetYear(fromDate), globCal.GetMonth(fromDate), 1, globCal);
OnVisibleMonthChanged(VisibleDate, visibleDate);
}
}
}
}