diff options
Diffstat (limited to 'source/ShiftUI/Widgets/DateTimePicker.cs')
| -rw-r--r-- | source/ShiftUI/Widgets/DateTimePicker.cs | 2018 |
1 files changed, 2018 insertions, 0 deletions
diff --git a/source/ShiftUI/Widgets/DateTimePicker.cs b/source/ShiftUI/Widgets/DateTimePicker.cs new file mode 100644 index 0000000..183fd77 --- /dev/null +++ b/source/ShiftUI/Widgets/DateTimePicker.cs @@ -0,0 +1,2018 @@ +// 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. +// +// Copyright (c) 2004-2005 Novell, Inc. +// +// Authors: +// John BouAntoun [email protected] +// Rolf Bjarne Kvinge [email protected] +// +// TODO: +// - wire in all events from monthcalendar + + +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Globalization; +using System.Runtime.InteropServices; +using System.Threading; + +namespace ShiftUI { + [ClassInterface (ClassInterfaceType.AutoDispatch)] + [DefaultBindingProperty ("Value")] + [ComVisible (true)] + [DefaultEvent("ValueChanged")] + [DefaultProperty("Value")] + //[Designer("ShiftUI.Design.DateTimePickerDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")] + [ToolboxWidget] + public class DateTimePicker : Widget { + + #region Public variables + + // this class has to have the specified hour, minute and second, as it says in msdn + //[EditorBrowsable (EditorBrowsableState.Never)] + [Browsable (false)] + public static readonly DateTime MaxDateTime = new DateTime (9998, 12, 31, 0, 0, 0); + + //[EditorBrowsable (EditorBrowsableState.Never)] + [Browsable (false)] + public static readonly DateTime MinDateTime = new DateTime (1753, 1, 1); + + internal const int check_box_size = 13; + internal const int check_box_space = 4; + + #endregion // Public variables + + #region Local variables + + protected static readonly Color DefaultMonthBackColor = ThemeEngine.Current.ColorWindow; + protected static readonly Color DefaultTitleBackColor = ThemeEngine.Current.ColorActiveCaption; + protected static readonly Color DefaultTitleForeColor = ThemeEngine.Current.ColorActiveCaptionText; + protected static readonly Color DefaultTrailingForeColor = SystemColors.GrayText; + + internal MonthCalendar month_calendar; + bool is_checked; + string custom_format; + LeftRightAlignment drop_down_align; + DateTimePickerFormat format; + DateTime max_date; + DateTime min_date; + bool show_check_box; + bool show_up_down; + DateTime date_value; + bool right_to_left_layout; + + // variables used for drawing and such + internal const int up_down_width = check_box_size; + internal bool is_drop_down_visible; + internal bool is_up_pressed; + internal bool is_down_pressed; + internal Timer updown_timer; + internal const int initial_timer_delay = 500; + internal const int subsequent_timer_delay = 100; + internal bool is_checkbox_selected; + + // variables for determining how to format the string + internal PartData[] part_data; + internal int editing_part_index = -1; + internal int editing_number = -1; + internal string editing_text; + + bool drop_down_button_entered; + #endregion // Local variables + + #region DateTimePickerAccessibleObject Subclass + [ComVisible(true)] + public class DateTimePickerAccessibleObject : WidgetAccessibleObject { + #region DateTimePickerAccessibleObject Local Variables + private new DateTimePicker owner; + #endregion // DateTimePickerAccessibleObject Local Variables + + #region DateTimePickerAccessibleObject Constructors + public DateTimePickerAccessibleObject(DateTimePicker owner) : base(owner) { + this.owner = owner; + } + #endregion // DateTimePickerAccessibleObject Constructors + + #region DateTimePickerAccessibleObject Properties + public override string KeyboardShortcut { + get { + return base.KeyboardShortcut; + } + } + + public override AccessibleRole Role { + get { + return base.Role; + } + } + + public override AccessibleStates State { + get { + AccessibleStates retval; + + retval = AccessibleStates.Default; + + if (owner.Checked) { + retval |= AccessibleStates.Checked; + } + + return retval; + } + } + + public override string Value { + get { + return owner.Text; + } + } + #endregion // DateTimePickerAccessibleObject Properties + } + #endregion // DateTimePickerAccessibleObject Sub-class + + #region public constructors + + // only public constructor + public DateTimePicker () { + + // initialise the month calendar + month_calendar = new MonthCalendar (this); + month_calendar.CalendarDimensions = new Size (1, 1); + month_calendar.MaxSelectionCount = 1; + month_calendar.ForeColor = Widget.DefaultForeColor; + month_calendar.BackColor = DefaultMonthBackColor; + month_calendar.TitleBackColor = DefaultTitleBackColor; + month_calendar.TitleForeColor = DefaultTitleForeColor; + month_calendar.TrailingForeColor = DefaultTrailingForeColor; + month_calendar.Visible = false; + // initialize the timer + updown_timer = new Timer(); + updown_timer.Interval = initial_timer_delay; + + + // initialise other variables + is_checked = true; + custom_format = null; + drop_down_align = LeftRightAlignment.Left; + format = DateTimePickerFormat.Long; + max_date = MaxDateTime; + min_date = MinDateTime; + show_check_box = false; + show_up_down = false; + date_value = DateTime.Now; + + is_drop_down_visible = false; + BackColor = SystemColors.Window; + ForeColor = SystemColors.WindowText; + + month_calendar.DateChanged += new DateRangeEventHandler (MonthCalendarDateChangedHandler); + month_calendar.DateSelected += new DateRangeEventHandler (MonthCalendarDateSelectedHandler); + month_calendar.LostFocus += new EventHandler (MonthCalendarLostFocusHandler); + updown_timer.Tick += new EventHandler (UpDownTimerTick); + KeyPress += new KeyPressEventHandler (KeyPressHandler); + KeyDown += new KeyEventHandler (KeyDownHandler); + GotFocus += new EventHandler (GotFocusHandler); + LostFocus += new EventHandler (LostFocusHandler); + MouseDown += new MouseEventHandler (MouseDownHandler); + MouseUp += new MouseEventHandler (MouseUpHandler); + MouseEnter += new EventHandler (OnMouseEnter); + MouseLeave += new EventHandler (OnMouseLeave); + MouseMove += new MouseEventHandler (OnMouseMove); + Paint += new PaintEventHandler (PaintHandler); + Resize += new EventHandler (ResizeHandler); + SetStyle (Widgetstyles.UserPaint | Widgetstyles.StandardClick, false); + SetStyle (Widgetstyles.FixedHeight, true); + SetStyle (Widgetstyles.Selectable, true); + + CalculateFormats (); + } + + #endregion + + #region public properties + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Never)] + public override Color BackColor { + set { + base.BackColor = value; + } + get { + return base.BackColor; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Never)] + public override Image BackgroundImage { + set { + base.BackgroundImage = value; + } + get { + return base.BackgroundImage; + } + } + + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public override ImageLayout BackgroundImageLayout { + get{ + return base.BackgroundImageLayout; + } + set { + base.BackgroundImageLayout = value; + } + } + + [AmbientValue(null)] + [Localizable(true)] + public Font CalendarFont { + set { + month_calendar.Font = value; + } + get { + return month_calendar.Font; + } + } + + public Color CalendarForeColor { + set { + month_calendar.ForeColor = value; + } + get { + return month_calendar.ForeColor; + } + } + + public Color CalendarMonthBackground { + set { + month_calendar.BackColor = value; + } + get { + return month_calendar.BackColor; + } + } + + public Color CalendarTitleBackColor { + set { + month_calendar.TitleBackColor = value; + } + get { + return month_calendar.TitleBackColor; + } + } + + public Color CalendarTitleForeColor { + set { + month_calendar.TitleForeColor = value; + } + get { + return month_calendar.TitleForeColor; + } + } + + public Color CalendarTrailingForeColor { + set { + month_calendar.TrailingForeColor = value; + } + get { + return month_calendar.TrailingForeColor; + } + } + + // when checked the value is grayed out + [Bindable(true)] + [DefaultValue(true)] + public bool Checked { + set { + if (is_checked != value) { + is_checked = value; + // invalidate the value inside this control + if (ShowCheckBox) { + for (int i = 0; i < part_data.Length; i++) + part_data [i].Selected = false; + Invalidate (date_area_rect); + OnUIAChecked (); + OnUIASelectionChanged (); + } + } + } + get { + return is_checked; + } + } + + // the custom format string to format this control with + [Localizable (true)] + [DefaultValue(null)] + [RefreshProperties(RefreshProperties.Repaint)] + public string CustomFormat { + set { + if (custom_format != value) { + custom_format = value; + if (this.Format == DateTimePickerFormat.Custom) { + CalculateFormats (); + } + } + } + get { + return custom_format; + } + } + + //[EditorBrowsable (EditorBrowsableState.Never)] + protected override bool DoubleBuffered { + get { + return base.DoubleBuffered; + } + set { + base.DoubleBuffered = value; + } + } + + // which side the drop down is to be aligned on + [DefaultValue(LeftRightAlignment.Left)] + [Localizable(true)] + public LeftRightAlignment DropDownAlign { + set { + if (drop_down_align != value) { + drop_down_align = value; + } + } + get { + return drop_down_align; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Never)] + public override Color ForeColor { + set { + base.ForeColor = value; + } + get { + return base.ForeColor; + } + } + + // the format of the date time picker text, default is long + [RefreshProperties(RefreshProperties.Repaint)] + public DateTimePickerFormat Format { + set { + if (format != value) { + format = value; + RecreateHandle (); // MS recreates the handle on every format change. + CalculateFormats (); + this.OnFormatChanged (EventArgs.Empty); + // invalidate the value inside this control + this.Invalidate (date_area_rect); + } + } + get { + return format; + } + } + + public DateTime MaxDate { + set { + if (value < min_date) { + string msg = string.Format (CultureInfo.CurrentCulture, + "'{0}' is not a valid value for 'MaxDate'. 'MaxDate' " + + "must be greater than or equal to MinDate.", + value.ToString ("G")); + throw new ArgumentOutOfRangeException ("MaxDate", msg); + } + if (value > MaxDateTime) { + string msg = string.Format (CultureInfo.CurrentCulture, + "DateTimePicker does not support dates after {0}.", + MaxDateTime.ToString ("G", CultureInfo.CurrentCulture)); + throw new ArgumentOutOfRangeException ("MaxDate", msg); + } + if (max_date != value) { + max_date = value; + if (Value > max_date) { + Value = max_date; + // invalidate the value inside this control + this.Invalidate (date_area_rect); + } + OnUIAMaximumChanged (); + } + } + get { + return max_date; + } + } + + public static DateTime MaximumDateTime { + get { + return MaxDateTime; + } + } + + public DateTime MinDate { + set { + // If the user tries to set DateTime.MinValue, fix it to + // DateTimePicker's minimum. + if (value == DateTime.MinValue) + value = MinDateTime; + + if (value > MaxDate) { + string msg = string.Format (CultureInfo.CurrentCulture, + "'{0}' is not a valid value for 'MinDate'. 'MinDate' " + + "must be less than MaxDate.", + value.ToString ("G")); + throw new ArgumentOutOfRangeException ("MinDate", msg); + } + if (value < MinDateTime) { + string msg = string.Format (CultureInfo.CurrentCulture, + "DateTimePicker does not support dates before {0}.", + MinDateTime.ToString ("G", CultureInfo.CurrentCulture)); + throw new ArgumentOutOfRangeException ("MinDate", msg); + } + if (min_date != value) { + min_date = value; + if (Value < min_date) { + Value = min_date; + // invalidate the value inside this control + this.Invalidate (date_area_rect); + } + OnUIAMinimumChanged (); + } + } + get { + return min_date; + } + } + + public static DateTime MinimumDateTime { + get { + return MinDateTime; + } + } + + //[EditorBrowsable (EditorBrowsableState.Never)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + [Browsable (false)] + public new Padding Padding { + get { return base.Padding; } + set { base.Padding = value; } + } + + // the prefered height to draw this control using current font + [Browsable(false)] + //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public int PreferredHeight { + get { + // Make it proportional + return (int) Math.Ceiling (Font.Height * 1.5); + } + } + + [DefaultValue (false)] + [Localizable (true)] + public virtual bool RightToLeftLayout { + get { + return right_to_left_layout; + } + set { + if (right_to_left_layout != value) { + right_to_left_layout = value; + OnRightToLeftLayoutChanged (EventArgs.Empty); + } + } + } + + // whether or not the check box is shown + [DefaultValue(false)] + public bool ShowCheckBox { + set { + if (show_check_box != value) { + show_check_box = value; + // invalidate the value inside this control + this.Invalidate (date_area_rect); + OnUIAShowCheckBoxChanged (); + } + } + get { + return show_check_box; + } + } + + // if true show the updown control, else popup the monthcalendar + [DefaultValue(false)] + public bool ShowUpDown { + set { + if (show_up_down != value) { + show_up_down = value; + // need to invalidate the whole control + this.Invalidate (); + OnUIAShowUpDownChanged (); + } + } + get { + return show_up_down; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public override string Text { + set { + DateTime parsed_value; + + if (value == null || value == string.Empty) { + date_value = DateTime.Now; + OnValueChanged (EventArgs.Empty); + OnTextChanged (EventArgs.Empty); + return; + } + + if (format == DateTimePickerFormat.Custom) { + // TODO: if the format is a custom format we need to do a custom parse here + // This implementation will fail if the custom format is set to something that can + // be a standard datetime format string + // http://msdn2.microsoft.com/en-us/library/az4se3k1.aspx + parsed_value = DateTime.ParseExact (value, GetExactFormat (), null); + } else { + parsed_value = DateTime.ParseExact (value, GetExactFormat (), null); + } + + if (date_value != parsed_value) { + Value = parsed_value; + } + } + get { + if (!IsHandleCreated) + return ""; + + if (format == DateTimePickerFormat.Custom) { + System.Text.StringBuilder result = new System.Text.StringBuilder (); + for (int i = 0; i < part_data.Length; i++) { + result.Append(part_data[i].GetText(date_value)); + } + return result.ToString (); + } else { + return Value.ToString (GetExactFormat ()); + } + } + } + + [Bindable(true)] + [RefreshProperties(RefreshProperties.All)] + public DateTime Value { + set { + if (date_value != value) { + if (value < MinDate || value > MaxDate) + throw new ArgumentOutOfRangeException ("value", "value must be between MinDate and MaxDate"); + + date_value = value; + this.OnValueChanged (EventArgs.Empty); + this.Invalidate (date_area_rect); + } + } + get { + return date_value; + } + } + + #endregion // public properties + + #region public methods + + // just return the text value + public override string ToString () { + return this.Text; + } + + #endregion // public methods + + #region public events + static object CloseUpEvent = new object (); + static object DropDownEvent = new object (); + static object FormatChangedEvent = new object (); + static object ValueChangedEvent = new object (); + static object RightToLeftLayoutChangedEvent = new object (); + + // raised when the monthcalendar is closed + public event EventHandler CloseUp { + add { Events.AddHandler (CloseUpEvent, value); } + remove { Events.RemoveHandler (CloseUpEvent, value); } + } + + // raised when the monthcalendar is opened + public event EventHandler DropDown { + add { Events.AddHandler (DropDownEvent, value); } + remove { Events.RemoveHandler (DropDownEvent, value); } + } + + // raised when the format of the value is changed + public event EventHandler FormatChanged { + add { Events.AddHandler (FormatChangedEvent, value); } + remove { Events.RemoveHandler (FormatChangedEvent, value); } + } + + // raised when the date Value is changed + public event EventHandler ValueChanged { + add { Events.AddHandler (ValueChangedEvent, value); } + remove { Events.RemoveHandler (ValueChangedEvent, value); } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler BackColorChanged { + add { + base.BackColorChanged += value; + } + + remove { + base.BackColorChanged -= value; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler BackgroundImageChanged { + add { + base.BackgroundImageChanged += value; + } + + remove { + base.BackgroundImageChanged -= value; + } + } + + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public new event EventHandler BackgroundImageLayoutChanged { + add + { + base.BackgroundImageLayoutChanged += value; + } + + remove + { + base.BackgroundImageLayoutChanged -= value; + } + } + + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public new event EventHandler Click { + add { + base.Click += value; + } + remove { + base.Click -= value; + } + } + + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public new event EventHandler DoubleClick { + add { + base.DoubleClick += value; + } + remove { + base.DoubleClick -= value; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler ForeColorChanged { + add { + base.ForeColorChanged += value; + } + + remove { + base.ForeColorChanged -= value; + } + } + + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public new event MouseEventHandler MouseClick { + add { + base.MouseClick += value; + } + remove { + base.MouseClick -= value; + } + } + + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public new event MouseEventHandler MouseDoubleClick { + add { + base.MouseDoubleClick += value; + } + remove { + base.MouseDoubleClick -= value; + } + } + + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public new event EventHandler PaddingChanged { + add + { + base.PaddingChanged += value; + } + remove + { + base.PaddingChanged -= value; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Never)] + public new event PaintEventHandler Paint { + add { + base.Paint += value; + } + + remove { + base.Paint -= value; + } + } + + public event EventHandler RightToLeftLayoutChanged { + add { + Events.AddHandler (RightToLeftLayoutChangedEvent, value); + } + remove { + Events.RemoveHandler (RightToLeftLayoutChangedEvent, value); + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + public new event EventHandler TextChanged { + add { + base.TextChanged += value; + } + + remove { + base.TextChanged -= value; + } + } + #endregion // public events + + #region protected properties + + // not sure why we're overriding this one + protected override CreateParams CreateParams { + get { + return base.CreateParams; + } + } + + // specify the default size for this control + protected override Size DefaultSize { + get { + // todo actually measure this properly + return new Size (200, PreferredHeight); + } + } + + #endregion // protected properties + + #region protected methods + + // not sure why we're overriding this one + protected override AccessibleObject CreateAccessibilityInstance () { + return base.CreateAccessibilityInstance (); + } + + // not sure why we're overriding this one + protected override void CreateHandle () { + base.CreateHandle (); + } + + // not sure why we're overriding this one + protected override void DestroyHandle () { + base.DestroyHandle (); + } + + // find out if this key is an input key for us, depends on which date part is focused + protected override bool IsInputKey (Keys keyData) { + switch (keyData) + { + case Keys.Up: + case Keys.Down: + case Keys.Left: + case Keys.Right: + return true; + } + return false; + } + + // raises the CloseUp event + protected virtual void OnCloseUp (EventArgs eventargs) { + EventHandler eh = (EventHandler)(Events [CloseUpEvent]); + if (eh != null) + eh (this, eventargs); + } + + // raise the drop down event + protected virtual void OnDropDown (EventArgs eventargs) { + EventHandler eh = (EventHandler)(Events [DropDownEvent]); + if (eh != null) + eh (this, eventargs); + } + + protected override void OnFontChanged(EventArgs e) { + // FIXME - do we need to update/invalidate/recalc our stuff? + month_calendar.Font = Font; + Size = new Size (Size.Width, PreferredHeight); + + base.OnFontChanged (e); + } + + // raises the format changed event + protected virtual void OnFormatChanged (EventArgs e) { + EventHandler eh = (EventHandler)(Events [FormatChangedEvent]); + if (eh != null) + eh (this, e); + } + + protected override void OnHandleCreated (EventArgs e) { + base.OnHandleCreated(e); + } + protected override void OnHandleDestroyed (EventArgs e) { + base.OnHandleDestroyed(e); + } + + //[EditorBrowsable (EditorBrowsableState.Advanced)] + protected virtual void OnRightToLeftLayoutChanged (EventArgs e) { + EventHandler eh = (EventHandler) Events [RightToLeftLayoutChangedEvent]; + if (eh != null) + eh (this, e); + } + + // not sure why we're overriding this one + protected override void OnSystemColorsChanged (EventArgs e) { + base.OnSystemColorsChanged (e); + } + + // raise the ValueChanged event + protected virtual void OnValueChanged (EventArgs eventargs) { + EventHandler eh = (EventHandler)(Events [ValueChangedEvent]); + if (eh != null) + eh (this, eventargs); + } + + // SetBoundsCore was removed from the 2.0 public API, so + // I had to do this hack instead. :/ + internal override int OverrideHeight (int height) + { + return DefaultSize.Height; + } + + // not sure why we're overriding this + protected override void WndProc (ref Message m) { + base.WndProc (ref m); + } + + #endregion // protected methods + + #region internal / private properties + + // this is the region that the date and the check box is drawn on + internal Rectangle date_area_rect { + get { + return ThemeEngine.Current.DateTimePickerGetDateArea (this); + } + } + + internal Rectangle CheckBoxRect { + get { + Rectangle retval = new Rectangle (check_box_space, ClientSize.Height / 2 - check_box_size / 2, + check_box_size, check_box_size); + return retval; + } + } + + // the rectangle for the drop down arrow + internal Rectangle drop_down_arrow_rect { + get { + return ThemeEngine.Current.DateTimePickerGetDropDownButtonArea (this); + } + } + + // the part of the date that is currently hilighted + internal Rectangle hilight_date_area { + get { + // TODO: put hilighted part calculation in here + return Rectangle.Empty; + } + } + + internal bool DropDownButtonEntered { + get { return drop_down_button_entered; } + } + + #endregion + + #region internal / private methods + + private void ResizeHandler (object sender, EventArgs e) + { + Invalidate (); + } + + private void UpDownTimerTick (object sender, EventArgs e) + { + if (updown_timer.Interval == initial_timer_delay) + updown_timer.Interval = subsequent_timer_delay; + + if (is_down_pressed) + IncrementSelectedPart (-1); + else if (is_up_pressed) + IncrementSelectedPart (1); + else + updown_timer.Enabled = false; + } + + // calculates the maximum width + internal Single CalculateMaxWidth(string format, Graphics gr, StringFormat string_format) + { + SizeF size; + float result = 0; + string text; + Font font = this.Font; + + switch (format) + { + case "M": + case "MM": + case "MMM": + case "MMMM": + for (int i = 1; i <= 12; i++) { + text = PartData.GetText (Value.AddMonths (i), format); + size = gr.MeasureString (text, font, int.MaxValue, string_format); + result = Math.Max (result, size.Width); + } + return result; + case "d": + case "dd": + case "ddd": + case "dddd": + for (int i = 1; i <= 12; i++) { + text = PartData.GetText (Value.AddDays (i), format); + size = gr.MeasureString (text, font, int.MaxValue, string_format); + result = Math.Max (result, size.Width); + } + return result; + case "h": + case "hh": + for (int i = 1; i <= 12; i++) { + text = PartData.GetText (Value.AddHours (i), format); + size = gr.MeasureString (text, font, int.MaxValue, string_format); + result = Math.Max (result, size.Width); + } + return result; + case "H": + case "HH": + for (int i = 1; i <= 24; i++) { + text = PartData.GetText (Value.AddDays (i), format); + size = gr.MeasureString (text, font, int.MaxValue, string_format); + result = Math.Max (result, size.Width); + } + return result; + case "m": + case "mm": + for (int i = 1; i <= 60; i++) { + text = PartData.GetText (Value.AddMinutes (i), format); + size = gr.MeasureString (text, font, int.MaxValue, string_format); + result = Math.Max (result, size.Width); + } + return result; + case "s": + case "ss": + for (int i = 1; i <= 60; i++) { + text = PartData.GetText (Value.AddSeconds (i), format); + size = gr.MeasureString (text, font, int.MaxValue, string_format); + result = Math.Max (result, size.Width); + } + return result; + case "t": + case "tt": + for (int i = 1; i <= 2; i++) { + text = PartData.GetText (Value.AddHours (i * 12), format); + size = gr.MeasureString (text, font, int.MaxValue, string_format); + result = Math.Max (result, size.Width); + } + return result; + case "y": + case "yy": + case "yyyy": + // Actually all the allowed year values are between MinDateTime and MaxDateTime, + // which are 4 digits always + text = PartData.GetText (Value, format); + size = gr.MeasureString (text, font, int.MaxValue, string_format); + result = Math.Max (result, size.Width); + return result; + default: + return gr.MeasureString (format, font, int.MaxValue, string_format).Width; + } + } + + // returns the format of the date as a string + // (i.e. resolves the Format enum values to it's corresponding string format) + // Why CurrentCulture and not CurrentUICulture is explained here: + // http://blogs.msdn.com/michkap/archive/2007/01/11/1449754.aspx + private string GetExactFormat() + { + switch (this.format) { + case DateTimePickerFormat.Long: + return Thread.CurrentThread.CurrentCulture.DateTimeFormat.LongDatePattern; + case DateTimePickerFormat.Short: + return Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortDatePattern; + case DateTimePickerFormat.Time: + return Thread.CurrentThread.CurrentCulture.DateTimeFormat.LongTimePattern; + case DateTimePickerFormat.Custom: + return this.custom_format == null ? String.Empty : this.custom_format; + default: + return Thread.CurrentThread.CurrentCulture.DateTimeFormat.LongDatePattern; + } + } + + private void CalculateFormats() + { + string real_format; + System.Text.StringBuilder literal = new System.Text.StringBuilder (); + System.Collections.ArrayList formats = new ArrayList (); + bool is_literal = false; + char lastch = (char) 0; + char ch; + + real_format = GetExactFormat (); + + // parse the format string + for (int i = 0; i < real_format.Length; i++) + { + ch = real_format [i]; + + if (is_literal && ch != '\'') + { + literal.Append (ch); + continue; + } + + switch (ch) + { + case 't': + case 'd': + case 'h': + case 'H': + case 'm': + case 'M': + case 's': + case 'y': + case 'g': // Spec says nothing about g, but it seems to be treated like spaces. + if (!(lastch == ch || lastch == 0) && literal.Length != 0) + { + formats.Add (new PartData(literal.ToString (), false, this)); + literal.Length = 0; + } + literal.Append (ch); + break; + case '\'': + if (is_literal && i < real_format.Length - 1 && real_format [i + 1] == '\'') { + literal.Append (ch); + i++; + break; + } + if (literal.Length == 0) { + is_literal = !is_literal; + break; + } + formats.Add (new PartData (literal.ToString (), is_literal, this)); + literal.Length = 0; + is_literal = !is_literal; + break; + default: + if (literal.Length != 0) + { + formats.Add (new PartData(literal.ToString (), false, this)); + literal.Length = 0; + } + formats.Add (new PartData (ch.ToString(), true, this)); + break; + + } + lastch = ch; + } + if (literal.Length >= 0) + formats.Add (new PartData (literal.ToString (), is_literal, this)); + + part_data = new PartData [formats.Count]; + formats.CopyTo (part_data); + } + + private Point CalculateDropDownLocation (Rectangle parent_control_rect, Size child_size, bool align_left) + { + // default bottom left + Point location = new Point(parent_control_rect.Left + 5, parent_control_rect.Bottom); + // now adjust the alignment + if (!align_left) { + location.X = parent_control_rect.Right - child_size.Width; + } + + Point screen_location = PointToScreen (location); + Rectangle working_area = Screen.FromControl(this).WorkingArea; + // now adjust if off the right side of the screen + if (screen_location.X < working_area.X) { + screen_location.X = working_area.X; + } + // now adjust if it should be displayed above control + if (screen_location.Y + child_size.Height > working_area.Bottom) { + screen_location.Y -= (parent_control_rect.Height + child_size.Height); + } + + // since the parent of the month calendar is the form, adjust accordingly. + if (month_calendar.Parent != null) { + screen_location = month_calendar.Parent.PointToClient(screen_location); + } + + return screen_location; + } + + // actually draw this control + internal void Draw (Rectangle clip_rect, Graphics dc) + { + ThemeEngine.Current.DrawDateTimePicker (dc, clip_rect, this); + } + + // drop the calendar down + internal void DropDownMonthCalendar () + { + EndDateEdit (true); + // ensure the right date is set for the month_calendar + month_calendar.SetDate (this.date_value); + // get a rectangle that has the dimensions of the text area, + // but the height of the dtp control. + Rectangle align_area = this.date_area_rect; + align_area.Y = this.ClientRectangle.Y; + align_area.Height = this.ClientRectangle.Height; + + // establish the month calendar's location + month_calendar.Location = CalculateDropDownLocation ( + align_area, + month_calendar.Size, + (this.DropDownAlign == LeftRightAlignment.Left)); + month_calendar.Show (); + month_calendar.Focus (); + month_calendar.Capture = true; + + // fire any registered events + // XXX should this just call OnDropDown? + EventHandler eh = (EventHandler)(Events [DropDownEvent]); + if (eh != null) + eh (this, EventArgs.Empty); + } + + // hide the month calendar + internal void HideMonthCalendar () + { + this.is_drop_down_visible = false; + Invalidate (drop_down_arrow_rect); + month_calendar.Capture = false; + if (month_calendar.Visible) { + month_calendar.Hide (); + } + Focus (); + } + + private int GetSelectedPartIndex() + { + for (int i = 0; i < part_data.Length; i++) + { + if (part_data[i].Selected && !part_data[i].is_literal) + return i; + } + return -1; + } + + internal void IncrementSelectedPart(int delta) + { + int selected_index = GetSelectedPartIndex(); + + if (selected_index == -1) { + return; + } + + EndDateEdit (false); + + DateTimePart dt_part = part_data [selected_index].date_time_part; + switch (dt_part) + { + case DateTimePart.Day: + if (delta < 0) { + if (Value.Day == 1) + SetPart(DateTime.DaysInMonth(Value.Year, Value.Month), dt_part); + else + SetPart(Value.Day + delta, dt_part); + } else { + if (Value.Day == DateTime.DaysInMonth(Value.Year, Value.Month)) + SetPart(1, dt_part); + else + SetPart(Value.Day + delta, dt_part) ; + } + break; + case DateTimePart.DayName: + Value = Value.AddDays(delta); + break; + case DateTimePart.AMPMHour: + case DateTimePart.Hour: + SetPart(Value.Hour + delta, dt_part); + break; + case DateTimePart.Minutes: + SetPart(Value.Minute + delta, dt_part); + break; + case DateTimePart.Month: + SetPart (Value.Month + delta, dt_part, true); + break; + case DateTimePart.Seconds: + SetPart(Value.Second + delta, dt_part); + break; + case DateTimePart.AMPMSpecifier: + int hour = Value.Hour; + hour = hour >= 0 && hour <= 11 ? hour + 12 : hour - 12; + SetPart (hour, DateTimePart.Hour); + break; + case DateTimePart.Year: + SetPart(Value.Year + delta, dt_part); + break; + } + } + + internal void SelectPart (int index) + { + is_checkbox_selected = false; + for (int i = 0; i < part_data.Length; i++) + { + part_data[i].Selected = (i == index); + } + + Invalidate (); + OnUIASelectionChanged (); + } + + internal void SelectNextPart() + { + int selected_index; + if (is_checkbox_selected) { + for (int i = 0; i < part_data.Length; i++) + { + if (!part_data[i].is_literal) + { + is_checkbox_selected = false; + part_data[i].Selected = true; + Invalidate(); + break; + } + } + } else { + selected_index = GetSelectedPartIndex(); + if (selected_index >= 0) + part_data [selected_index].Selected = false; + + for (int i = selected_index + 1; i < part_data.Length; i++) + { + if (!part_data[i].is_literal) + { + part_data [i].Selected = true; + Invalidate(); + break; + } + } + if (GetSelectedPartIndex() == -1) + { // if no part was found before the end, look from the beginning + if (ShowCheckBox) + { + is_checkbox_selected = true; + Invalidate(); + } + else + { + for (int i = 0; i <= selected_index; i++) + { + if (!part_data[i].is_literal) + { + part_data[i].Selected = true; + Invalidate(); + break; + } + } + } + } + } + + OnUIASelectionChanged (); + } + + internal void SelectPreviousPart() + { + if (is_checkbox_selected) + { + for (int i = part_data.Length - 1; i >= 0; i--) + { + if (!part_data[i].is_literal) + { + is_checkbox_selected = false; + part_data[i].Selected = true; + Invalidate(); + break; + } + } + } + else + { + int selected_index = GetSelectedPartIndex(); + + if (selected_index >= 0) + part_data[selected_index].Selected = false; + + for (int i = selected_index - 1; i >= 0; i--) + { + if (!part_data[i].is_literal) + { + part_data[i].Selected = true; + Invalidate(); + break; + } + } + if (GetSelectedPartIndex() == -1) + { // if no part was found before the beginning, look from the end + if (ShowCheckBox) + { + is_checkbox_selected = true; + Invalidate(); + } + else + { + for (int i = part_data.Length - 1; i >= selected_index; i--) + { + if (!part_data[i].is_literal) + { + part_data[i].Selected = true; + Invalidate(); + break; + } + } + } + } + } + + OnUIASelectionChanged (); + } + + // raised by key down events. + private void KeyDownHandler(object sender, KeyEventArgs e) + { + switch (e.KeyCode) + { + case Keys.Add: + case Keys.Up: + { + if (ShowCheckBox && Checked == false) + break; + IncrementSelectedPart(1); + e.Handled = true; + break; + } + case Keys.Subtract: + case Keys.Down: + { + if (ShowCheckBox && Checked == false) + break; + IncrementSelectedPart(-1); + e.Handled = true; + break; + } + case Keys.Left: + {// select the next part to the left + if (ShowCheckBox && Checked == false) + break; + SelectPreviousPart(); + e.Handled = true; + break; + } + case Keys.Right: + {// select the next part to the right + if (ShowCheckBox && Checked == false) + break; + SelectNextPart(); + e.Handled = true; + break; + } + case Keys.F4: + if (!e.Alt && !is_drop_down_visible) { + DropDownMonthCalendar (); + e.Handled = true; + } + + break; + } + } + + // raised by any key down events + private void KeyPressHandler (object sender, KeyPressEventArgs e) + { + switch (e.KeyChar) { + case ' ': + if (show_check_box && is_checkbox_selected) + Checked = !Checked; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + int number = e.KeyChar - (int) '0'; + int selected_index = GetSelectedPartIndex(); + if (selected_index == -1) + break; + if (!part_data[selected_index].is_numeric_format) + break; + + DateTimePart dt_part = part_data [selected_index].date_time_part; + if (editing_part_index < 0) { + editing_part_index = selected_index; + editing_number = 0; + editing_text = String.Empty; + } + + editing_text += number.ToString (); + int date_part_max_length = 0; + + switch (dt_part) { + case DateTimePart.Day: + case DateTimePart.Month: + case DateTimePart.Seconds: + case DateTimePart.Minutes: + case DateTimePart.AMPMHour: + case DateTimePart.Hour: + date_part_max_length = 2; + break; + case DateTimePart.Year: + date_part_max_length = 4; + break; + } + + editing_number = editing_number * 10 + number; + if (editing_text.Length >= date_part_max_length) + EndDateEdit (false); + + Invalidate (date_area_rect); + break; + default: + break; + } + e.Handled = true; + } + + private void EndDateEdit (bool invalidate) + { + if (editing_part_index == -1) + return; + + PartData part = part_data [editing_part_index]; + if (part.date_time_part == DateTimePart.Year) { // Special case + // Infer, like .Net does + if (editing_number > 0 && editing_number < 30) + editing_number += 2000; + else if (editing_number >= 30 && editing_number < 100) + editing_number += 1900; + } + + SetPart (editing_number, part.date_time_part); + editing_part_index = editing_number = -1; + editing_text = null; + + if (invalidate) + Invalidate (date_area_rect); + } + + internal void SetPart (int value, DateTimePart dt_part) + { + SetPart (value, dt_part, false); + } + + // set the specified part of the date to the specified value + internal void SetPart (int value, DateTimePart dt_part, bool adjust) + { + switch (dt_part) + { + case DateTimePart.Seconds: + if (value == -1) + value = 59; + if (value >= 0 && value <= 59) + Value = new DateTime(Value.Year, Value.Month, Value.Day, Value.Hour, Value.Minute, value, Value.Millisecond); + break; + case DateTimePart.Minutes: + if (value == -1) + value = 59; + if (value >= 0 && value <= 59) + Value = new DateTime(Value.Year, Value.Month, Value.Day, Value.Hour, value, Value.Second, Value.Millisecond); + break; + case DateTimePart.AMPMHour: + if (value == -1) + value = 23; + if (value >= 0 && value <= 23) { + int prev_hour = Value.Hour; + if ((prev_hour >= 12 && prev_hour <= 23) && value < 12) // Adjust to p.m. + value += 12; + Value = new DateTime (Value.Year, Value.Month, Value.Day, value, Value.Minute, Value.Second, Value.Millisecond); + } + break; + case DateTimePart.Hour: + if (value == -1) + value = 23; + if (value >= 0 && value <= 23) + Value = new DateTime(Value.Year, Value.Month, Value.Day, value, Value.Minute, Value.Second, Value.Millisecond); + break; + case DateTimePart.Day: + int max_days = DateTime.DaysInMonth(Value.Year, Value.Month); + if (value >= 1 && value <= 31 && value <= max_days) + Value = new DateTime(Value.Year, Value.Month, value, Value.Hour, Value.Minute, Value.Second, Value.Millisecond); + break; + case DateTimePart.Month: + DateTime date = Value; + + if (adjust) { + if (value == 0) { + date = date.AddYears (-1); + value = 12; + } else if (value == 13) { + date = date.AddYears (1); + value = 1; + } + } + + if (value >= 1 && value <= 12) { + // if we move from say december to november with days on 31, we must + // remap to the maximum number of days + int days_in_new_month = DateTime.DaysInMonth (date.Year, value); + + if (date.Day > days_in_new_month) + Value = new DateTime (date.Year, value, days_in_new_month, date.Hour, date.Minute, date.Second, date.Millisecond); + else + Value = new DateTime (date.Year, value, date.Day, date.Hour, date.Minute, date.Second, date.Millisecond); + } + break; + case DateTimePart.Year: + if (value >= min_date.Year && value <= max_date.Year) { + // if we move to a leap year, the days in month could throw an exception + int days_in_new_month = DateTime.DaysInMonth (value, Value.Month); + + if (Value.Day > days_in_new_month) + Value = new DateTime (value, Value.Month, days_in_new_month, Value.Hour, Value.Minute, Value.Second, Value.Millisecond); + else + Value = new DateTime (value, Value.Month, Value.Day, Value.Hour, Value.Minute, Value.Second, Value.Millisecond); + } + break; + } + } + + private void GotFocusHandler (object sender, EventArgs e) + { + if (ShowCheckBox) { + is_checkbox_selected = true; + Invalidate (CheckBoxRect); + OnUIASelectionChanged (); + } + } + + // if we loose focus deselect any selected parts. + private void LostFocusHandler (object sender, EventArgs e) + { + int selected_index = GetSelectedPartIndex (); + if (selected_index != -1) + { + part_data [selected_index].Selected = false; + Rectangle invalidate_rect = Rectangle.Ceiling (part_data [selected_index].drawing_rectangle); + invalidate_rect.Inflate (2, 2); + Invalidate (invalidate_rect); + OnUIASelectionChanged (); + } + else if (is_checkbox_selected) + { + is_checkbox_selected = false; + Invalidate (CheckBoxRect); + OnUIASelectionChanged (); + } + } + + // if month calendar looses focus and the drop down is up, then close it + private void MonthCalendarLostFocusHandler(object sender, EventArgs e) + { + if (is_drop_down_visible && !month_calendar.Focused) + { + //this.HideMonthCalendar(); + //This is handled from the monthcalender itself, + //it may loose focus, but still has to be visible, + //for instance when the context menu is displayed. + } + + } + + private void MonthCalendarDateChangedHandler (object sender, DateRangeEventArgs e) + { + if (month_calendar.Visible) + this.Value = e.Start.Date.Add (this.Value.TimeOfDay); + } + + // fired when a user clicks on the month calendar to select a date + private void MonthCalendarDateSelectedHandler (object sender, DateRangeEventArgs e) + { + this.HideMonthCalendar (); + } + + private void MouseUpHandler(object sender, MouseEventArgs e) + { + if (ShowUpDown) + { + if (is_up_pressed || is_down_pressed) + { + updown_timer.Enabled = false; + is_up_pressed = false; + is_down_pressed = false; + Invalidate (drop_down_arrow_rect); + } + } + } + + // to check if the mouse has come down on this control + private void MouseDownHandler (object sender, MouseEventArgs e) + { + // Only left clicks are handled. + if (e.Button != MouseButtons.Left) + return; + + if (ShowCheckBox && CheckBoxRect.Contains(e.X, e.Y)) + { + is_checkbox_selected = true; + Checked = !Checked; + OnUIASelectionChanged (); + return; + } + + // Deselect the checkbox only if the pointer is not on it + // *and* the other parts are enabled (Checked as true) + if (Checked) { + is_checkbox_selected = false; + OnUIASelectionChanged (); + } + + if (ShowUpDown && drop_down_arrow_rect.Contains (e.X, e.Y)) + { + if (!(ShowCheckBox && Checked == false)) + { + if (e.Y < this.Height / 2) { + is_up_pressed = true; + is_down_pressed = false; + IncrementSelectedPart (1); + } else { + is_up_pressed = false; + is_down_pressed = true; + IncrementSelectedPart (-1); + } + Invalidate (drop_down_arrow_rect); + updown_timer.Interval = initial_timer_delay; + updown_timer.Enabled = true; + } + } else if (is_drop_down_visible == false && drop_down_arrow_rect.Contains (e.X, e.Y)) { + DropDownButtonClicked (); + } else { + // mouse down on this control anywhere else collapses it + if (is_drop_down_visible) { + HideMonthCalendar (); + } + if (!(ShowCheckBox && Checked == false)) + { + // go through the parts to see if the click is in any of them + bool invalidate_afterwards = false; + for (int i = 0; i < part_data.Length; i++) { + bool old = part_data [i].Selected; + + if (part_data [i].is_literal) + continue; + + if (part_data [i].drawing_rectangle.Contains (e.X, e.Y)) { + part_data [i].Selected = true; + } else + part_data [i].Selected = false; + + if (old != part_data [i].Selected) + invalidate_afterwards = true; + } + if (invalidate_afterwards) { + Invalidate (); + OnUIASelectionChanged (); + } + } + + } + } + + internal void DropDownButtonClicked () + { + if (!is_drop_down_visible) { + is_drop_down_visible = true; + if (!Checked) + Checked = true; + Invalidate (drop_down_arrow_rect); + DropDownMonthCalendar (); + } else { + HideMonthCalendar (); + } + } + + // paint this control now + private void PaintHandler (object sender, PaintEventArgs pe) { + if (Width <= 0 || Height <= 0 || Visible == false) + return; + + Draw (pe.ClipRectangle, pe.Graphics); + } + + void OnMouseEnter (object sender, EventArgs e) + { + if (ThemeEngine.Current.DateTimePickerBorderHasHotElementStyle) + Invalidate (); + } + + void OnMouseLeave (object sender, EventArgs e) + { + drop_down_button_entered = false; + if (ThemeEngine.Current.DateTimePickerBorderHasHotElementStyle) + Invalidate (); + } + + void OnMouseMove (object sender, MouseEventArgs e) + { + if (!is_drop_down_visible && + ThemeEngine.Current.DateTimePickerDropDownButtonHasHotElementStyle && + drop_down_button_entered != drop_down_arrow_rect.Contains (e.Location)) { + drop_down_button_entered = !drop_down_button_entered; + Invalidate (drop_down_arrow_rect); + } + } + #endregion + + #region internal classes + internal enum DateTimePart { + Seconds, + Minutes, + AMPMHour, + Hour, + Day, + DayName, + Month, + Year, + AMPMSpecifier, + Literal + } + + internal class PartData + { + internal string value; + internal bool is_literal; + bool is_selected; + internal RectangleF drawing_rectangle; + internal DateTimePart date_time_part; + DateTimePicker owner; + + internal bool is_numeric_format + { + get + { + if (is_literal) + return false; + switch (value) { + case "m": + case "mm": + case "d": + case "dd": + case "h": + case "hh": + case "H": + case "HH": + case "M": + case "MM": + case "s": + case "ss": + case "y": + case "yy": + case "yyyy": + return true; + case "ddd": + case "dddd": + return false; + default: + return false; + } + } + } + + internal PartData(string value, bool is_literal, DateTimePicker owner) + { + this.value = value; + this.is_literal = is_literal; + this.owner = owner; + date_time_part = GetDateTimePart (value); + } + + internal bool Selected { + get { + return is_selected; + } + set { + if (value == is_selected) + return; + + owner.EndDateEdit (false); + is_selected = value; + } + } + + // calculate the string to show for this data + internal string GetText(DateTime date) + { + if (is_literal) { + return value; + } else { + return GetText (date, value); + } + } + + static DateTimePart GetDateTimePart (string value) + { + switch (value) { + case "s": + case "ss": + return DateTimePart.Seconds; + case "m": + case "mm": + return DateTimePart.Minutes; + case "h": + case "hh": + return DateTimePart.AMPMHour; + case "H": + case "HH": + return DateTimePart.Hour; + case "d": + case "dd": + return DateTimePart.Day; + case "ddd": + case "dddd": + return DateTimePart.DayName; + case "M": + case "MM": + case "MMMM": + return DateTimePart.Month; + case "y": + case "yy": + case "yyy": + case "yyyy": + return DateTimePart.Year; + case "t": + case "tt": + return DateTimePart.AMPMSpecifier; + } + + return DateTimePart.Literal; + } + + static internal string GetText(DateTime date, string format) + { + if (format.StartsWith ("g")) + return " "; + else if (format.Length == 1) + return date.ToString ("%" + format); + else if (format == "yyyyy" || format == "yyyyyy" || format == "yyyyyyy" || format == "yyyyyyyy") + return date.ToString ("yyyy"); + else if (format.Length > 1) + return date.ToString (format); + else + return string.Empty; + } + } + + #endregion + + #region UIA Framework: Methods, Properties and Events + + internal bool UIAIsCheckBoxSelected { + get { return is_checkbox_selected; } + } + + static object UIAMinimumChangedEvent = new object (); + static object UIAMaximumChangedEvent = new object (); + static object UIASelectionChangedEvent = new object (); + static object UIACheckedEvent = new object (); + static object UIAShowCheckBoxChangedEvent = new object (); + static object UIAShowUpDownChangedEvent = new object (); + + internal event EventHandler UIAMinimumChanged { + add { Events.AddHandler (UIAMinimumChangedEvent, value); } + remove { Events.RemoveHandler (UIAMinimumChangedEvent, value); } + } + + internal event EventHandler UIAMaximumChanged { + add { Events.AddHandler (UIAMinimumChangedEvent, value); } + remove { Events.RemoveHandler (UIAMinimumChangedEvent, value); } + } + + internal event EventHandler UIASelectionChanged { + add { Events.AddHandler (UIASelectionChangedEvent, value); } + remove { Events.RemoveHandler (UIASelectionChangedEvent, value); } + } + + internal event EventHandler UIAChecked { + add { Events.AddHandler (UIACheckedEvent, value); } + remove { Events.RemoveHandler (UIACheckedEvent, value); } + } + + internal event EventHandler UIAShowCheckBoxChanged { + add { Events.AddHandler (UIAShowCheckBoxChangedEvent, value); } + remove { Events.RemoveHandler (UIAShowCheckBoxChangedEvent, value); } + } + + internal event EventHandler UIAShowUpDownChanged { + add { Events.AddHandler (UIAShowUpDownChangedEvent, value); } + remove { Events.RemoveHandler (UIAShowUpDownChangedEvent, value); } + } + + internal void OnUIAMinimumChanged () + { + EventHandler eh = (EventHandler)(Events [UIAMinimumChangedEvent]); + if (eh != null) + eh (this, EventArgs.Empty); + } + + internal void OnUIAMaximumChanged () + { + EventHandler eh = (EventHandler)(Events [UIAMaximumChangedEvent]); + if (eh != null) + eh (this, EventArgs.Empty); + } + + internal void OnUIASelectionChanged () + { + EventHandler eh = (EventHandler)(Events [UIASelectionChangedEvent]); + if (eh != null) + eh (this, EventArgs.Empty); + } + + internal void OnUIAChecked () + { + EventHandler eh = (EventHandler)(Events [UIACheckedEvent]); + if (eh != null) + eh (this, EventArgs.Empty); + } + + internal void OnUIAShowCheckBoxChanged () + { + EventHandler eh = (EventHandler)(Events [UIAShowCheckBoxChangedEvent]); + if (eh != null) + eh (this, EventArgs.Empty); + } + + internal void OnUIAShowUpDownChanged () + { + EventHandler eh = (EventHandler)(Events [UIAShowUpDownChangedEvent]); + if (eh != null) + eh (this, EventArgs.Empty); + } + + #endregion + } +} |