[LoongArch64] Part-5:add loongarch support in some files for LoongArch64. (#21769)

[mono-project.git] / mcs / class / System.Windows.Forms / System.Windows.Forms / DateTimePicker.cs

// 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  jba-mono@optusnet.com.au
//      Rolf Bjarne Kvinge      rolfkvinge@ya.com
//
// 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.Windows.Forms;

namespace System.Windows.Forms {
        [ClassInterface (ClassInterfaceType.AutoDispatch)]
        [DefaultBindingProperty ("Value")]
        [ComVisible (true)]
        [DefaultEvent("ValueChanged")]
        [DefaultProperty("Value")]
        [Designer("System.Windows.Forms.Design.DateTimePickerDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
        public class DateTimePicker : Control {

                #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 : ControlAccessibleObject {
                        #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 = Control.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 (ControlStyles.UserPaint | ControlStyles.StandardClick, false);
                        SetStyle (ControlStyles.FixedHeight, true);
                        SetStyle (ControlStyles.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 Threading.Thread.CurrentThread.CurrentCulture.DateTimeFormat.LongDatePattern;
                        case DateTimePickerFormat.Short:
                                return Threading.Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortDatePattern;
                        case DateTimePickerFormat.Time:
                                return Threading.Thread.CurrentThread.CurrentCulture.DateTimeFormat.LongTimePattern;
                        case DateTimePickerFormat.Custom:
                                return this.custom_format == null ? String.Empty : this.custom_format;
                        default:
                                return Threading.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
        }
}