1114 lines
31 KiB
C#
1114 lines
31 KiB
C#
//
|
|
// System.Web.UI.WebControls.Calendar.cs
|
|
//
|
|
// Authors:
|
|
// Jordi Mas i Hernandez (jordi@ximian.com)
|
|
//
|
|
// (C) 2005-2010 Novell, Inc (http://www.novell.com)
|
|
//
|
|
//
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
//
|
|
|
|
using System.Globalization;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Security.Permissions;
|
|
using System.Threading;
|
|
using System.Text;
|
|
using System.Web.Util;
|
|
|
|
namespace System.Web.UI.WebControls
|
|
{
|
|
// CAS
|
|
[AspNetHostingPermissionAttribute (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
|
[AspNetHostingPermissionAttribute (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
|
// attributes
|
|
[DataBindingHandler("System.Web.UI.Design.WebControls.CalendarDataBindingHandler, " + Consts.AssemblySystem_Design)]
|
|
[DefaultEvent("SelectionChanged")]
|
|
[DefaultProperty("SelectedDate")]
|
|
[Designer("System.Web.UI.Design.WebControls.CalendarDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
|
|
[ControlValueProperty ("SelectedDate", "1/1/0001 12:00:00 AM")]
|
|
[SupportsEventValidation]
|
|
public class Calendar : WebControl, IPostBackEventHandler
|
|
{
|
|
TableItemStyle dayHeaderStyle;
|
|
TableItemStyle dayStyle;
|
|
TableItemStyle nextPrevStyle;
|
|
TableItemStyle otherMonthDayStyle;
|
|
TableItemStyle selectedDayStyle;
|
|
TableItemStyle titleStyle;
|
|
TableItemStyle todayDayStyle;
|
|
TableItemStyle selectorStyle;
|
|
TableItemStyle weekendDayStyle;
|
|
DateTimeFormatInfo dateInfo;
|
|
SelectedDatesCollection selectedDatesCollection;
|
|
ArrayList dateList;
|
|
DateTime today = DateTime.Today;
|
|
static DateTime dateZenith = new DateTime (2000, 1,1);
|
|
const int daysInAWeek = 7;
|
|
static readonly object DayRenderEvent = new object ();
|
|
static readonly object SelectionChangedEvent = new object ();
|
|
static readonly object VisibleMonthChangedEvent = new object ();
|
|
|
|
public Calendar ()
|
|
{
|
|
}
|
|
|
|
[Localizable (true)]
|
|
[DefaultValue ("")]
|
|
[WebSysDescription ("")]
|
|
[WebCategoryAttribute ("Appearance")]
|
|
public virtual string Caption {
|
|
get { return ViewState.GetString ("Caption", String.Empty); }
|
|
set { ViewState["Caption"] = value; }
|
|
}
|
|
|
|
[DefaultValue (TableCaptionAlign.NotSet)]
|
|
[WebSysDescription ("")]
|
|
[WebCategoryAttribute ("Accessibility")]
|
|
public virtual TableCaptionAlign CaptionAlign {
|
|
get { return (TableCaptionAlign)ViewState.GetInt ("CaptionAlign", (int)TableCaptionAlign.NotSet); }
|
|
set { ViewState ["CaptionAlign"] = value; }
|
|
}
|
|
|
|
[DefaultValue(2)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Layout")]
|
|
public int CellPadding {
|
|
get { return ViewState.GetInt ("CellPadding", 2); }
|
|
|
|
set {
|
|
if (value < -1)
|
|
throw new ArgumentOutOfRangeException ("The specified cell padding is less than -1.");
|
|
|
|
ViewState ["CellPadding"] = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(0)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Layout")]
|
|
public int CellSpacing {
|
|
get { return ViewState.GetInt ("CellSpacing", 0); }
|
|
|
|
set {
|
|
if (value < -1)
|
|
throw new ArgumentOutOfRangeException ("The specified cell spacing is less than -1");
|
|
|
|
ViewState ["CellSpacing"] = value;
|
|
}
|
|
}
|
|
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[NotifyParentProperty(true)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle DayHeaderStyle {
|
|
get {
|
|
if (dayHeaderStyle == null) {
|
|
dayHeaderStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
dayHeaderStyle.TrackViewState ();
|
|
}
|
|
|
|
return dayHeaderStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(DayNameFormat.Short)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public DayNameFormat DayNameFormat {
|
|
get { return (DayNameFormat) ViewState.GetInt ("DayNameFormat", (int) DayNameFormat.Short); }
|
|
|
|
set {
|
|
if (value != DayNameFormat.FirstLetter && value != DayNameFormat.FirstTwoLetters &&
|
|
value != DayNameFormat.Full && value != DayNameFormat.Short && value != DayNameFormat.Shortest) {
|
|
throw new ArgumentOutOfRangeException ("The specified day name format is not one of the DayNameFormat values.");
|
|
}
|
|
|
|
ViewState ["DayNameFormat"] = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(null)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[NotifyParentProperty(true)]
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle DayStyle {
|
|
get {
|
|
if (dayStyle == null) {
|
|
dayStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
dayStyle.TrackViewState ();
|
|
}
|
|
|
|
return dayStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(FirstDayOfWeek.Default)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public FirstDayOfWeek FirstDayOfWeek {
|
|
get { return (FirstDayOfWeek) ViewState.GetInt ("FirstDayOfWeek", (int) FirstDayOfWeek.Default); }
|
|
|
|
set {
|
|
if (value < FirstDayOfWeek.Sunday || value > FirstDayOfWeek.Default) {
|
|
throw new ArgumentOutOfRangeException ("The specified day name format is not one of the DayNameFormat values.");
|
|
}
|
|
|
|
ViewState ["FirstDayOfWeek"] = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(">")]
|
|
[Localizable (true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public string NextMonthText {
|
|
get { return ViewState.GetString ("NextMonthText", ">"); }
|
|
set { ViewState ["NextMonthText"] = value; }
|
|
}
|
|
|
|
[DefaultValue(NextPrevFormat.CustomText)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public NextPrevFormat NextPrevFormat {
|
|
get { return (NextPrevFormat) ViewState.GetInt ("NextPrevFormat", (int) NextPrevFormat.CustomText); }
|
|
|
|
set {
|
|
if (value != NextPrevFormat.CustomText && value != NextPrevFormat.ShortMonth && value != NextPrevFormat.FullMonth)
|
|
throw new ArgumentOutOfRangeException ("The specified day name format is not one of the DayNameFormat values.");
|
|
|
|
ViewState ["NextPrevFormat"] = value;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[NotifyParentProperty(true)]
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle NextPrevStyle {
|
|
get {
|
|
if (nextPrevStyle == null) {
|
|
nextPrevStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
nextPrevStyle.TrackViewState ();
|
|
}
|
|
|
|
return nextPrevStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(null)]
|
|
[NotifyParentProperty(true)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle OtherMonthDayStyle {
|
|
get {
|
|
if (otherMonthDayStyle == null) {
|
|
otherMonthDayStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
otherMonthDayStyle.TrackViewState ();
|
|
}
|
|
|
|
return otherMonthDayStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue("<")]
|
|
[Localizable (true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public string PrevMonthText {
|
|
get { return ViewState.GetString ("PrevMonthText", "<"); }
|
|
set { ViewState ["PrevMonthText"] = value; }
|
|
}
|
|
|
|
[Bindable(true, BindingDirection.TwoWay)]
|
|
[DefaultValue("1/1/0001 12:00:00 AM")]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public DateTime SelectedDate {
|
|
get {
|
|
if (SelectedDates.Count > 0)
|
|
return SelectedDates [0];
|
|
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
set { SelectedDates.SelectRange (value, value); }
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public SelectedDatesCollection SelectedDates {
|
|
get {
|
|
if (dateList == null)
|
|
dateList = new ArrayList ();
|
|
|
|
if (selectedDatesCollection == null)
|
|
selectedDatesCollection = new SelectedDatesCollection (dateList);
|
|
|
|
return selectedDatesCollection;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(null)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[NotifyParentProperty(true)]
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle SelectedDayStyle {
|
|
get {
|
|
if (selectedDayStyle == null) {
|
|
selectedDayStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
selectedDayStyle.TrackViewState ();
|
|
}
|
|
|
|
return selectedDayStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(CalendarSelectionMode.Day)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Behavior")]
|
|
public CalendarSelectionMode SelectionMode {
|
|
get { return (CalendarSelectionMode) ViewState.GetInt ("SelectionMode", (int) CalendarSelectionMode.Day); }
|
|
|
|
set {
|
|
if (value != CalendarSelectionMode.Day && value != CalendarSelectionMode.DayWeek &&
|
|
value != CalendarSelectionMode.DayWeekMonth && value != CalendarSelectionMode.None) {
|
|
throw new ArgumentOutOfRangeException ("The specified selection mode is not one of the CalendarSelectionMode values.");
|
|
}
|
|
ViewState ["SelectionMode"] = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(">>")]
|
|
[Localizable (true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public string SelectMonthText {
|
|
get { return ViewState.GetString ("SelectMonthText", ">>"); }
|
|
set { ViewState ["SelectMonthText"] = value; }
|
|
}
|
|
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[NotifyParentProperty(true)]
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle SelectorStyle {
|
|
get {
|
|
if (selectorStyle == null) {
|
|
selectorStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
selectorStyle.TrackViewState ();
|
|
}
|
|
|
|
return selectorStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(">")]
|
|
[Localizable (true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public string SelectWeekText {
|
|
get { return ViewState.GetString ("SelectWeekText", ">"); }
|
|
set { ViewState ["SelectWeekText"] = value; }
|
|
}
|
|
|
|
[DefaultValue(true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public bool ShowDayHeader {
|
|
get { return ViewState.GetBool ("ShowDayHeader", true); }
|
|
set { ViewState ["ShowDayHeader"] = value; }
|
|
}
|
|
|
|
[DefaultValue(false)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public bool ShowGridLines {
|
|
get { return ViewState.GetBool ("ShowGridLines", false); }
|
|
set { ViewState ["ShowGridLines"] = value; }
|
|
}
|
|
|
|
[DefaultValue(true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public bool ShowNextPrevMonth {
|
|
get { return ViewState.GetBool ("ShowNextPrevMonth", true); }
|
|
set { ViewState ["ShowNextPrevMonth"] = value; }
|
|
}
|
|
|
|
[DefaultValue(true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public bool ShowTitle {
|
|
get { return ViewState.GetBool ("ShowTitle", true); }
|
|
set { ViewState ["ShowTitle"] = value; }
|
|
}
|
|
|
|
[DefaultValue(TitleFormat.MonthYear)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public TitleFormat TitleFormat {
|
|
get { return (TitleFormat) ViewState.GetInt ("TitleFormat", (int) TitleFormat.MonthYear); }
|
|
|
|
set {
|
|
if (value != TitleFormat.Month && value != TitleFormat.MonthYear) {
|
|
throw new ArgumentOutOfRangeException ("The specified title format is not one of the TitleFormat values.");
|
|
}
|
|
|
|
ViewState ["TitleFormat"] = value;
|
|
}
|
|
}
|
|
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[NotifyParentProperty(true)]
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle TitleStyle {
|
|
get {
|
|
if (titleStyle == null) {
|
|
titleStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
titleStyle.TrackViewState ();
|
|
}
|
|
|
|
return titleStyle;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(null)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[NotifyParentProperty(true)]
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle TodayDayStyle {
|
|
get {
|
|
if (todayDayStyle == null) {
|
|
todayDayStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
todayDayStyle.TrackViewState ();
|
|
}
|
|
|
|
return todayDayStyle;
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public DateTime TodaysDate {
|
|
get {
|
|
object obj = ViewState ["TodaysDate"];
|
|
|
|
if (obj != null)
|
|
return (DateTime) obj;
|
|
|
|
return today;
|
|
}
|
|
|
|
set { ViewState ["TodaysDate"] = value.Date; }
|
|
}
|
|
|
|
[DefaultValue (true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategoryAttribute ("Accessibility")]
|
|
public virtual bool UseAccessibleHeader {
|
|
get { return ViewState.GetBool ("UseAccessibleHeader", true); }
|
|
set { ViewState ["UseAccessibleHeader"] = value; }
|
|
}
|
|
|
|
[Bindable(true)]
|
|
[DefaultValue("1/1/0001 12:00:00 AM")]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public DateTime VisibleDate {
|
|
get {
|
|
object obj = ViewState ["VisibleDate"];
|
|
|
|
if (obj != null)
|
|
return (DateTime) obj;
|
|
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
set { ViewState ["VisibleDate"] = value.Date; }
|
|
}
|
|
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[NotifyParentProperty(true)]
|
|
[PersistenceMode(PersistenceMode.InnerProperty)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public TableItemStyle WeekendDayStyle {
|
|
get {
|
|
if (weekendDayStyle == null) {
|
|
weekendDayStyle = new TableItemStyle ();
|
|
if (IsTrackingViewState)
|
|
weekendDayStyle.TrackViewState ();
|
|
}
|
|
|
|
return weekendDayStyle;
|
|
}
|
|
}
|
|
public override bool SupportsDisabledAttribute {
|
|
get { return RenderingCompatibilityLessThan40; }
|
|
}
|
|
// Private properties
|
|
DateTimeFormatInfo DateInfo {
|
|
get {
|
|
if (dateInfo == null)
|
|
dateInfo = Thread.CurrentThread.CurrentCulture.DateTimeFormat;
|
|
|
|
return dateInfo;
|
|
}
|
|
}
|
|
|
|
DateTime DisplayDate {
|
|
get {
|
|
DateTime dateTime = VisibleDate;
|
|
if (dateTime == DateTime.MinValue) // If visibledate is still the default value
|
|
dateTime = TodaysDate;
|
|
|
|
return dateTime;
|
|
}
|
|
}
|
|
|
|
DayOfWeek DisplayFirstDayOfWeek {
|
|
get {
|
|
if (FirstDayOfWeek != FirstDayOfWeek.Default)
|
|
return (DayOfWeek) FirstDayOfWeek;
|
|
|
|
return (DayOfWeek) DateInfo.FirstDayOfWeek;
|
|
}
|
|
}
|
|
|
|
protected override ControlCollection CreateControlCollection ()
|
|
{
|
|
return base.CreateControlCollection ();
|
|
}
|
|
|
|
protected bool HasWeekSelectors (CalendarSelectionMode selectionMode)
|
|
{
|
|
if (selectionMode == CalendarSelectionMode.DayWeek || selectionMode == CalendarSelectionMode.DayWeekMonth)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void IPostBackEventHandler.RaisePostBackEvent (string eventArgument)
|
|
{
|
|
RaisePostBackEvent (eventArgument);
|
|
}
|
|
|
|
protected virtual void RaisePostBackEvent (string eventArgument)
|
|
{
|
|
ValidateEvent (UniqueID, eventArgument);
|
|
if (eventArgument.Length < 1)
|
|
return;
|
|
|
|
if (eventArgument[0] == 'V') { // Goes to Next or Previous month
|
|
DateTime prev = VisibleDate;
|
|
int days = Int32.Parse (eventArgument.Substring (1));
|
|
DateTime dt = GetGlobalCalendar().AddDays (dateZenith, days);
|
|
VisibleDate = dt;
|
|
OnVisibleMonthChanged (VisibleDate, prev);
|
|
return;
|
|
}
|
|
|
|
if (eventArgument[0] == 'R') { // Selects a range of dates
|
|
string num, date, days;
|
|
num = eventArgument.Substring (1);
|
|
days = num.Substring (num.Length - 2, 2);
|
|
date = num.Substring (0, num.Length - 2);
|
|
DateTime d = GetGlobalCalendar().AddDays (dateZenith, Int32.Parse (date));
|
|
SelectedDates.SelectRange (d, d.AddDays (Int32.Parse (days)));
|
|
OnSelectionChanged ();
|
|
return;
|
|
}
|
|
|
|
// Selects a single day
|
|
int daysFromZenith = Int32.Parse (eventArgument);
|
|
DateTime day = GetGlobalCalendar().AddDays (dateZenith, daysFromZenith);
|
|
SelectedDates.SelectRange (day, day);
|
|
OnSelectionChanged ();
|
|
}
|
|
|
|
protected override void LoadViewState (object savedState)
|
|
{
|
|
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)
|
|
TitleStyle.LoadViewState (states [6]);
|
|
|
|
if (states [7] != null)
|
|
TodayDayStyle.LoadViewState (states [7]);
|
|
|
|
if (states [8] != null)
|
|
SelectorStyle.LoadViewState (states [8]);
|
|
|
|
if (states [9] != null)
|
|
WeekendDayStyle.LoadViewState (states [9]);
|
|
|
|
ArrayList array = (ArrayList) ViewState ["SelectedDates"];
|
|
if (array != null) {
|
|
dateList = array;
|
|
selectedDatesCollection = new SelectedDatesCollection (dateList);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnDayRender (TableCell cell, CalendarDay day)
|
|
{
|
|
DayRenderEventHandler eh = (DayRenderEventHandler) (Events [DayRenderEvent]);
|
|
if (eh != null) {
|
|
Page page = Page;
|
|
if (page != null)
|
|
eh (this, new DayRenderEventArgs (cell, day, page.ClientScript.GetPostBackClientHyperlink (this, GetDaysFromZenith (day.Date).ToString (), true)));
|
|
else
|
|
eh (this, new DayRenderEventArgs (cell, day));
|
|
}
|
|
}
|
|
|
|
protected internal override void OnPreRender (EventArgs e)
|
|
{
|
|
base.OnPreRender (e);
|
|
}
|
|
|
|
protected virtual void OnSelectionChanged ()
|
|
{
|
|
EventHandler eh = (EventHandler) (Events [SelectionChangedEvent]);
|
|
if (eh != null)
|
|
eh (this, EventArgs.Empty);
|
|
}
|
|
|
|
protected virtual void OnVisibleMonthChanged (DateTime newDate, DateTime previousDate)
|
|
{
|
|
MonthChangedEventHandler eh = (MonthChangedEventHandler) (Events [VisibleMonthChangedEvent]);
|
|
if (eh != null)
|
|
eh (this, new MonthChangedEventArgs (newDate, previousDate));
|
|
}
|
|
|
|
protected internal override void Render (HtmlTextWriter writer)
|
|
{
|
|
TableStyle ts = new TableStyle ();
|
|
ts.CellSpacing = CellSpacing;
|
|
ts.CellPadding = CellPadding;
|
|
ts.BorderWidth = 1;
|
|
if (ControlStyleCreated)
|
|
ts.CopyFrom (ControlStyle);
|
|
if (ShowGridLines)
|
|
ts.GridLines = GridLines.Both;
|
|
ts.AddAttributesToRender (writer);
|
|
writer.AddAttribute (HtmlTextWriterAttribute.Id, ClientID);
|
|
writer.RenderBeginTag (HtmlTextWriterTag.Table);
|
|
|
|
if (!String.IsNullOrEmpty (Caption))
|
|
WriteCaption (writer);
|
|
|
|
bool enabled = IsEnabled;
|
|
|
|
if (ShowTitle)
|
|
WriteTitle (writer, enabled);
|
|
|
|
if (ShowDayHeader)
|
|
WriteDayHeader (writer, enabled);
|
|
|
|
WriteDays (writer, enabled);
|
|
|
|
writer.RenderEndTag ();
|
|
}
|
|
|
|
protected override object SaveViewState ()
|
|
{
|
|
object [] states = new object [10];
|
|
|
|
if (dayHeaderStyle != null)
|
|
states [1] = dayHeaderStyle.SaveViewState ();
|
|
|
|
if (dayStyle != null)
|
|
states [2] = dayStyle.SaveViewState ();
|
|
|
|
if (nextPrevStyle != null)
|
|
states [3] = nextPrevStyle.SaveViewState ();
|
|
|
|
if (otherMonthDayStyle != null)
|
|
states [4] = otherMonthDayStyle.SaveViewState ();
|
|
|
|
if (selectedDayStyle != null)
|
|
states [5] = selectedDayStyle.SaveViewState ();
|
|
|
|
if (titleStyle != null)
|
|
states [6] = titleStyle.SaveViewState ();
|
|
|
|
if (todayDayStyle != null)
|
|
states [7] =todayDayStyle.SaveViewState ();
|
|
|
|
if (selectorStyle != null)
|
|
states [8] = selectorStyle.SaveViewState ();
|
|
|
|
if (weekendDayStyle != null)
|
|
states [9] = weekendDayStyle.SaveViewState ();
|
|
|
|
if (SelectedDates.Count > 0) {
|
|
ViewState ["SelectedDates"] = dateList;
|
|
}
|
|
|
|
states [0] = base.SaveViewState ();
|
|
|
|
for (int i = 0; i < states.Length; i++) {
|
|
if (states [i] != null)
|
|
return states;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected override void TrackViewState ()
|
|
{
|
|
base.TrackViewState ();
|
|
|
|
if (dayHeaderStyle != null)
|
|
dayHeaderStyle.TrackViewState ();
|
|
|
|
if (dayStyle != null)
|
|
dayStyle.TrackViewState ();
|
|
|
|
if (nextPrevStyle != null)
|
|
nextPrevStyle.TrackViewState ();
|
|
|
|
if (otherMonthDayStyle != null)
|
|
otherMonthDayStyle.TrackViewState ();
|
|
|
|
if (selectedDayStyle != null)
|
|
selectedDayStyle.TrackViewState ();
|
|
|
|
if (titleStyle != null)
|
|
titleStyle.TrackViewState ();
|
|
|
|
if (todayDayStyle != null)
|
|
todayDayStyle.TrackViewState ();
|
|
|
|
if (selectorStyle != null)
|
|
selectorStyle.TrackViewState ();
|
|
|
|
if (weekendDayStyle != null)
|
|
weekendDayStyle.TrackViewState ();
|
|
}
|
|
|
|
//
|
|
// Private methods
|
|
//
|
|
void WriteDayHeader (HtmlTextWriter writer, bool enabled)
|
|
{
|
|
int i, first;
|
|
string dayName;
|
|
i = first = (int) (DisplayFirstDayOfWeek);
|
|
TableCell cell;
|
|
|
|
|
|
writer.RenderBeginTag (HtmlTextWriterTag.Tr);
|
|
|
|
if (SelectionMode == CalendarSelectionMode.DayWeek) {
|
|
cell = new TableCell();
|
|
cell.HorizontalAlign = HorizontalAlign.Center;
|
|
cell.ApplyStyle (DayHeaderStyle);
|
|
|
|
// Empty Cell
|
|
cell.RenderBeginTag (writer);
|
|
cell.RenderEndTag (writer);
|
|
} else {
|
|
if (SelectionMode == CalendarSelectionMode.DayWeekMonth) {
|
|
TableCell selector = new TableCell ();
|
|
selector.ApplyStyle (SelectorStyle);
|
|
selector.HorizontalAlign = HorizontalAlign.Center;
|
|
|
|
DateTime date = new DateTime (DisplayDate.Year, DisplayDate.Month, 1); // first date
|
|
int days = DateTime.DaysInMonth (DisplayDate.Year, DisplayDate.Month);
|
|
|
|
selector.RenderBeginTag (writer);
|
|
writer.Write (BuildLink ("R" + GetDaysFromZenith (date) + days, SelectMonthText, DayHeaderStyle.ForeColor, enabled));
|
|
selector.RenderEndTag (writer);
|
|
}
|
|
}
|
|
|
|
DateTimeFormatInfo dti = DateInfo;
|
|
while (true) {
|
|
DayOfWeek dayOfWeek = (DayOfWeek) i;
|
|
dayName = dti.GetDayName (dayOfWeek);
|
|
|
|
if (UseAccessibleHeader) {
|
|
writer.AddAttribute (HtmlTextWriterAttribute.Abbr, dayName);
|
|
writer.AddAttribute (HtmlTextWriterAttribute.Scope, "col", false);
|
|
cell = new TableHeaderCell();
|
|
} else
|
|
cell = new TableCell();
|
|
|
|
cell.HorizontalAlign = HorizontalAlign.Center;
|
|
cell.ApplyStyle (DayHeaderStyle);
|
|
|
|
cell.RenderBeginTag (writer);
|
|
|
|
switch (DayNameFormat) {
|
|
case DayNameFormat.FirstLetter:
|
|
dayName = dayName.Substring (0, 1);
|
|
break;
|
|
case DayNameFormat.FirstTwoLetters:
|
|
dayName = dayName.Substring (0, 2);
|
|
break;
|
|
case DayNameFormat.Shortest:
|
|
dayName = dti.GetShortestDayName (dayOfWeek);
|
|
break;
|
|
case DayNameFormat.Full:
|
|
break;
|
|
case DayNameFormat.Short:
|
|
default:
|
|
dayName = dti.GetAbbreviatedDayName (dayOfWeek);
|
|
break;
|
|
}
|
|
|
|
writer.Write (dayName);
|
|
cell.RenderEndTag (writer);
|
|
|
|
if (i >= daysInAWeek - 1)
|
|
i = 0;
|
|
else
|
|
i++;
|
|
|
|
if (i == first)
|
|
break;
|
|
}
|
|
|
|
writer.RenderEndTag ();
|
|
}
|
|
|
|
void WriteDay (DateTime date, HtmlTextWriter writer, bool enabled)
|
|
{
|
|
TableItemStyle style = new TableItemStyle ();
|
|
TableCell cell = new TableCell ();
|
|
|
|
CalendarDay day = new CalendarDay (date,
|
|
IsWeekEnd (date.DayOfWeek),
|
|
date == TodaysDate, SelectedDates.Contains (date),
|
|
GetGlobalCalendar ().GetMonth (DisplayDate) != GetGlobalCalendar ().GetMonth (date),
|
|
date.Day.ToString ());
|
|
|
|
day.IsSelectable = SelectionMode != CalendarSelectionMode.None;
|
|
cell.HorizontalAlign = HorizontalAlign.Center;
|
|
cell.Width = Unit.Percentage (GetCellWidth ());
|
|
|
|
LiteralControl lit = new LiteralControl (day.DayNumberText);
|
|
cell.Controls.Add (lit);
|
|
|
|
OnDayRender (cell, day);
|
|
|
|
if (dayStyle != null && !dayStyle.IsEmpty)
|
|
style.CopyFrom (dayStyle);
|
|
|
|
if (day.IsWeekend && weekendDayStyle != null && !weekendDayStyle.IsEmpty)
|
|
style.CopyFrom (weekendDayStyle);
|
|
|
|
if (day.IsToday && todayDayStyle != null && !todayDayStyle.IsEmpty)
|
|
style.CopyFrom (todayDayStyle);
|
|
|
|
if (day.IsOtherMonth && otherMonthDayStyle != null && !otherMonthDayStyle.IsEmpty)
|
|
style.CopyFrom (otherMonthDayStyle);
|
|
|
|
if (enabled && day.IsSelected) {
|
|
style.BackColor = Color.Silver;
|
|
style.ForeColor = Color.White;
|
|
if (selectedDayStyle != null && !selectedDayStyle.IsEmpty)
|
|
style.CopyFrom (selectedDayStyle);
|
|
}
|
|
|
|
cell.ApplyStyle (style);
|
|
|
|
lit.Text = BuildLink (GetDaysFromZenith (date).ToString (), day.DayNumberText,
|
|
cell.ForeColor, enabled && day.IsSelectable);
|
|
|
|
cell.RenderControl (writer);
|
|
}
|
|
|
|
void WriteDays (HtmlTextWriter writer, bool enabled)
|
|
{
|
|
DateTime date = new DateTime (DisplayDate.Year, DisplayDate.Month, 1); // first date
|
|
DateTime lastDate;
|
|
TableCell selectorCell = null;
|
|
int n;
|
|
|
|
// Goes backwards until we find the date of that is begining of the week
|
|
for (n = 0; n < daysInAWeek; n++) {
|
|
if (date.DayOfWeek == DisplayFirstDayOfWeek)
|
|
break;
|
|
|
|
date = GetGlobalCalendar().AddDays (date, -1);
|
|
}
|
|
/* if the start date is the first day of the week, we need to shift backward one more week */
|
|
if (n == 0)
|
|
date = GetGlobalCalendar().AddDays (date, -1 * daysInAWeek);
|
|
|
|
lastDate = GetGlobalCalendar().AddDays (date, 6 * daysInAWeek); // Always six weeks per months
|
|
|
|
while (true) {
|
|
writer.RenderBeginTag (HtmlTextWriterTag.Tr);
|
|
|
|
if (HasWeekSelectors (SelectionMode)) { // Week selector
|
|
if (selectorCell == null) {
|
|
selectorCell = new TableCell ();
|
|
selectorCell.ApplyStyle (SelectorStyle);
|
|
selectorCell.HorizontalAlign = HorizontalAlign.Center;
|
|
selectorCell.Width = Unit.Percentage (GetCellWidth ());
|
|
}
|
|
|
|
selectorCell.RenderBeginTag (writer);
|
|
writer.Write (BuildLink ("R" + GetDaysFromZenith (date) + "07", SelectWeekText, selectorCell.ForeColor, enabled));
|
|
selectorCell.RenderEndTag (writer);
|
|
}
|
|
|
|
for (int i = 0; i < daysInAWeek; i++) {
|
|
WriteDay (date, writer, enabled);
|
|
date = GetGlobalCalendar().AddDays (date, 1);
|
|
}
|
|
|
|
writer.RenderEndTag ();
|
|
if (date >= lastDate)
|
|
break;
|
|
}
|
|
}
|
|
|
|
string BuildLink (string arg, string text, Color foreColor, bool hasLink)
|
|
{
|
|
StringBuilder str = new StringBuilder ();
|
|
Color clr;
|
|
Page page = Page;
|
|
hasLink = (page != null && hasLink == true) ? true : false;
|
|
|
|
if (hasLink) {
|
|
str.Append ("<a href=\"");
|
|
str.Append (page.ClientScript.GetPostBackClientHyperlink (this, arg, true));
|
|
str.Append ('\"');
|
|
|
|
|
|
if (!foreColor.IsEmpty)
|
|
clr = foreColor;
|
|
else {
|
|
if (ForeColor.IsEmpty)
|
|
clr = Color.Black;
|
|
else
|
|
clr = ForeColor;
|
|
}
|
|
|
|
str.Append (" style=\"color:" + ColorTranslator.ToHtml (clr));
|
|
str.Append ("\">");
|
|
str.Append (text);
|
|
str.Append ("</a>");
|
|
} else
|
|
str.Append (text);
|
|
|
|
return str.ToString ();
|
|
}
|
|
|
|
int GetDaysFromZenith (DateTime date)
|
|
{
|
|
TimeSpan span = date.Subtract (dateZenith);
|
|
return span.Days;
|
|
}
|
|
|
|
void WriteCaption (HtmlTextWriter writer)
|
|
{
|
|
if (CaptionAlign != TableCaptionAlign.NotSet)
|
|
writer.AddAttribute (HtmlTextWriterAttribute.Align, CaptionAlign.ToString (Helpers.InvariantCulture));
|
|
|
|
writer.RenderBeginTag (HtmlTextWriterTag.Caption);
|
|
writer.Write (Caption);
|
|
writer.RenderEndTag ();
|
|
}
|
|
|
|
void WriteTitle (HtmlTextWriter writer, bool enabled)
|
|
{
|
|
TableCell cellNextPrev = null;
|
|
TableCell titleCell = new TableCell ();
|
|
Table tableTitle = new Table ();
|
|
|
|
writer.RenderBeginTag (HtmlTextWriterTag.Tr);
|
|
|
|
titleCell.ColumnSpan = HasWeekSelectors (SelectionMode) ? 8 : 7;
|
|
|
|
if (titleStyle != null && !titleStyle.IsEmpty && !titleStyle.BackColor.IsEmpty)
|
|
titleCell.BackColor = titleStyle.BackColor;
|
|
else
|
|
titleCell.BackColor = Color.Silver;
|
|
|
|
titleCell.RenderBeginTag (writer);
|
|
|
|
// Table
|
|
tableTitle.Width = Unit.Percentage (100);
|
|
if (titleStyle != null && !titleStyle.IsEmpty)
|
|
tableTitle.ApplyStyle (titleStyle);
|
|
|
|
tableTitle.RenderBeginTag (writer);
|
|
writer.RenderBeginTag (HtmlTextWriterTag.Tr);
|
|
|
|
if (ShowNextPrevMonth) { // Previous Table Data
|
|
cellNextPrev = new TableCell ();
|
|
cellNextPrev.ApplyStyle (nextPrevStyle);
|
|
cellNextPrev.Width = Unit.Percentage (15);
|
|
|
|
DateTime date = GetGlobalCalendar().AddMonths (DisplayDate, - 1);
|
|
date = GetGlobalCalendar ().AddDays (date, -date.Day + 1);
|
|
cellNextPrev.RenderBeginTag (writer);
|
|
writer.Write (BuildLink ("V" + GetDaysFromZenith (date), GetNextPrevFormatText (date, false), cellNextPrev.ForeColor, enabled));
|
|
cellNextPrev.RenderEndTag (writer);
|
|
}
|
|
|
|
// Current Month Table Data
|
|
{
|
|
DateTimeFormatInfo dti = DateInfo;
|
|
string str;
|
|
TableCell cellMonth = new TableCell ();
|
|
cellMonth.Width = Unit.Percentage (70);
|
|
cellMonth.HorizontalAlign = HorizontalAlign.Center;
|
|
|
|
cellMonth.RenderBeginTag (writer);
|
|
|
|
if (TitleFormat == TitleFormat.MonthYear)
|
|
str = DisplayDate.ToString (dti.YearMonthPattern, dti);
|
|
else
|
|
str = dti.GetMonthName (GetGlobalCalendar ().GetMonth (DisplayDate));
|
|
|
|
writer.Write (str);
|
|
cellMonth.RenderEndTag (writer);
|
|
}
|
|
|
|
if (ShowNextPrevMonth) { // Next Table Data
|
|
DateTime date = GetGlobalCalendar().AddMonths (DisplayDate, + 1);
|
|
date = GetGlobalCalendar ().AddDays (date, -date.Day + 1);
|
|
|
|
cellNextPrev.HorizontalAlign = HorizontalAlign.Right;
|
|
cellNextPrev.RenderBeginTag (writer);
|
|
writer.Write (BuildLink ("V" + GetDaysFromZenith (date), GetNextPrevFormatText (date, true), cellNextPrev.ForeColor, enabled));
|
|
cellNextPrev.RenderEndTag (writer);
|
|
}
|
|
|
|
writer.RenderEndTag ();
|
|
tableTitle.RenderEndTag (writer);
|
|
titleCell.RenderEndTag (writer);
|
|
writer.RenderEndTag (); //tr
|
|
}
|
|
|
|
string GetNextPrevFormatText (DateTime date, bool next)
|
|
{
|
|
string text;
|
|
DateTimeFormatInfo dti = DateInfo;
|
|
switch (NextPrevFormat) {
|
|
case NextPrevFormat.FullMonth:
|
|
text = dti.GetMonthName (GetGlobalCalendar ().GetMonth (date));
|
|
break;
|
|
case NextPrevFormat.ShortMonth:
|
|
text = dti.GetAbbreviatedMonthName (GetGlobalCalendar ().GetMonth (date));
|
|
break;
|
|
case NextPrevFormat.CustomText:
|
|
default:
|
|
text = ((next) ? NextMonthText : PrevMonthText);
|
|
break;
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
bool IsWeekEnd (DayOfWeek day)
|
|
{
|
|
return (day == DayOfWeek.Saturday || day == DayOfWeek.Sunday);
|
|
}
|
|
|
|
double GetCellWidth ()
|
|
{
|
|
return HasWeekSelectors (SelectionMode) ? 100/8 : 100/7;
|
|
}
|
|
|
|
System.Globalization.Calendar GetGlobalCalendar ()
|
|
{
|
|
return DateTimeFormatInfo.CurrentInfo.Calendar;
|
|
}
|
|
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Action")]
|
|
public event DayRenderEventHandler DayRender {
|
|
add { Events.AddHandler (DayRenderEvent, value); }
|
|
remove { Events.RemoveHandler (DayRenderEvent, value); }
|
|
}
|
|
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Action")]
|
|
public event EventHandler SelectionChanged {
|
|
add { Events.AddHandler (SelectionChangedEvent, value); }
|
|
remove { Events.RemoveHandler (SelectionChangedEvent, value); }
|
|
}
|
|
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Action")]
|
|
public event MonthChangedEventHandler VisibleMonthChanged {
|
|
add { Events.AddHandler (VisibleMonthChangedEvent, value); }
|
|
remove { Events.RemoveHandler (VisibleMonthChangedEvent, value); }
|
|
}
|
|
}
|
|
}
|