DotNetBar ComboBoxEx

DotNetBar ComboBoxEx

using System;
using System.ComponentModel;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using Endv.DotNetBar.Rendering;
using Endv.DotNetBar.TextMarkup;
using Endv.Editors;

namespace Endv.DotNetBar.Controls
{
    /// <summary>
    /// Represents enhanced Windows combo box control.
    /// </summary>
    [ToolboxBitmap(typeof(ComboBoxEx), "Controls.ComboBoxEx.ico"), ToolboxItem(true), Designer(typeof(Design.ComboBoxExDesigner))]
    public class ComboBoxEx : System.Windows.Forms.ComboBox, ICommandSource
    {
        /// <summary>
        /// Represents the method that will handle the DropDownChange event.
        /// </summary>
        public delegate void OnDropDownChangeEventHandler(object sender, bool Expanded);
        /// <summary>
        /// Occurs when drop down portion of combo box is shown or hidden.
        /// </summary>
        public event OnDropDownChangeEventHandler DropDownChange;

        private eDotNetBarStyle m_Style=eDotNetBarStyle.Office2007;
        private bool m_DefaultStyle=false;            // Disables our drawing in WndProc
        private bool m_MouseOver=false;
        private bool m_MouseOverThumb=false;
        private bool m_DroppedDown=false;
        //private System.Windows.Forms.Timer m_Timer;
        private bool m_WindowsXPAware=false;
        private bool m_DisableInternalDrawing=false;
        private ImageList m_ImageList=null;
        private int m_DropDownHeight=0;
        private IntPtr m_LastFocusWindow;
        private IntPtr m_DropDownHandle=IntPtr.Zero;
        private ComboTextBoxMsgHandler m_TextWindowMsgHandler=null;
        //private ComboListBoxMsgHandler m_ListBoxMsgHandler = null;

        [DllImport("user32")]
        private static extern bool ValidateRect(IntPtr hWnd,ref NativeFunctions.RECT pRect);

        [DllImport("user32",SetLastError=true, CharSet=CharSet.Auto)]
        private static extern IntPtr GetWindow(IntPtr hWnd, uint uCmd);
        private const uint GW_CHILD=5;

        private bool m_PreventEnterBeep=false;

        private string m_WatermarkText = "";
        private bool m_Focused = false;
        private Font m_WatermarkFont = null;
        private Color m_WatermarkColor = SystemColors.GrayText;
        private bool m_IsStandalone = true;
        private Timer m_MouseOverTimer = null;
        private Rectangle m_ThumbRect = Rectangle.Empty;
        private bool _FocusHighlightEnabled = false;
        private static Color _DefaultHighlightColor = Color.FromArgb(0xFF, 0xFF, 0x88);
        private Color _FocusHighlightColor = _DefaultHighlightColor;

        /// <summary>
        /// Creates new instance of ComboBoxEx.
        /// </summary>
        public ComboBoxEx():base()
        {
            if(!ColorFunctions.ColorsLoaded)
            {
                NativeFunctions.RefreshSettings();
                NativeFunctions.OnDisplayChange();
                ColorFunctions.LoadColors();
            }
            m_MouseOverTimer = new Timer();
            m_MouseOverTimer.Interval = 10;
            m_MouseOverTimer.Enabled = false;
            m_MouseOverTimer.Tick += new EventHandler(MouseOverTimerTick);
#if FRAMEWORK20
            this.FlatStyle = FlatStyle.Flat;
#endif
        }

        private bool _FocusCuesEnabled = true;
        /// <summary>
        /// Gets or sets whether control displays focus cues when focused.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether control displays focus cues when focused.")]
        public virtual bool FocusCuesEnabled
        {
            get { return _FocusCuesEnabled; }
            set
            {
                _FocusCuesEnabled = value;
                if (this.Focused) this.Invalidate();
            }
        }

        /// <summary>
        /// Gets or sets whether control is stand-alone control. Stand-alone flag affects the appearance of the control in Office 2007 style.
        /// </summary>
        [Browsable(true), DefaultValue(true), Category("Appearance"), Description("Indicates the appearance of the control.")]
        public bool IsStandalone
        {
            get { return m_IsStandalone; }
            set
            {
                m_IsStandalone = value;
            }
        }

        private bool _WatermarkEnabled = true;
        /// <summary>
        /// Gets or sets whether watermark text is displayed when control is empty. Default value is true.
        /// </summary>
        [DefaultValue(true), Description("Indicates whether watermark text is displayed when control is empty.")]
        public virtual bool WatermarkEnabled
        {
            get { return _WatermarkEnabled; }
            set { _WatermarkEnabled = value; this.Invalidate(); }
        }

        /// <summary>
        /// Gets or sets the watermark (tip) text displayed inside of the control when Text is not set and control does not have input focus. This property supports text-markup.
        /// Note that WatermarkText is not compatible with the auto-complete feature of .NET Framework 2.0.
        /// </summary>
        [Browsable(true), DefaultValue(""), Localizable(true), Category("Appearance"), Description("Indicates watermark text displayed inside of the control when Text is not set and control does not have input focus."), Editor(typeof(Design.TextMarkupUIEditor), typeof(System.Drawing.Design.UITypeEditor))]
        public string WatermarkText
        {
            get { return m_WatermarkText; }
            set
            {
                if (value == null) value = "";
                m_WatermarkText = value;
                MarkupTextChanged();
                this.Invalidate();
            }
        }

        private eWatermarkBehavior _WatermarkBehavior = eWatermarkBehavior.HideOnFocus;
        /// <summary>
        /// Gets or sets the watermark hiding behaviour. Default value indicates that watermark is hidden when control receives input focus.
        /// </summary>
        [DefaultValue(eWatermarkBehavior.HideOnFocus), Category("Behavior"), Description("Indicates watermark hiding behaviour.")]
        public eWatermarkBehavior WatermarkBehavior
        {
            get { return _WatermarkBehavior; }
            set { _WatermarkBehavior = value; this.Invalidate(); }
        }

        private TextMarkup.BodyElement m_TextMarkup = null;
        private void MarkupTextChanged()
        {
            m_TextMarkup = null;

            if (!TextMarkup.MarkupParser.IsMarkup(ref m_WatermarkText))
                return;

            m_TextMarkup = TextMarkup.MarkupParser.Parse(m_WatermarkText);
            ResizeMarkup();
        }

        private void ResizeMarkup()
        {
            if (m_TextMarkup != null)
            {
                using (Graphics g = this.CreateGraphics())
                {
                    MarkupDrawContext dc = GetMarkupDrawContext(g);
                    m_TextMarkup.Measure(GetWatermarkBounds().Size, dc);
                    Size sz = m_TextMarkup.Bounds.Size;
                    m_TextMarkup.Arrange(new Rectangle(GetWatermarkBounds().Location, sz), dc);
                }
            }
        }
        private MarkupDrawContext GetMarkupDrawContext(Graphics g)
        {
            return new MarkupDrawContext(g, (m_WatermarkFont == null ? this.Font : m_WatermarkFont), m_WatermarkColor, this.RightToLeft == RightToLeft.Yes);
        }

        /// <summary>
        /// Gets or sets the watermark font.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Indicates watermark font."), DefaultValue(null)]
        public Font WatermarkFont
        {
            get { return m_WatermarkFont; }
            set { m_WatermarkFont = value; this.Invalidate(true); }
        }

        /// <summary>
        /// Gets or sets the watermark text color.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Indicates watermark text color.")]
        public Color WatermarkColor
        {
            get { return m_WatermarkColor; }
            set { m_WatermarkColor = value; this.Invalidate(true); }
        }
        /// <summary>
        /// Indicates whether property should be serialized by Windows Forms designer.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeWatermarkColor()
        {
            return m_WatermarkColor != SystemColors.GrayText;
        }
        /// <summary>
        /// Resets the property to default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetWatermarkColor()
        {
            this.WatermarkColor = SystemColors.GrayText;
        }

        /// <summary>
        /// Gets or sets the combo box background color. Note that in Office 2007 style back color of the control is automatically managed.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override Color BackColor
        {
            get
            {
                return base.BackColor;
            }
            set
            {
                base.BackColor = value;
            }
        }

        private bool m_UseCustomBackColor=false;
        /// <summary>
        /// Gets or sets whether the BackColor value you set is used instead of the style back color automatically provided by the control. Default
        /// value is false which indicates that BackColor property is automatically managed. Set this property to true and then set BackColor property
        /// to make control use your custom back color.
        /// </summary>
        [Browsable(false), DefaultValue(false)]
        public bool UseCustomBackColor
        {
            get { return m_UseCustomBackColor; }
            set { m_UseCustomBackColor = value; }
        }

        /// <summary>
        /// Gets or sets value indicating whether system combo box appearance is used. Default value is false.
        /// </summary>
        [Browsable(false),Category("Behavior"),Description("Makes Combo box appear the same as built-in Combo box."),DefaultValue(false)]
        public bool DefaultStyle
        {
            get
            {
                return m_DefaultStyle;
            }
            set
            {
                if(m_DefaultStyle!=value)
                {
                    m_DefaultStyle=value;
                    this.Invalidate(true);
                }
            }
        }

        /// <summary>
        /// Gets or sets value indicating whether the combo box is draw using the Windows XP Theme manager when running on Windows XP or theme aware OS.
        /// </summary>
        [Browsable(false),Category("Behavior"),Description("When running on WindowsXP draws control using the Windows XP Themes if theme manager is enabled."),DefaultValue(false)]
        public bool ThemeAware
        {
            get
            {
                return m_WindowsXPAware;
            }
            set
            {
                if(m_WindowsXPAware!=value)
                {
                    m_WindowsXPAware=value;
                    if(!m_WindowsXPAware)
                        m_DefaultStyle=false;
                    else if (m_WindowsXPAware && BarFunctions.ThemedOS)
                    {
                        m_DefaultStyle = true;
                        #if FRAMEWORK20
                        this.FlatStyle = FlatStyle.Standard;
                        #endif
                    }
                }
            }
        }

        /// <summary>
        /// Disables internal drawing support for the List-box portion of Combo-box. Default value is false which means that internal drawing code is used. If
        /// you plan to provide your own drawing for combo box items you must set this property to True.
        /// </summary>
        [Browsable(true),Category("Behavior"),Description("Disables internal drawing support for the List-box portion of Combo-box."), DefaultValue(false)]
        public bool DisableInternalDrawing
        {
            get
            {
                return m_DisableInternalDrawing;
            }
            set
            {
                if(m_DisableInternalDrawing!=value)
                    m_DisableInternalDrawing=value;
            }
        }

        /// <summary>
        /// Gets or sets whether combo box generates the audible alert when Enter key is pressed.
        /// </summary>
        [System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Behavior"),System.ComponentModel.Description("Indicates whether combo box generates the audible alert when Enter key is pressed."),System.ComponentModel.DefaultValue(false)]
        public bool PreventEnterBeep
        {
            get
            {
                return m_PreventEnterBeep;
            }
            set
            {
                m_PreventEnterBeep=value;
            }
        }

        /// <summary>
        /// The ImageList control used by Combo box to draw images.
        /// </summary>
        [Browsable(true),Category("Behavior"),Description("The ImageList control used by Combo box to draw images."), DefaultValue(null)]
        public System.Windows.Forms.ImageList Images
        {
            get
            {
                return m_ImageList;
            }
            set
            {
                m_ImageList=value;
            }
        }

        /// <summary>
        /// Determines the visual style applied to the combo box when shown. Default style is Office 2007.
        /// </summary>
        [Browsable(true),Category("Appearance"), DefaultValue(eDotNetBarStyle.Office2007) ,Description("Determines the display of the item when shown.")]
        public eDotNetBarStyle Style
        {
            get
            {
                return m_Style;
            }
            set
            {
                m_Style=value;
                UpdateBackColor();
                this.Invalidate(true);
            }
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            base.OnHandleCreated(e);
            UpdateBackColor();
            SetupTextBoxMessageHandler();
            RemoveTheme(this.Handle);
        }

        /*protected override void OnHandleDestroyed(EventArgs e)
        {
            if(m_Timer!=null)
                m_Timer.Enabled=false;
            base.OnHandleDestroyed(e);
        }*/

        protected override void OnResize(EventArgs e)
        {
            ResizeMarkup();
            this.Invalidate();
            base.OnResize(e);
        }
        
        private void MouseOverTimerTick(object sender, EventArgs e)
        {
            bool over = false;
            
            if (this.IsHandleCreated && this.Visible)
            {
                WinApi.RECT rw = new WinApi.RECT();
                WinApi.GetWindowRect(this.Handle, ref rw);
                Rectangle r = rw.ToRectangle();
                if (r.Contains(Control.MousePosition))
                    over = true;
                Point p=this.PointToClient(Control.MousePosition);
                if (m_ThumbRect.Contains(p))
                    MouseOverThumb = true;
                else
                    MouseOverThumb = false;
            }

            if (!over)
            {
                SetMouseOverTimerEnabled(false);
                m_MouseOver = false;
                UpdateBackColor();
                this.Invalidate();
                if (this.ParentItem != null) this.ParentItem.HideToolTip();
            }
        }
        internal BaseItem ParentItem = null;

        private bool MouseOverThumb
        {
            get { return m_MouseOverThumb; }
            set
            {
                if (m_MouseOverThumb != value)
                {
                    m_MouseOverThumb = value;
                    this.Invalidate();
                }
            }
        }

        protected override void OnGotFocus(EventArgs e)
        {
            base.OnGotFocus(e);
            if (!m_MouseOver)
                m_MouseOver = true;
            UpdateBackColor();
            this.Invalidate(true);
        }

        protected override void OnLostFocus(EventArgs e)
        {
            //if(!this.ClientRectangle.Contains(this.PointToClient(Control.MousePosition)))
                //m_MouseOver=false;
            SetMouseOverTimerEnabled(true);
            //Color c = GetComboColors().Background;
            //if (this.BackColor != c)
                //this.BackColor = c;
            //if(!m_MouseOver)
            //    this.Refresh();
            m_LastFocusWindow=IntPtr.Zero;
            base.OnLostFocus(e);
        }

        private Timer m_DropDownTrackTimer = null;
        private void StartDropDownTrackTimer()
        {
            if (m_DropDownTrackTimer == null)
            {
                m_DropDownTrackTimer = new Timer();
                m_DropDownTrackTimer.Tick += new EventHandler(DropDownTrackTimerTick);
                m_DropDownTrackTimer.Interval = 200;
            }
            m_DropDownTrackTimer.Start();
        }
        private void StopDropDownTrackTimer()
        {
            Timer t = m_DropDownTrackTimer;
            m_DropDownTrackTimer = null;
            if (t != null)
            {
                t.Stop();
                t.Dispose();
            }
        }

        private void DropDownTrackTimerTick(object sender, EventArgs e)
        {
            DroppedDownInternal = (WinApi.SendMessage(this.Handle, (int)WinApi.WindowsMessages.CB_GETDROPPEDSTATE, IntPtr.Zero, IntPtr.Zero) != 0);
        }

        private bool DroppedDownInternal
        {
            get
            {
                return m_DroppedDown;
            }
            set
            {
                if (m_DroppedDown != value)
                {
                    StopDropDownTrackTimer();
                    m_DroppedDown = value;
                    this.Invalidate();

                    if (DropDownChange != null)
                        DropDownChange(this, m_DroppedDown);
                    #if !FRAMEWORK20
                    if(m_DroppedDown)
                    {
                        StartDropDownTrackTimer();
                    }
                    #endif
                }
            }
        }

#if FRAMEWORK20
        protected override void OnDropDownClosed(EventArgs e)
        {
            DroppedDownInternal = false;
            m_SelectedIndexInternal = this.SelectedIndex;
            base.OnDropDownClosed(e);
        }
#endif

        protected override void OnDropDown(EventArgs e)
        {
            base.OnDropDown(e);
            if(DropDownChange!=null)
                this.DropDownChange(this,true);
            DroppedDownInternal=true;
        }

        [DllImport("user32", CharSet = CharSet.Unicode)]
        private static extern int SetWindowTheme(IntPtr hWnd, [MarshalAs(UnmanagedType.LPWStr)] String pszSubAppName, [MarshalAs(UnmanagedType.LPWStr)] String pszSubIdList);

        private void RemoveTheme(IntPtr handle)
        {
            bool isXp = false;
            if (System.Environment.Version.Major > 5)
                isXp = true;
            else if ((System.Environment.Version.Major == 5) &&
               (System.Environment.Version.Minor >= 1))
                isXp = true;
            if (isXp)
                SetWindowTheme(handle, " ", " ");
        }

        #region Internal Combo Colors
        private class InternalComboColors
        {
            public Color Background = SystemColors.Window;
            public Color Border = SystemColors.Window;
            public LinearGradientColorTable ThumbBackground = null;
            public Color ThumbText = SystemColors.ControlText;
            public LinearGradientColorTable ThumbBorderOuter = null;
            public LinearGradientColorTable ThumbBorderInner = null;
        }

        private InternalComboColors GetComboColors()
        {
            InternalComboColors c = new InternalComboColors();
            
            bool bFocus = (m_MouseOverThumb || this.Focused || this.DroppedDownInternal && this.DropDownStyle != ComboBoxStyle.Simple);
            if (bFocus && !this.Enabled)
                bFocus = false;

            if (BarFunctions.IsOffice2007Style(this.Style) && GlobalManager.Renderer is Office2007Renderer)
            {
                Office2007ComboBoxColorTable colorTable = ((Office2007Renderer)GlobalManager.Renderer).ColorTable.ComboBox;
                Office2007ComboBoxStateColorTable stateColors = (IsToolbarStyle && !m_MouseOver ? colorTable.Default : colorTable.DefaultStandalone);
                if (bFocus)
                {
                    if (this.DroppedDown)
                        stateColors = colorTable.DroppedDown;
                    else if(bFocus)
                        stateColors = colorTable.MouseOver;
                }

                c.Background = stateColors.Background;
                c.Border = stateColors.Border;
                c.ThumbBackground = stateColors.ExpandBackground;
                c.ThumbText = stateColors.ExpandText;
                c.ThumbBorderOuter = stateColors.ExpandBorderOuter;
                c.ThumbBorderInner = stateColors.ExpandBorderInner;
            }
            else
            {
                ColorScheme cs = new ColorScheme(this.Style);
                if (bFocus)
                {
                    if (DroppedDownInternal)
                    {
                        c.ThumbBackground = new LinearGradientColorTable(cs.ItemPressedBackground, cs.ItemPressedBackground2, cs.ItemPressedBackgroundGradientAngle);
                        c.Border = cs.ItemPressedBorder;
                        c.ThumbText = cs.ItemPressedText;
                    }
                    else
                    {
                        if (m_MouseOverThumb)
                            c.ThumbBackground = new LinearGradientColorTable(cs.ItemHotBackground, cs.ItemHotBackground2, cs.ItemHotBackgroundGradientAngle);
                        else
                            c.ThumbBackground = new LinearGradientColorTable(cs.BarBackground, cs.BarBackground2, cs.BarBackgroundGradientAngle);
                        c.Border = cs.ItemHotBorder;
                        c.ThumbText = cs.ItemHotText;
                    }
                }
                else
                {
                    c.ThumbBackground = new LinearGradientColorTable(cs.BarBackground, cs.BarBackground2, cs.BarBackgroundGradientAngle);
                    if (m_MouseOver || !IsToolbarStyle)
                    {
                        c.Border = cs.ItemHotBorder;
                    }
                }
            }

            if (_FocusHighlightEnabled && this.Enabled && this.Focused)
                c.Background = _FocusHighlightColor;
            else if (!this.Enabled)
            {
                c.Background = _DisabledBackColor.IsEmpty ? SystemColors.Control : _DisabledBackColor;
                c.ThumbText = _DisabledForeColor.IsEmpty ? SystemColors.ControlDark : _DisabledForeColor; ;
            }

            return c;
        }
        #endregion

        protected override void WndProc(ref Message m)
        {
            const int WM_PAINT = 0xF;
            const int WM_PRINTCLIENT = 0x0318;
            const int WM_CTLCOLORLISTBOX = 0x0134;
            const int CB_ADDSTRING = 0x143;
            const int CB_INSERTSTRING = 0x14A;
            const int CB_DELETESTRING = 0x0144;

            WinApi.RECT rect = new WinApi.RECT();

            if (m.Msg == WM_CTLCOLORLISTBOX)
            {
                m_DropDownHandle = m.LParam;
                if (m_DropDownHeight > 0)
                {
                    WinApi.GetWindowRect(m.LParam, ref rect);
                    NativeFunctions.SetWindowPos(m.LParam, 0, rect.Left, rect.Top, rect.Right - rect.Left, m_DropDownHeight, NativeFunctions.SWP_NOACTIVATE | NativeFunctions.SWP_NOMOVE);
                }
            }
            else if (m.Msg == (int)WinApi.WindowsMessages.CB_GETDROPPEDSTATE)
            {
                base.WndProc(ref m);
                if (m.Result == IntPtr.Zero)
                {
                    if (DroppedDownInternal)
                    {
                        DroppedDownInternal = false;
                    }
                }
                return;
            }
            else if (m.Msg == NativeFunctions.WM_SETFOCUS)
            {
                if (m.WParam != this.Handle)
                    m_LastFocusWindow = m.WParam;
            }
            else if (m.Msg == CB_ADDSTRING)
            {
                if (this.Items.Count > 0)
                {
                    ComboItem cb = this.Items[this.Items.Count - 1] as ComboItem;
                    if (cb != null)
                        cb.m_ComboBox = this;
                }
            }
            else if (m.Msg == CB_INSERTSTRING)
            {
                int index = m.WParam.ToInt32();
                if (index >= 0 && index < this.Items.Count)
                {
                    ComboItem cb = this.Items[index] as ComboItem;
                    if (cb != null)
                        cb.m_ComboBox = this;
                }
                m_SelectedIndexInternal = -1;
            }
            else if (m.Msg == CB_DELETESTRING)
            {
                m_SelectedIndexInternal = -1;
            }
            else if (m.Msg == NativeFunctions.WM_USER + 7)
            {
                if (this.DropDownStyle == ComboBoxStyle.DropDown && !m_Focused) this.SelectionLength = 0;
                this.Invalidate(true);
                return;
            }
            
            if (m_DefaultStyle)
            {
                base.WndProc(ref m);
                return;
            }

            if ((m.Msg == WM_PAINT || m.Msg == WM_PRINTCLIENT) && this.DrawMode != DrawMode.Normal)
            {
                WinApi.GetWindowRect(m.HWnd, ref rect);
                System.Drawing.Size controlSize = new Size(rect.Width, rect.Height);

                WinApi.PAINTSTRUCT ps = new WinApi.PAINTSTRUCT();
                IntPtr hdc = WinApi.BeginPaint(m.HWnd, ref ps);
                try
                {
                    Graphics g = Graphics.FromHdc(hdc);
                    try
                    {
                        PaintComboBox(g, controlSize);
                    }
                    finally
                    {
                        g.Dispose();
                    }
                }
                finally
                {
                    WinApi.EndPaint(m.HWnd, ref ps);
                }

                if (this.Parent is ItemControl)
                    ((ItemControl)this.Parent).UpdateKeyTipsCanvas();
            }
            else
                base.WndProc(ref m);
        }

        private void PaintComboBox(Graphics targetGraphics, System.Drawing.Size controlSize)
        {
            InternalComboColors colors = GetComboColors();
            Rectangle r = new Rectangle(Point.Empty, controlSize);

            BufferedBitmap bmp = new BufferedBitmap(targetGraphics, new Rectangle(0, 0, this.Width, this.Height));
            try
            {
                Graphics g = bmp.Graphics;

                PaintComboBackground(g, r, colors);
                PaintComboBorder(g, r, colors);
                Rectangle contentRect = PaintComboThumb(g, r, colors);
                int selectedIndex = this.SelectedIndex == -1 ? -1 : m_SelectedIndexInternal;
                if (m_SelectedIndexInternal == -1 && this.SelectedIndex >= 0) selectedIndex = this.SelectedIndex;
                if (DropDownStyle == ComboBoxStyle.DropDownList && selectedIndex >= 0 && this.Items.Count > 0 && selectedIndex < this.Items.Count)
                {
                    DrawItemState state = DrawItemState.ComboBoxEdit;
                    if (Focused)
                        state |= (DrawItemState.Focus | DrawItemState.Selected);

                    if (!Enabled) state = DrawItemState.Disabled | DrawItemState.ComboBoxEdit;
                    contentRect.Inflate(-1, -1);
                    this.OnDrawItem(new DrawItemEventArgs(g, this.Font, contentRect,
                        selectedIndex, state, this.ForeColor, this.BackColor));
                }
                if (this.ShouldDrawWatermark() && this.DropDownStyle == ComboBoxStyle.DropDownList)
                    DrawWatermark(g);

                bmp.Render(targetGraphics);
            }
            finally
            {
                bmp.Dispose();
            }
        }

        private Rectangle PaintComboThumb(Graphics g, Rectangle r, InternalComboColors colors)
        {
            Rectangle contentRect = r;
            contentRect.Inflate(-2, -2);

            if (this.DropDownStyle == ComboBoxStyle.Simple) return contentRect;
            
            int thumbWidth = SystemInformation.HorizontalScrollBarThumbWidth;
            Rectangle thumbRect = new Rectangle(r.Width - thumbWidth, r.Y, thumbWidth, r.Height);
            if (RightToLeft == RightToLeft.Yes)
                thumbRect = new Rectangle(r.X + 1, r.Y + 1, thumbWidth, r.Height - 2);
            if (!this.IsToolbarStyle)
            {
                thumbRect.Y += 2;
                thumbRect.Height -= 4;
                thumbRect.Width -= 2; ;
                if (RightToLeft == RightToLeft.Yes)
                    thumbRect.X += 2;
            }
            else if (!BarFunctions.IsOffice2007Style(this.Style))
                thumbRect.Inflate(-1, -1);

            if (RightToLeft == RightToLeft.Yes)
            {
                int diff = thumbRect.Right - contentRect.X + 2;
                contentRect.Width -= diff;
                contentRect.X += diff;
            }
            else
            {
                int diff = contentRect.Right - thumbRect.X + 2;
                contentRect.Width -= diff;
            }
            //contentRect.Y++;
            //contentRect.Height--;

            if (!this.IsToolbarStyle && BarFunctions.IsOffice2007Style(this.Style))
            {
                Office2007ButtonItemPainter.PaintBackground(g, GetOffice2007StateColorTable(), thumbRect, RoundRectangleShapeDescriptor.RectangleShape);
            }
            else
            {
                if (colors.ThumbBackground != null)
                    DisplayHelp.FillRectangle(g, thumbRect, colors.ThumbBackground);
                if (colors.ThumbBorderOuter != null)
                    DisplayHelp.DrawGradientRectangle(g, thumbRect, colors.ThumbBorderOuter, 1);
                Rectangle innerBorder = thumbRect;
                innerBorder.Inflate(-1, -1);
                if (colors.ThumbBorderInner != null)
                    DisplayHelp.DrawGradientRectangle(g, innerBorder, colors.ThumbBorderInner, 1);
            }

            using(SolidBrush brush=new SolidBrush(colors.ThumbText))
                DrawArrow(thumbRect, g, brush);

            m_ThumbRect = thumbRect;
            return contentRect;
        }

        [Browsable(false)]
        public bool IsToolbarStyle
        {
            get { return !m_IsStandalone; }
        }

        protected Office2007ButtonItemStateColorTable GetOffice2007StateColorTable()
        {
            bool bFocus = (m_MouseOverThumb || this.DroppedDownInternal && this.DropDownStyle != ComboBoxStyle.Simple);

            if (GlobalManager.Renderer is Office2007Renderer)
            {
                Office2007ColorTable ct = ((Office2007Renderer)GlobalManager.Renderer).ColorTable;
                Office2007ButtonItemColorTable buttonColorTable = ct.ButtonItemColors[Enum.GetName(typeof(eButtonColor), eButtonColor.OrangeWithBackground)];
                if (!this.Enabled)
                    return buttonColorTable.Disabled;
                else if (this.DroppedDownInternal)
                    return buttonColorTable.Checked;
                else if (bFocus)
                    return buttonColorTable.MouseOver;
                else
                    return buttonColorTable.Default;
            }

            return null;
        }

        private void PaintComboBorder(Graphics g, Rectangle controlBounds, InternalComboColors colors)
        {
            DisplayHelp.DrawRectangle(g, colors.Border, controlBounds);
        }

        private void PaintComboBackground(Graphics g, Rectangle controlBounds, InternalComboColors colors)
        {
            DisplayHelp.FillRectangle(g, controlBounds, colors.Background);
        }

        private bool ShouldDrawWatermark()
        {
            if (_WatermarkEnabled && this.Enabled && (!this.Focused || _WatermarkBehavior== eWatermarkBehavior.HideNonEmpty) && this.Text == "" && this.SelectedIndex == -1)
                return true;
            return false;
        }

        private void DrawWatermark(Graphics g)
        {
            if (m_TextMarkup != null)
            {
                MarkupDrawContext dc = GetMarkupDrawContext(g);
                m_TextMarkup.Render(dc);
            }
            else
            {
                eTextFormat tf = eTextFormat.Left | eTextFormat.VerticalCenter;

                if (this.RightToLeft == RightToLeft.Yes) tf |= eTextFormat.RightToLeft;
                //if (this.TextAlign == HorizontalAlignment.Left)
                //    tf |= eTextFormat.Left;
                //else if (this.TextAlign == HorizontalAlignment.Right)
                //    tf |= eTextFormat.Right;
                //else if (this.TextAlign == HorizontalAlignment.Center)
                //    tf |= eTextFormat.HorizontalCenter;
                tf |= eTextFormat.EndEllipsis;
                tf |= eTextFormat.WordBreak;
                TextDrawing.DrawString(g, m_WatermarkText, (m_WatermarkFont == null ? this.Font : m_WatermarkFont),
                    m_WatermarkColor, GetWatermarkBounds(), tf);
            }
        }

        private Rectangle GetWatermarkBounds()
        {
            if (this.DropDownStyle != ComboBoxStyle.DropDownList && m_TextWindowMsgHandler!=null)
            {
                WinApi.RECT rect = new WinApi.RECT();
                WinApi.GetWindowRect(m_TextWindowMsgHandler.Handle, ref rect);
                return new Rectangle(0, 0, rect.Width, rect.Height);
            }

            Rectangle r = new Rectangle(2, 0, this.Width - 2, this.Height);
            r.Inflate(-2, -1);
            int thumbSize = SystemInformation.HorizontalScrollBarThumbWidth;
            r.Width -= thumbSize;
            if (this.RightToLeft == RightToLeft.Yes)
                r.X += thumbSize;

            return r;
        }

        //private void CreateListBoxMsgHandler(IntPtr m_DropDownHandle)
        //{
        //    DisposeListBoxMsgHandler();
        //    m_ListBoxMsgHandler = new ComboListBoxMsgHandler();
        //    m_ListBoxMsgHandler.AssignHandle(m_DropDownHandle);
        //}

        //private void DisposeListBoxMsgHandler()
        //{
        //    if (m_ListBoxMsgHandler != null)
        //    {
        //        m_ListBoxMsgHandler.ReleaseHandle();
        //        m_ListBoxMsgHandler = null;
        //    }
        //}

        private void DrawArrow(Rectangle r, Graphics g, Brush b)
        {
            Point[] p=new Point[3];
            p[0].X=r.Left+(r.Width-4)/2;
            p[0].Y=r.Top+(r.Height-3)/2 + 1;
            p[1].X=p[0].X+5;
            p[1].Y=p[0].Y;
            p[2].X=p[0].X+2;
            p[2].Y=p[0].Y+3;
            g.FillPolygon(b,p);
        }

        /*private void OnTimer(object sender, EventArgs e)
        {
            bool bRefresh=false;

            if(m_DroppedDown && !this.DroppedDown)
            {
                m_DroppedDown=false;
                
                if(DropDownChange!=null)
                    this.DropDownChange(this,false);

                m_DropDownHandle=IntPtr.Zero;
                bRefresh=true;
            }

            Point mousePos=this.PointToClient(Control.MousePosition);
            if(!this.ClientRectangle.Contains(mousePos))
            {
                if(m_MouseOver && !m_DroppedDown)
                {
                    m_MouseOver=false;
                    bRefresh=true;
                }
            }
            else if(!m_MouseOver)
            {
                m_MouseOver=true;
                bRefresh=true;
            }

            if(bRefresh)
                this.Refresh();
        }*/

        protected override void OnVisibleChanged(EventArgs e)
        {
            base.OnVisibleChanged(e);
            m_MouseOver=false;
            if (this.DropDownStyle == ComboBoxStyle.DropDown && this.Items.Count > 0 && this.Items[0] is ComboItem && this.DisplayMember!="")
            {
                string s = this.DisplayMember;
                this.DisplayMember = "";
                this.DisplayMember = s;
            }
            if (this.IsHandleCreated && !this.IsDisposed)
            {
                UpdateBackColor();
            }
        }

        private int m_SelectedIndexInternal = -1;

        protected override void OnSelectedIndexChanged(EventArgs e)
        {
            m_SelectedIndexInternal = this.SelectedIndex;
            
            if(!this.DroppedDownInternal)
            {
                if(DroppedDownInternal)
                {
                    DroppedDownInternal=false;
                }
                if(!m_MouseOver)
                    this.Invalidate(true);
            }
            if (this.SelectedIndex == -1 && _WatermarkBehavior == eWatermarkBehavior.HideNonEmpty && m_WatermarkText.Length > 0 && this.Text == "")
                this.Invalidate(true);
            else if (this.DropDownStyle == ComboBoxStyle.DropDownList)
                this.Invalidate();
            
            base.OnSelectedIndexChanged(e);

            ExecuteCommand();
        }

        protected override void OnTextChanged(EventArgs e)
        {
            if (this.SelectedIndex == -1 && _WatermarkBehavior == eWatermarkBehavior.HideNonEmpty && m_WatermarkText.Length > 0 && this.Text == "")
                this.Invalidate(true);
            base.OnTextChanged(e);
        }

        /*protected override void OnEnabledChanged(EventArgs e)
        {
            base.OnEnabledChanged(e);
            SyncTimerEnabled();
        }*/

        /*private void SyncTimerEnabled()
        {
            if(this.Visible)
            {
                if(!m_Timer.Enabled && this.Enabled && !this.DesignMode)
                    m_Timer.Enabled=true;
            }
            else
            {
                if(m_Timer.Enabled)
                    m_Timer.Enabled=false;
            }
        }*/

        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose( bool disposing )
        {
            /*if(m_Timer!=null)
            {
                if(m_Timer.Enabled)
                    m_Timer.Enabled=false;
                m_Timer.Dispose();
                m_Timer=null;
            }*/
            if (m_MouseOverTimer != null)
            {
                m_MouseOverTimer.Enabled = false;
                m_MouseOverTimer.Dispose();
                m_MouseOverTimer = null;
            }
            m_DisableInternalDrawing=true;
            if(m_TextWindowMsgHandler!=null)
            {
                m_TextWindowMsgHandler.ReleaseHandle();
                m_TextWindowMsgHandler=null;
            }
            base.Dispose( disposing );
        }

        protected override void OnFontChanged(EventArgs e)
        {
            base.OnFontChanged(e);
            if(this.Disposing || this.IsDisposed)
                return;
            if(!m_DisableInternalDrawing && this.DrawMode==DrawMode.OwnerDrawFixed)
            {
                if(this.IsHandleCreated && this.Parent!=null && !this.Parent.IsDisposed)
                    this.ItemHeight=this.FontHeight + 1;
            }
        }

        internal int GetFontHeight()
        {
            return this.FontHeight;
        }

        protected override void OnMeasureItem(MeasureItemEventArgs e)
        {
            base.OnMeasureItem(e);
            if(!m_DisableInternalDrawing)
            {
                if(this.DrawMode==DrawMode.OwnerDrawFixed)
                {
                    e.ItemHeight = this.ItemHeight - 2;
                }
                else
                {
                    object o=this.Items[e.Index];
                    if(o is ComboItem)
                    {
                        if(((ComboItem)o).IsFontItem)
                            MeasureFontItem(e);
                        else
                        {
                            Size sz=GetComboItemSize(o as ComboItem);
                            e.ItemHeight=sz.Height;
                            e.ItemWidth=sz.Width;
                            if (BarFunctions.IsOffice2007Style(m_Style))
                            {
                                e.ItemHeight += 6;
                                e.ItemWidth += 6;
                            }
                        }
                    }
                }
            }
        }

        protected override void OnDrawItem(DrawItemEventArgs e)
        {
            base.OnDrawItem(e);
            InternalDrawItem(e);
        }

        private void InternalDrawItem(DrawItemEventArgs e)
        {
            if(!m_DisableInternalDrawing && e.Index>=0)
            {
                object o=this.Items[e.Index];
                if(o is ComboItem)
                    DrawComboItem(e);
                else
                    DrawObjectItem(e);
            }
        }

        protected virtual Size GetComboItemSize(ComboItem item)
        {
            Size size=Size.Empty;
            if(BarFunctions.IsHandleValid(this))
            {
                Graphics g=this.CreateGraphics();
                try
                {
                    size=GetComboItemSize(item, g);
                }
                finally
                {
                    g.Dispose();
                }
            }
            return size;
        }

        protected virtual void DrawObjectItem(DrawItemEventArgs e)
        {
            Graphics g=e.Graphics;
            string text=GetItemText(this.Items[e.Index]);
            Color textColor = Color.Empty;
            Office2007ButtonItemStateColorTable ct = null;
            
            if (BarFunctions.IsOffice2007Style(m_Style))
            {
                Office2007ButtonItemColorTable bct = ((Office2007Renderer)GlobalManager.Renderer).ColorTable.ButtonItemColors[0];
                if ((e.State & DrawItemState.Selected) != 0 || (e.State & DrawItemState.HotLight) != 0)
                    ct = bct.MouseOver;
                else if ((e.State & DrawItemState.Disabled) != 0 || !this.Enabled)
                    ct = bct.Disabled;
                else
                    ct = bct.Default;

                //if (ct != null)
                //    textColor = ct.Text;
                if ((e.State & DrawItemState.Disabled) != 0 || !this.Enabled)
                    textColor = _DisabledForeColor.IsEmpty ? SystemColors.ControlDark : _DisabledForeColor;
                else
                    textColor = this.ForeColor;

                if ((e.State & DrawItemState.HotLight) != 0 || (e.State & DrawItemState.Selected) != 0)
                {
                    Rectangle r = e.Bounds;
                    r.Width--;
                    r.Height--;
                    Office2007ButtonItemPainter.PaintBackground(g, ct, r, RoundRectangleShapeDescriptor.RoundCorner2);
                }
                else
                    e.DrawBackground();
            }
            else
            {
                e.DrawBackground();

                if ((e.State & DrawItemState.HotLight) != 0 || (e.State & DrawItemState.Selected) != 0)
                {
                    g.FillRectangle(SystemBrushes.Highlight, e.Bounds);
                    textColor = SystemColors.HighlightText;
                }
                else if ((e.State & DrawItemState.Disabled) != 0 || (e.State & DrawItemState.Grayed) != 0)
                    textColor = _DisabledForeColor.IsEmpty ? SystemColors.ControlDark : _DisabledForeColor;
                else
                    textColor = SystemColors.ControlText;
            }

            if((e.State & DrawItemState.Focus)!=0)
                DrawFocusRectangle(e);
            Rectangle rText = e.Bounds;
            
            if ((e.State & DrawItemState.ComboBoxEdit) == DrawItemState.ComboBoxEdit)
            {
                //rText.Inflate(-1, 0);
                
            }
            else if (BarFunctions.IsOffice2007Style(m_Style))
                rText.Inflate(-3, 0);
            else
                rText.Inflate(-2, 0);

            TextDrawing.DrawString(g,text,this.Font,textColor,rText,eTextFormat.Default | eTextFormat.NoClipping | eTextFormat.NoPrefix);
        }

        private void DrawFocusRectangle(DrawItemEventArgs e)
        {
            if (_FocusCuesEnabled && ((e.State & DrawItemState.Focus) == DrawItemState.Focus) && ((e.State & DrawItemState.NoFocusRect) != DrawItemState.NoFocusRect))
            {
                Rectangle r = e.Bounds;
                //r.Width--;
                //r.Height--;
                ControlPaint.DrawFocusRectangle(e.Graphics, r, e.ForeColor, e.BackColor);
            }
        }

        private Color _DisabledForeColor = Color.Empty;
        /// <summary>
        /// Gets or sets the text color for the text in combo-box when control Enabled property is set to false.
        /// Setting this property is effective only for DropDownList ComboBox style.
        /// </summary>
        [Category("Appearance"), Description("Indicates text color for the text in combo-box when control Enabled property is set to false. Setting this property is effective only for DropDownList ComboBox style.")]
        public Color DisabledForeColor
        {
            get { return _DisabledForeColor; }
            set 
            { 
                _DisabledForeColor = value;
                if (!this.Enabled)
                    this.Invalidate();
            }
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ShouldSerializeDisabledForeColor()
        {
            return !_DisabledForeColor.IsEmpty;
        }
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public void ResetDisabledForeColor()
        {
            DisabledForeColor = Color.Empty;
        }

        private Color _DisabledBackColor = Color.Empty;
        /// <summary>
        /// Gets or sets the control background color when control is disabled. Default value is an empty color which indicates that system background color is used when control is disabled.
        /// </summary>
        [Description("Indicates control background color when control is disabled"), Category("Appearance")]
        public Color DisabledBackColor
        {
            get { return _DisabledBackColor; }
            set
            {
                if (_DisabledBackColor != value)
                {
                    _DisabledBackColor = value;
                    if (!this.Enabled) this.Invalidate();
                }
            }
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeDisabledBackColor()
        {
            return !_DisabledBackColor.IsEmpty;
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetDisabledBackColor()
        {
            DisabledBackColor = Color.Empty;
        }

        protected virtual void DrawComboItem(DrawItemEventArgs e)
        {
            ComboItem item=this.Items[e.Index] as ComboItem;
            if(item.IsFontItem)
            {
                this.DrawFontItem(e);
                return;
            }

            Graphics g=e.Graphics;
            Image img=null;
            Color clr;
            Color textColor = item.ForeColor;
            if (textColor.IsEmpty || (e.State & DrawItemState.Selected) != 0 || (e.State & DrawItemState.HotLight) != 0)
                textColor = this.ForeColor;

            if (item.ImageIndex >= 0 && m_ImageList != null && m_ImageList.Images.Count > item.ImageIndex)
                img = m_ImageList.Images[item.ImageIndex];
            else if (item.Image != null)
                img = item.Image;

            Office2007ButtonItemStateColorTable ct = null;
            if (BarFunctions.IsOffice2007Style(m_Style))
            {
                Office2007ButtonItemColorTable bct = ((Office2007Renderer)GlobalManager.Renderer).ColorTable.ButtonItemColors[0];
                if ((e.State & DrawItemState.Selected) != 0 || (e.State & DrawItemState.HotLight) != 0)
                    ct = bct.MouseOver;
                else if ((e.State & DrawItemState.Disabled) != 0 || !this.Enabled)
                    ct = bct.Disabled;
                else
                    ct = bct.Default;
                //if (ct == null)
                if (!this.Enabled)
                    textColor = _DisabledForeColor.IsEmpty ? SystemColors.ControlDark : _DisabledForeColor;
                //else
                //    textColor = SystemColors.ControlText;
                //else
                  //  textColor = ct.Text;
            }

            int contWidth=this.DropDownWidth;
            if(item.ImagePosition!=HorizontalAlignment.Center && img!=null)
            {
                contWidth-=img.Width;
                if(contWidth<=0)
                    contWidth=this.DropDownWidth;
            }

            // Back Color
            if((e.State & DrawItemState.Selected)!=0 || (e.State & DrawItemState.HotLight)!=0)
            {
                if (BarFunctions.IsOffice2007Style(m_Style))
                    Office2007ButtonItemPainter.PaintBackground(g, ct, e.Bounds, RoundRectangleShapeDescriptor.RoundCorner2);
                else
                    e.DrawBackground();
                DrawFocusRectangle(e);
            }
            else
            {
                clr=item.BackColor;
                if(item.BackColor.IsEmpty)
                    clr=e.BackColor;
                g.FillRectangle(new SolidBrush(clr),e.Bounds);
            }

            // Draw Image
            Rectangle rImg=e.Bounds;
            Rectangle rText=e.Bounds;
            //if (e.State != DrawItemState.ComboBoxEdit)
            {
                if ((e.State & DrawItemState.ComboBoxEdit) == DrawItemState.ComboBoxEdit)
                {
                    if (img != null)
                    {
                        rText.X += 3;
                        rText.Width -= 3;
                    }
                    //rText.Inflate(-1, 0);
                    //rText.Y++;
                    //rText.Height--;
                }
                else if (BarFunctions.IsOffice2007Style(m_Style))
                    rText.Inflate(-3, 0);
                else
                    rText.Inflate(-2, 0);
            }
            if(img!=null)
            {
                rImg.Width=img.Width;
                rImg.Height=img.Height;
                if(item.ImagePosition==HorizontalAlignment.Left)
                {
                    // Left
                    if(e.Bounds.Height>img.Height)
                        rImg.Y+=(e.Bounds.Height-img.Height)/2;
                    rText.Width-=rImg.Width;
                    rText.X+=rImg.Width;
                }
                else if(item.ImagePosition==HorizontalAlignment.Right)
                {
                    // Right
                    if(e.Bounds.Height>img.Height)
                        rImg.Y+=(e.Bounds.Height-img.Height)/2;
                    rImg.X=e.Bounds.Right-img.Width;
                    rText.Width-=rImg.Width;
                }
                else
                {
                    // Center
                    rImg.X+=(e.Bounds.Width-img.Width)/2;
                    rText.Y=rImg.Bottom;
                }
                g.DrawImage(img,rImg);
            }
            
            // Draw Text
            if(item.Text!="")
            {
                System.Drawing.Font f=e.Font;
                bool bDisposeFont=false;
                try
                {
                    if(item.FontName!="")
                    {
                        f=new Font(item.FontName,item.FontSize,item.FontStyle);
                        bDisposeFont=true;
                    }
                    else if(item.FontStyle!=f.Style)
                    {
                        f = new Font(f, item.FontStyle);
                        bDisposeFont=true;
                    }
                }
                catch
                {
                    f=e.Font;
                    if(f==null)
                    {
                        f=System.Windows.Forms.SystemInformation.MenuFont.Clone() as Font;
                        bDisposeFont=true;
                    }
                }

                eTextFormat format = eTextFormat.Default | eTextFormat.NoClipping | eTextFormat.NoPrefix;
                if (item.TextFormat.Alignment == StringAlignment.Center)
                    format = eTextFormat.HorizontalCenter;
                else if (item.TextFormat.Alignment == StringAlignment.Far)
                    format = eTextFormat.Right;
                if (item.TextLineAlignment == StringAlignment.Center)
                    format |= eTextFormat.VerticalCenter;
                else if (item.TextLineAlignment == StringAlignment.Far)
                    format |= eTextFormat.Bottom;
                TextDrawing.DrawString(g, item.Text, f, textColor, rText, format);
                
                if(bDisposeFont)
                    f.Dispose();
            }
            
        }

        protected virtual Size GetComboItemSize(ComboItem item, Graphics g)
        {
            if(this.DrawMode==DrawMode.OwnerDrawFixed)
                return new Size(this.DropDownWidth,this.ItemHeight);

            Size sz=Size.Empty;
            Size textSize=Size.Empty;
            Image img=null;
            if(item.ImageIndex>=0)
                img=m_ImageList.Images[item.ImageIndex];
            else if(item.Image!=null)
                img=item.Image;
            
            int contWidth=this.DropDownWidth;
            if(item.ImagePosition!=HorizontalAlignment.Center && img!=null)
            {
                contWidth-=img.Width;
                if(contWidth<=0)
                    contWidth=this.DropDownWidth;
            }
            
            Font font=this.Font;
            if(item.FontName!="")
            {
                try
                {
                    font=new Font(item.FontName,item.FontSize,item.FontStyle);
                }
                catch
                {
                    font=this.Font;
                }
            }

            eTextFormat format = eTextFormat.Default;
            if (item.TextFormat.Alignment == StringAlignment.Center)
                format = eTextFormat.HorizontalCenter;
            else if (item.TextFormat.Alignment == StringAlignment.Far)
                format = eTextFormat.Right;
            if (item.TextLineAlignment == StringAlignment.Center)
                format |= eTextFormat.VerticalCenter;
            else if (item.TextLineAlignment == StringAlignment.Far)
                format |= eTextFormat.Bottom;

            textSize=TextDrawing.MeasureString(g,item.Text,font,this.DropDownWidth,format);
            textSize.Width += 2;
            sz.Width=textSize.Width;
            sz.Height=textSize.Height;
            if(sz.Width<this.DropDownWidth)
                sz.Width=this.DropDownWidth;

            if(item.ImagePosition==HorizontalAlignment.Center && img!=null)
                sz.Height+=img.Height;
            else if(img!=null && img.Height>sz.Height)
                sz.Height=img.Height;

            return sz;
        }

        /// <summary>
        /// Loads all fonts available on system into the combo box.
        /// </summary>
        public void LoadFonts()
        {
            this.Items.Clear();

            System.Drawing.Text.InstalledFontCollection colInstalledFonts = new System.Drawing.Text.InstalledFontCollection();
            FontFamily[] aFamilies = colInstalledFonts.Families;
            foreach(FontFamily ff in aFamilies)
            {
                ComboItem item=new ComboItem();
                item.IsFontItem=true;
                item.FontName=ff.GetName(0);
                item.FontSize=this.Font.Size;
                item.Text=ff.GetName(0);
                this.Items.Add(item);
            }
            this.DropDownWidth=this.Width*2;
        }

        private void DrawFontItem(DrawItemEventArgs e)
        {
            FontStyle[] styles=new FontStyle[4]{FontStyle.Regular,FontStyle.Bold,FontStyle.Italic,FontStyle.Bold | FontStyle.Italic};
            if (!BarFunctions.IsOffice2007Style(m_Style))
                e.DrawBackground();
            string fontname = this.Items[e.Index].ToString();
            FontFamily family = new FontFamily(fontname);

            int iWidth = this.DropDownWidth/2-4;
            if(iWidth<=0)
                iWidth=this.Width;
            foreach(FontStyle style in styles)
            {
                if(family.IsStyleAvailable(style))
                {
                    eTextFormat format = eTextFormat.Default | eTextFormat.NoPrefix;
                    Color textColor = (e.State & DrawItemState.Selected) != 0 ? SystemColors.HighlightText : SystemColors.ControlText;

                    Office2007ButtonItemStateColorTable ct = null;
                    if (BarFunctions.IsOffice2007Style(m_Style))
                    {
                        Office2007ButtonItemColorTable bct = ((Office2007Renderer)GlobalManager.Renderer).ColorTable.ButtonItemColors[0];
                        if ((e.State & DrawItemState.Selected) != 0 || (e.State & DrawItemState.HotLight) != 0)
                            ct = bct.MouseOver;
                        else if ((e.State & DrawItemState.Disabled) != 0 || !this.Enabled)
                            ct = bct.Disabled;
                        else
                            ct = bct.Default;
                        //if (ct == null)
                        if (!this.Enabled)
                            textColor = _DisabledForeColor.IsEmpty ? SystemColors.ControlDark : _DisabledForeColor;
                        else
                            textColor = SystemColors.ControlText;

                        if ((e.State & DrawItemState.Selected) != 0 || (e.State & DrawItemState.HotLight) != 0)
                            Office2007ButtonItemPainter.PaintBackground(e.Graphics, ct, e.Bounds, RoundRectangleShapeDescriptor.RoundCorner2);
                        else
                        {
                            e.DrawBackground();
                        }
                    }

                    if ((e.State & DrawItemState.ComboBoxEdit) == DrawItemState.ComboBoxEdit)
                    {
                        Rectangle rt = e.Bounds;
                        //rt.Y += 1;
                        //rt.Height -= 1;
                        TextDrawing.DrawString(e.Graphics, fontname, this.Font, textColor, rt, format);
                    }
                    else
                    {
                        Size szFont = TextDrawing.MeasureString(e.Graphics, fontname, this.Font);
                        int iDiff = (int)((e.Bounds.Height - szFont.Height) / 2);
                        Rectangle rFontName = new Rectangle(e.Bounds.X, e.Bounds.Y + iDiff, 
                            ((e.State & DrawItemState.Disabled)==DrawItemState.Disabled?e.Bounds.Width: Math.Max(e.Bounds.Width - 100, 32)), e.Bounds.Height - iDiff);
                        TextDrawing.DrawString(e.Graphics, fontname, this.Font, textColor, rFontName, format);
                        Rectangle rRemainder = new Rectangle(e.Bounds.X + iWidth + 4, e.Bounds.Y, e.Bounds.Width + 100, e.Bounds.Height);
                        Font f = new Font(family, (float)e.Bounds.Height - 8, style);
                        TextDrawing.DrawString(e.Graphics, fontname, f, textColor, rRemainder, format);
                    }
                    break;
                }
            }
        }

        private void MeasureFontItem(MeasureItemEventArgs e)
        {
            e.ItemHeight = 18;
        }

#if !FRAMEWORK20
        /// <summary>
        /// Specifies the height of the drop-down portion of combo box.
        /// </summary>
        [Browsable(true),Category("Behavior"),Description("The height, in pixels, of drop down box in a combo box."), DefaultValue(0)]
        public int DropDownHeight
        {
            get
            {
                return m_DropDownHeight;
            }
            set
            {
                m_DropDownHeight=value;
            }
        }
#endif

        /// <summary>
        /// Releases the focus from combo box. The control that last had focus will receive focus back when this method is called.
        /// </summary>
        public void ReleaseFocus()
        {
            if(this.Focused && m_LastFocusWindow!=IntPtr.Zero)
            {
                Control ctrl=Control.FromChildHandle(new System.IntPtr(m_LastFocusWindow.ToInt32()));
                if(ctrl!=this)
                {
                    if(ctrl!=null)
                        ctrl.Focus();
                    else
                    {
                        NativeFunctions.SetFocus(m_LastFocusWindow.ToInt32());
                    }
                    this.OnLostFocus(new System.EventArgs());
                }
                m_LastFocusWindow=IntPtr.Zero;
                
            }
        }

        protected override bool ProcessCmdKey(ref Message msg,Keys keyData)
        {
            if(keyData==Keys.Enter && m_PreventEnterBeep)
            {
                this.OnKeyPress(new KeyPressEventArgs((char)13));
                return true;
            }
            return base.ProcessCmdKey(ref msg, keyData);
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            if (!IsStandalone)
            {
                if (e.KeyCode == Keys.Enter)
                    ReleaseFocus();
                else if (e.KeyCode == Keys.Escape)
                {
                    ReleaseFocus();
                }
            }

            base.OnKeyDown(e);
        }

        /// <summary>
        /// Gets the window handle that the drop down list is bound to.
        /// </summary>
        [Browsable(false)]
        public IntPtr DropDownHandle
        {
            get
            {
                return m_DropDownHandle;
            }
        }

        internal bool MouseOver
        {
            get
            {
                return m_MouseOver;
            }
            set
            {
                if(m_MouseOver!=value)
                {
                    m_MouseOver=value;
                    this.Invalidate(true);
                }
            }
        }

        [System.ComponentModel.Editor(typeof(Endv.Editors.ComboItemsEditor), typeof(System.Drawing.Design.UITypeEditor)), Localizable(true)]
        public new ComboBox.ObjectCollection Items
        {
            get
            {
                return base.Items;
            }
        }

        protected override void OnEnabledChanged(EventArgs e)
        {
            UpdateBackColor();
            base.OnEnabledChanged(e);
        }

        private void UpdateBackColor()
        {
            if (!m_UseCustomBackColor)
            {
                Color c = GetComboColors().Background;
                if (this.BackColor != c)
                    this.BackColor = c;
            }
        }

        protected override void OnMouseEnter(EventArgs e)
        {
            if(!m_MouseOver)
            {
                m_MouseOver=true;
                UpdateBackColor();
                this.Invalidate(true);
            }
            SetMouseOverTimerEnabled(true);
            base.OnMouseEnter(e);
        }
        protected override void OnMouseLeave(EventArgs e)
        {
            //if(this.DroppedDown)
            //{
            //    m_MouseOver=false;
            //}
            //else if(this.DropDownStyle!=ComboBoxStyle.DropDownList && m_MouseOver)
            //{
            //    // Get the mouse position
            //    Point p=this.PointToClient(Control.MousePosition);
            //    if(!this.ClientRectangle.Contains(p))
            //    {
            //        m_MouseOver=false;
            //    }
            //}
            //else if(m_MouseOver)
            //{
            //    m_MouseOver=false;
            //}
            SetMouseOverTimerEnabled(true);
            //Color c = GetComboColors().Background;
            //if (this.BackColor != c)
            //    this.BackColor = c;
            //this.Refresh();
            base.OnMouseLeave(e);
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
            if (!m_MouseOver)
            {
                //if (!m_Focused)
                {
                    m_MouseOver = true;
                    this.Invalidate();
                    SetMouseOverTimerEnabled(true);
                }
            }
        }

        private void SetMouseOverTimerEnabled(bool value)
        {
            if (m_MouseOverTimer != null) m_MouseOverTimer.Enabled = value;
        }

        private void SetupTextBoxMessageHandler()
        {
#if FRAMEWORK20
            if (this.DropDownStyle != ComboBoxStyle.DropDownList && this.AutoCompleteMode == AutoCompleteMode.None)
#else
            if (this.DropDownStyle != ComboBoxStyle.DropDownList)
#endif
            {
                if (m_TextWindowMsgHandler == null)
                {
                    // Get hold of the text box
                    IntPtr hwnd = GetWindow(this.Handle, GW_CHILD);
                    // Subclass so we can track messages
                    if (hwnd != IntPtr.Zero)
                    {
                        m_TextWindowMsgHandler = new ComboTextBoxMsgHandler();
                        m_TextWindowMsgHandler.MouseLeave += new EventHandler(this.TextBoxMouseLeave);
                        m_TextWindowMsgHandler.Paint += new PaintEventHandler(TextBoxPaint);
                        m_TextWindowMsgHandler.AssignHandle(hwnd);
                    }
                }
            }
            else if (m_TextWindowMsgHandler != null)
            {
                m_TextWindowMsgHandler.ReleaseHandle();
                m_TextWindowMsgHandler = null;
            }
        }
        
        protected override void OnDropDownStyleChanged(EventArgs e)
        {
            SetupTextBoxMessageHandler();
            base.OnDropDownStyleChanged(e);
        }

        private void TextBoxPaint(object sender, PaintEventArgs e)
        {
            if (ShouldDrawWatermark())
                DrawWatermark(e.Graphics);
        }

        private void TextBoxMouseLeave(object sender, EventArgs e)
        {
            if(!m_MouseOver)
                return;
            SetMouseOverTimerEnabled(true);
        }

        /// <summary>
        /// Gets or sets whether FocusHighlightColor is used as background color to highlight text box when it has input focus. Default value is false.
        /// </summary>
        [DefaultValue(false), Browsable(true), Category("Appearance"), Description("Indicates whether FocusHighlightColor is used as background color to highlight text box when it has input focus.")]
        public virtual bool FocusHighlightEnabled
        {
            get { return _FocusHighlightEnabled; }
            set
            {
                if (_FocusHighlightEnabled != value)
                {
                    _FocusHighlightEnabled = value;
                    if (this.Focused)
                        this.Invalidate();
                }
            }
        }

        /// <summary>
        /// Gets or sets the color used as background color to highlight text box when it has input focus and focus highlight is enabled.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Indicates color used as background color to highlight text box when it has input focus and focus highlight is enabled.")]
        public virtual Color FocusHighlightColor
        {
            get { return _FocusHighlightColor; }
            set
            {
                if (_FocusHighlightColor != value)
                {
                    _FocusHighlightColor = value;
                    if (this.Focused)
                        this.Invalidate();
                }
            }
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeFocusHighlightColor()
        {
            return !_FocusHighlightColor.Equals(_DefaultHighlightColor);
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetFocusHighlightColor()
        {
            FocusHighlightColor = _DefaultHighlightColor;
        }

        #region ICommandSource Members
        protected virtual void ExecuteCommand()
        {
            if (_Command == null) return;
            CommandManager.ExecuteCommand(this);
        }

        /// <summary>
        /// Gets or sets the command assigned to the item. Default value is null.
        /// <remarks>Note that if this property is set to null Enabled property will be set to false automatically to disable the item.</remarks>
        /// </summary>
        [DefaultValue(null), Category("Commands"), Description("Indicates the command assigned to the item.")]
        public Command Command
        {
            get { return (Command)((ICommandSource)this).Command; }
            set
            {
                ((ICommandSource)this).Command = value;
            }
        }

        private ICommand _Command = null;
        //[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        ICommand ICommandSource.Command
        {
            get
            {
                return _Command;
            }
            set
            {
                bool changed = false;
                if (_Command != value)
                    changed = true;

                if (_Command != null)
                    CommandManager.UnRegisterCommandSource(this, _Command);
                _Command = value;
                if (value != null)
                    CommandManager.RegisterCommand(this, value);
                if (changed)
                    OnCommandChanged();
            }
        }

        /// <summary>
        /// Called when Command property value changes.
        /// </summary>
        protected virtual void OnCommandChanged()
        {
        }

        private object _CommandParameter = null;
        /// <summary>
        /// Gets or sets user defined data value that can be passed to the command when it is executed.
        /// </summary>
        [Browsable(true), DefaultValue(null), Category("Commands"), Description("Indicates user defined data value that can be passed to the command when it is executed."), System.ComponentModel.TypeConverter(typeof(System.ComponentModel.StringConverter)), System.ComponentModel.Localizable(true)]
        public object CommandParameter
        {
            get
            {
                return _CommandParameter;
            }
            set
            {
                _CommandParameter = value;
            }
        }

        #endregion
        

        private class ComboTextBoxMsgHandler:NativeWindow
        {
            private const int WM_MOUSELEAVE=0x02A3;
            private const int WM_MOUSEMOVE=0x0200;
            private const int TME_LEAVE=0x02;
            [DllImport("user32",SetLastError=true, CharSet=CharSet.Auto)]
            private static extern bool TrackMouseEvent(ref TRACKMOUSEEVENT lpEventTrack);

            public event EventHandler MouseLeave;
            public event PaintEventHandler Paint;

            private struct TRACKMOUSEEVENT 
            {
                public int cbSize;
                public int dwFlags;
                public int hwndTrack;
                public int dwHoverTime;
            }

            private bool m_MouseTracking=false;

            protected override void WndProc(ref Message m)
            {
                const int WM_PAINT = 0xF;
                if(m.Msg==WM_MOUSEMOVE && !m_MouseTracking)
                {
                    m_MouseTracking = true;
                    TRACKMOUSEEVENT tme = new TRACKMOUSEEVENT();
                    tme.dwFlags = TME_LEAVE;
                    tme.cbSize = Marshal.SizeOf(tme);
                    tme.hwndTrack = this.Handle.ToInt32();
                    tme.dwHoverTime = 0;
                    m_MouseTracking = TrackMouseEvent(ref tme);
                }
                else if(m.Msg==WM_MOUSELEAVE)
                {
                    if(MouseLeave!=null)
                        MouseLeave(this,new EventArgs());
                    m_MouseTracking=false;
                }
                else if (m.Msg == WM_PAINT)
                {
                    base.WndProc(ref m);
                    if (Paint != null)
                    {
                        using (Graphics g = Graphics.FromHwnd(m.HWnd))
                            Paint(this, new PaintEventArgs(g, Rectangle.Empty));
                    }
                    return;
                }
                base.WndProc(ref m);
            }
        }
    }
}