mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 01:41:17 -10:00
* System.Web_test.dll.sources: add new test. * System.Web.UI/AttributeCollection.cs: avoid code duplication and don't add "style" to the bag, or it will overwrite the settings made by CssStyleCollection. * System.Web.UI/CssStyleCollection.cs: make it throw where MS throws. Minimize the number of times we create the "style" string and take care of updating it for the AttributeCollection. FillStyle and BagToString are now private. One should use the 2.0 (internal in <2.0) Value property. * System.Web.UI.WebControls/Style.cs: avoid unnecesary creation of a CssStyleCollection and instead write the style attributes directly to the HtmlTextWriter. * System.Web.UI.WebControls/CheckBox.cs: adapted to new API. * DataGrid.cs: handle null data sources. Fixed the contions that make the table to be added to the Controls collection. * System.Web.UI.WebControls/Calendar.cs: the table needed an ID and the attributes from the parent. Also don't create the ControlStyleCollection if it has not already been created. svn path=/trunk/mcs/; revision=50931
1275 lines
32 KiB
C#
1275 lines
32 KiB
C#
//
|
|
// System.Web.UI.WebControls.Calendar.cs
|
|
//
|
|
// Authors:
|
|
// Jordi Mas i Hernandez ([email protected])
|
|
//
|
|
// (C) 2005 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;
|
|
|
|
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")]
|
|
#if NET_2_0
|
|
[ControlValueProperty ("SelectedDate", "1/1/0001 12:00:00 AM")]
|
|
[SupportsEventValidation]
|
|
#endif
|
|
public class Calendar : WebControl, IPostBackEventHandler {
|
|
|
|
private TableItemStyle dayHeaderStyle;
|
|
private TableItemStyle dayStyle;
|
|
private TableItemStyle nextPrevStyle;
|
|
private TableItemStyle otherMonthDayStyle;
|
|
private TableItemStyle selectedDayStyle;
|
|
private TableItemStyle titleStyle;
|
|
private TableItemStyle todayDayStyle;
|
|
private TableItemStyle selectorStyle;
|
|
private TableItemStyle weekendDayStyle;
|
|
private DateTimeFormatInfo dateInfo;
|
|
private SelectedDatesCollection selectedDatesCollection;
|
|
private ArrayList dateList;
|
|
private static DateTime dateZenith = new DateTime (2000, 1,1);
|
|
private const int daysInAWeek = 7;
|
|
private static readonly object DayRenderEvent = new object ();
|
|
private static readonly object SelectionChangedEvent = new object ();
|
|
private static readonly object VisibleMonthChangedEvent = new object ();
|
|
|
|
public Calendar ()
|
|
{
|
|
dateInfo = new DateTimeFormatInfo ();
|
|
}
|
|
|
|
#if NET_2_0
|
|
[Localizable (true)]
|
|
[DefaultValue ("")]
|
|
[WebSysDescription ("")]
|
|
[WebCategoryAttribute ("Appearance")]
|
|
public virtual string Caption
|
|
{
|
|
get {
|
|
return ViewState.GetString ("Caption", "");
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[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) {
|
|
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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[DefaultValue(">")]
|
|
#if NET_2_0
|
|
[Localizable (true)]
|
|
#endif
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public string NextMonthText {
|
|
get {
|
|
return ViewState.GetString ("NextMonthText", ">");
|
|
}
|
|
|
|
set {
|
|
ViewState ["NextMonthText"] = value;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[DefaultValue("<")]
|
|
#if NET_2_0
|
|
[Localizable (true)]
|
|
#endif
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public string PrevMonthText {
|
|
get {
|
|
return ViewState.GetString ("PrevMonthText", "<");
|
|
}
|
|
|
|
set {
|
|
ViewState ["PrevMonthText"] = value;
|
|
}
|
|
}
|
|
|
|
#if NET_2_0
|
|
[Bindable(true, BindingDirection.TwoWay)]
|
|
#else
|
|
[Bindable(true)]
|
|
#endif
|
|
[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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[DefaultValue(">>")]
|
|
#if NET_2_0
|
|
[Localizable (true)]
|
|
#endif
|
|
[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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[DefaultValue(">")]
|
|
#if NET_2_0
|
|
[Localizable (true)]
|
|
#endif
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public string SelectWeekText {
|
|
get {
|
|
return ViewState.GetString ("SelectWeekText", ">");
|
|
}
|
|
|
|
set {
|
|
ViewState ["SelectWeekText"] = value;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[DefaultValue(true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public bool ShowDayHeader {
|
|
get {
|
|
return ViewState.GetBool ("ShowDayHeader", true);
|
|
}
|
|
|
|
set {
|
|
ViewState ["ShowDayHeader"] = value;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[DefaultValue(false)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public bool ShowGridLines {
|
|
get {
|
|
return ViewState.GetBool ("ShowGridLines", false);
|
|
}
|
|
|
|
set {
|
|
ViewState ["ShowGridLines"] = value;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[DefaultValue(true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public bool ShowNextPrevMonth {
|
|
get {
|
|
return ViewState.GetBool ("ShowNextPrevMonth", true);
|
|
}
|
|
|
|
set {
|
|
ViewState ["ShowNextPrevMonth"] = value;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[DefaultValue(true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Appearance")]
|
|
public bool ShowTitle {
|
|
get {
|
|
return ViewState.GetBool ("ShowTitle", true);
|
|
}
|
|
|
|
set {
|
|
ViewState ["ShowTitle"] = value;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[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;
|
|
}
|
|
}
|
|
|
|
#if ONLY_1_1
|
|
[Bindable(true)]
|
|
#endif
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
[WebSysDescription ("")]
|
|
[WebCategory ("Style")]
|
|
public DateTime TodaysDate {
|
|
get {
|
|
object obj = ViewState ["TodaysDate"];
|
|
|
|
if (obj != null)
|
|
return (DateTime) obj;
|
|
|
|
return DateTime.Today;
|
|
}
|
|
|
|
set {
|
|
ViewState ["TodaysDate"] = value.Date;
|
|
}
|
|
}
|
|
|
|
#if NET_2_0
|
|
[DefaultValue (true)]
|
|
[WebSysDescription ("")]
|
|
[WebCategoryAttribute ("Accessibility")]
|
|
public virtual bool UseAccessibleHeader
|
|
{
|
|
get {
|
|
return ViewState.GetBool ("UseAccessibleHeader", true);
|
|
}
|
|
set {
|
|
ViewState ["UseAccessibleHeader"] = value;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[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;
|
|
}
|
|
}
|
|
|
|
|
|
// Private properties
|
|
private DateTime DisplayDate {
|
|
get {
|
|
DateTime dateTime = VisibleDate;
|
|
if (dateTime == DateTime.MinValue) // If visibledate is still the default value
|
|
dateTime = TodaysDate;
|
|
|
|
return dateTime;
|
|
}
|
|
}
|
|
|
|
private 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;
|
|
}
|
|
|
|
#if NET_2_0
|
|
void IPostBackEventHandler.RaisePostBackEvent (string eventArgument)
|
|
{
|
|
RaisePostBackEvent (eventArgument);
|
|
}
|
|
|
|
protected virtual void RaisePostBackEvent (string arg)
|
|
#else
|
|
void IPostBackEventHandler.RaisePostBackEvent (string arg)
|
|
#endif
|
|
{
|
|
if (arg.Length < 1)
|
|
return;
|
|
|
|
if (arg[0] == 'V') { // Goes to Next or Previous month
|
|
DateTime prev = VisibleDate;
|
|
int days = Int32.Parse (arg.Substring (1));
|
|
DateTime dt = GetGlobalCalendar().AddDays (dateZenith, days);
|
|
VisibleDate = dt;
|
|
OnVisibleMonthChanged (VisibleDate, prev);
|
|
return;
|
|
}
|
|
|
|
if (arg[0] == 'R') { // Selects a range of dates
|
|
string num, date, days;
|
|
num = arg.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 (arg);
|
|
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)
|
|
eh (this, new DayRenderEventArgs (cell, day));
|
|
}
|
|
|
|
#if NET_2_0
|
|
protected internal
|
|
#else
|
|
protected
|
|
#endif
|
|
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));
|
|
}
|
|
|
|
#if NET_2_0
|
|
protected internal
|
|
#else
|
|
protected
|
|
#endif
|
|
override void Render (HtmlTextWriter writer)
|
|
{
|
|
Table table = new Table ();
|
|
table.CellSpacing = CellSpacing;
|
|
table.CellPadding = CellPadding;
|
|
if (ControlStyleCreated)
|
|
table.ControlStyle.CopyFrom (ControlStyle);
|
|
table.CopyBaseAttributes (this);
|
|
table.ID = ID;
|
|
|
|
if (ShowGridLines)
|
|
table.GridLines = GridLines.Both;
|
|
|
|
table.RenderBeginTag (writer);
|
|
|
|
#if NET_2_0
|
|
if (Caption != "")
|
|
WriteCaption (writer);
|
|
#endif
|
|
|
|
if (ShowTitle)
|
|
WriteTitle (writer);
|
|
|
|
if (ShowDayHeader)
|
|
WriteDayHeader (writer);
|
|
|
|
WriteDays (writer);
|
|
|
|
table.RenderEndTag (writer);
|
|
}
|
|
|
|
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
|
|
//
|
|
private void WriteDayHeader (HtmlTextWriter writer)
|
|
{
|
|
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, true));
|
|
selector.RenderEndTag (writer);
|
|
}
|
|
}
|
|
|
|
while (true) {
|
|
DayOfWeek dayOfWeek = (DayOfWeek) i;
|
|
dayName = dateInfo.GetDayName (dayOfWeek);
|
|
|
|
#if NET_2_0
|
|
if (UseAccessibleHeader) {
|
|
writer.AddAttribute (HtmlTextWriterAttribute.Abbr, dayName);
|
|
writer.AddAttribute (HtmlTextWriterAttribute.Scope, "col");
|
|
cell = new TableHeaderCell();
|
|
}
|
|
else
|
|
#endif
|
|
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.Full:
|
|
break;
|
|
case DayNameFormat.Short:
|
|
default:
|
|
dayName = dateInfo.GetAbbreviatedDayName (dayOfWeek);
|
|
break;
|
|
}
|
|
|
|
writer.Write (dayName);
|
|
cell.RenderEndTag (writer);
|
|
|
|
if (i >= daysInAWeek - 1) {
|
|
i = 0;
|
|
}
|
|
else {
|
|
i++;
|
|
}
|
|
if (i == first)
|
|
break;
|
|
}
|
|
|
|
writer.RenderEndTag ();
|
|
}
|
|
|
|
private void WriteDay (DateTime date, HtmlTextWriter writer)
|
|
{
|
|
Style style = new Style ();
|
|
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 (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, day.IsSelectable);
|
|
|
|
cell.RenderControl (writer);
|
|
}
|
|
|
|
private void WriteDays (HtmlTextWriter writer)
|
|
{
|
|
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, true));
|
|
selectorCell.RenderEndTag (writer);
|
|
}
|
|
|
|
for (int i = 0; i < daysInAWeek; i++) {
|
|
WriteDay (date, writer);
|
|
date = GetGlobalCalendar().AddDays (date, 1);
|
|
}
|
|
|
|
writer.RenderEndTag ();
|
|
if (date >= lastDate)
|
|
break;
|
|
}
|
|
}
|
|
|
|
private string BuildLink (string arg, string text, Color foreColor, bool hasLink)
|
|
{
|
|
string str = string.Empty;
|
|
Color clr;
|
|
hasLink = (Page != null && hasLink == true) ? true : false;
|
|
|
|
if (hasLink) {
|
|
str = "<a href=\"";
|
|
str += Page.ClientScript.GetPostBackClientHyperlink (this, arg);
|
|
str += "\"";
|
|
|
|
|
|
if (!foreColor.IsEmpty) {
|
|
clr = foreColor;
|
|
} else {
|
|
if (ForeColor.IsEmpty)
|
|
clr = Color.Black;
|
|
else
|
|
clr = ForeColor;
|
|
}
|
|
|
|
str += " style=color:" + ColorTranslator.ToHtml (clr);
|
|
str += ">";
|
|
str += text;
|
|
str += "</a>";
|
|
}
|
|
else
|
|
str += text;
|
|
|
|
return str;
|
|
}
|
|
|
|
private int GetDaysFromZenith (DateTime date)
|
|
{
|
|
TimeSpan span = date.Subtract (dateZenith);
|
|
return span.Days;
|
|
}
|
|
|
|
#if NET_2_0
|
|
void WriteCaption (HtmlTextWriter writer)
|
|
{
|
|
if (CaptionAlign != TableCaptionAlign.NotSet)
|
|
writer.AddAttribute (HtmlTextWriterAttribute.Align, CaptionAlign.ToString (CultureInfo.InvariantCulture));
|
|
|
|
writer.RenderBeginTag (HtmlTextWriterTag.Caption);
|
|
writer.Write (Caption);
|
|
writer.RenderEndTag ();
|
|
}
|
|
#endif
|
|
|
|
private void WriteTitle (HtmlTextWriter writer)
|
|
{
|
|
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, -DisplayDate.Day + 1);
|
|
cellNextPrev.RenderBeginTag (writer);
|
|
writer.Write (BuildLink ("V" + GetDaysFromZenith (date), GetNextPrevFormatText (date, false), cellNextPrev.ForeColor, true));
|
|
cellNextPrev.RenderEndTag (writer);
|
|
}
|
|
|
|
// Current Month Table Data
|
|
{
|
|
string str;
|
|
TableCell cellMonth = new TableCell ();
|
|
cellMonth.Width = Unit.Percentage (70);
|
|
cellMonth.HorizontalAlign = HorizontalAlign.Center;
|
|
|
|
cellMonth.RenderBeginTag (writer);
|
|
|
|
str = dateInfo.GetMonthName (GetGlobalCalendar ().GetMonth (DisplayDate));
|
|
|
|
if (TitleFormat == TitleFormat.MonthYear)
|
|
str += " " + (DisplayDate.Year.ToString ());
|
|
|
|
writer.Write (str);
|
|
cellMonth.RenderEndTag (writer);
|
|
}
|
|
|
|
if (ShowNextPrevMonth) { // Next Table Data
|
|
DateTime date = GetGlobalCalendar().AddMonths (DisplayDate, + 1);
|
|
date = GetGlobalCalendar().AddDays (date, -DisplayDate.Day + 1);
|
|
|
|
cellNextPrev.HorizontalAlign = HorizontalAlign.Right;
|
|
cellNextPrev.RenderBeginTag (writer);
|
|
writer.Write (BuildLink ("V" + GetDaysFromZenith (date), GetNextPrevFormatText (date, true), cellNextPrev.ForeColor, true));
|
|
cellNextPrev.RenderEndTag (writer);
|
|
}
|
|
|
|
writer.RenderEndTag ();
|
|
tableTitle.RenderEndTag (writer);
|
|
titleCell.RenderEndTag (writer);
|
|
writer.RenderEndTag (); //tr
|
|
|
|
}
|
|
|
|
|
|
private string GetNextPrevFormatText (DateTime date, bool next)
|
|
{
|
|
string text;
|
|
switch (NextPrevFormat) {
|
|
case NextPrevFormat.FullMonth:
|
|
text = dateInfo.GetMonthName (GetGlobalCalendar ().GetMonth (date));
|
|
break;
|
|
case NextPrevFormat.ShortMonth:
|
|
text = dateInfo.GetAbbreviatedMonthName (GetGlobalCalendar ().GetMonth (date));
|
|
break;
|
|
case NextPrevFormat.CustomText:
|
|
default:
|
|
text = ((next) ? NextMonthText : PrevMonthText);
|
|
break;
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
private bool IsWeekEnd (DayOfWeek day)
|
|
{
|
|
return (day == DayOfWeek.Saturday || day == DayOfWeek.Sunday);
|
|
}
|
|
|
|
private double GetCellWidth ()
|
|
{
|
|
return HasWeekSelectors (SelectionMode) ? 100/8 : 100/7;
|
|
}
|
|
|
|
private 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 {
|
|
Console.WriteLine ("Adding one");
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|