Move ShiftUI source code to ShiftOS

This'll be a lot easier to work on.

1 files changed, 2825 insertions, 0 deletions

diff --git a/source/ShiftUI/Widgets/ComboBox.cs b/source/ShiftUI/Widgets/ComboBox.cs
new file mode 100644
index 0000000..88bcbec
--- /dev/null
+++ b/source/ShiftUI/Widgets/ComboBox.cs
@@ -0,0 +1,2825 @@
+// 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-2006 Novell, Inc.
+//
+// Authors:
+//	Jordi Mas i Hernandez, [email protected]
+//	Mike Kestner  <[email protected]>
+//	Daniel Nauck    (dna(at)mono-project(dot)de)
+
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.ComponentModel.Design.Serialization;
+using System.Drawing;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+
+namespace ShiftUI
+{
+	[DefaultProperty("Items")]
+	[DefaultEvent("SelectedIndexChanged")]
+	//[Designer ("ShiftUI.Design.ComboBoxDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
+	[DefaultBindingProperty ("Text")]
+	[ClassInterface (ClassInterfaceType.AutoDispatch)]
+	[ComVisible(true)]
+    [ToolboxWidget]
+    public class ComboBox : ListWidget
+	{
+		private DrawMode draw_mode = DrawMode.Normal;
+		private ComboBoxStyle dropdown_style;
+		private int dropdown_width = -1;
+		private int selected_index = -1;
+		private ObjectCollection items;
+		private bool suspend_ctrlupdate;
+		private int maxdrop_items = 8;
+		private bool integral_height = true;
+		private bool sorted;
+		private int max_length;
+		private ComboListBox listbox_ctrl;
+		private ComboTextBox textbox_ctrl;
+		private bool process_textchanged_event = true;
+		private bool process_texchanged_autoscroll = true;
+		private bool item_height_specified;
+		private int item_height;
+		private int requested_height = -1;
+		private Hashtable item_heights;
+		private bool show_dropdown_button;
+		private ButtonState button_state = ButtonState.Normal;
+		private bool dropped_down;
+		private Rectangle text_area;
+		private Rectangle button_area;
+		private Rectangle listbox_area;
+		private const int button_width = 16;
+		bool drop_down_button_entered;
+		private AutoCompleteStringCollection auto_complete_custom_source = null;
+		private AutoCompleteMode auto_complete_mode = AutoCompleteMode.None;
+		private AutoCompleteSource auto_complete_source = AutoCompleteSource.None;
+		private FlatStyle flat_style;
+		private int drop_down_height;
+		const int default_drop_down_height = 106;
+
+		[ComVisible(true)]
+		public class ChildAccessibleObject : AccessibleObject {
+
+			public ChildAccessibleObject (ComboBox owner, IntPtr handle)
+				: base (owner)
+			{
+			}
+
+			public override string Name {
+				get {
+					return base.Name;
+				}
+			}
+		}
+
+		public ComboBox ()
+		{
+			items = new ObjectCollection (this);
+			DropDownStyle = ComboBoxStyle.DropDown;
+			item_height = FontHeight + 2;
+			background_color = ThemeEngine.Current.ColorControl;
+			border_style = BorderStyle.None;
+
+			drop_down_height = default_drop_down_height;
+			flat_style = FlatStyle.Standard;
+
+			/* Events */
+			MouseDown += new MouseEventHandler (OnMouseDownCB);
+			MouseUp += new MouseEventHandler (OnMouseUpCB);
+			MouseMove += new MouseEventHandler (OnMouseMoveCB);
+			MouseWheel += new MouseEventHandler (OnMouseWheelCB);
+			MouseEnter += new EventHandler (OnMouseEnter);
+			MouseLeave += new EventHandler (OnMouseLeave);
+			KeyDown +=new KeyEventHandler(OnKeyDownCB);
+		}
+
+		#region events
+		
+		[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 DoubleClick
+		{
+			add { base.DoubleClick += value; }
+			remove { base.DoubleClick -= value; }
+		}
+
+		static object DrawItemEvent = new object ();
+		static object DropDownEvent = new object ();
+		static object DropDownStyleChangedEvent = new object ();
+		static object MeasureItemEvent = new object ();
+		static object SelectedIndexChangedEvent = new object ();
+		static object SelectionChangeCommittedEvent = new object ();
+		static object DropDownClosedEvent = new object ();
+		static object TextUpdateEvent = new object ();
+
+		public event DrawItemEventHandler DrawItem {
+			add { Events.AddHandler (DrawItemEvent, value); }
+			remove { Events.RemoveHandler (DrawItemEvent, value); }
+		}
+
+		public event EventHandler DropDown {
+			add { Events.AddHandler (DropDownEvent, value); }
+			remove { Events.RemoveHandler (DropDownEvent, value); }
+		}
+		public event EventHandler DropDownClosed
+		{
+			add { Events.AddHandler (DropDownClosedEvent, value); }
+			remove { Events.RemoveHandler (DropDownClosedEvent, value); }
+		}
+
+		public event EventHandler DropDownStyleChanged {
+			add { Events.AddHandler (DropDownStyleChangedEvent, value); }
+			remove { Events.RemoveHandler (DropDownStyleChangedEvent, value); }
+		}
+
+		public event MeasureItemEventHandler MeasureItem {
+			add { Events.AddHandler (MeasureItemEvent, value); }
+			remove { Events.RemoveHandler (MeasureItemEvent, 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 SelectedIndexChanged {
+			add { Events.AddHandler (SelectedIndexChangedEvent, value); }
+			remove { Events.RemoveHandler (SelectedIndexChangedEvent, value); }
+		}
+
+		public event EventHandler SelectionChangeCommitted {
+			add { Events.AddHandler (SelectionChangeCommittedEvent, value); }
+			remove { Events.RemoveHandler (SelectionChangeCommittedEvent, value); }
+		}
+		public event EventHandler TextUpdate
+		{
+			add { Events.AddHandler (TextUpdateEvent, value); }
+			remove { Events.RemoveHandler (TextUpdateEvent, value); }
+		}
+
+		#endregion Events
+
+		#region Public Properties
+		[MonoTODO("AutoCompletion algorithm is currently not implemented.")]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
+		[Browsable (true)]
+		//[EditorBrowsable (EditorBrowsableState.Always)]
+		[Localizable (true)]
+		//[Editor ("ShiftUI.Design.ListWidgetStringCollectionEditor, " + Consts.AssemblySystem_Design,
+			 //"System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
+		public AutoCompleteStringCollection AutoCompleteCustomSource { 
+			get {
+				if(auto_complete_custom_source == null) {
+					auto_complete_custom_source = new AutoCompleteStringCollection ();
+					auto_complete_custom_source.CollectionChanged += new CollectionChangeEventHandler (OnAutoCompleteCustomSourceChanged);
+				}
+				return auto_complete_custom_source;
+			}
+			set {
+				if(auto_complete_custom_source == value)
+					return;
+
+				if(auto_complete_custom_source != null) //remove eventhandler from old collection
+					auto_complete_custom_source.CollectionChanged -= new CollectionChangeEventHandler (OnAutoCompleteCustomSourceChanged);
+
+				auto_complete_custom_source = value;
+
+				if(auto_complete_custom_source != null)
+					auto_complete_custom_source.CollectionChanged += new CollectionChangeEventHandler (OnAutoCompleteCustomSourceChanged);
+
+				SetTextBoxAutoCompleteData ();
+			}
+		}
+
+		[MonoTODO("AutoCompletion algorithm is currently not implemented.")]
+		[Browsable (true)]
+		//[EditorBrowsable (EditorBrowsableState.Always)]
+		[DefaultValue (AutoCompleteMode.None)]
+		public AutoCompleteMode AutoCompleteMode {
+			get { return auto_complete_mode; }
+			set {
+				if(auto_complete_mode == value)
+					return;
+
+				if((value < AutoCompleteMode.None) || (value > AutoCompleteMode.SuggestAppend))
+					throw new InvalidEnumArgumentException (String.Format("Enum argument value '{0}' is not valid for AutoCompleteMode", value));
+
+				auto_complete_mode = value;
+				SetTextBoxAutoCompleteData ();
+			}
+		}
+
+		[MonoTODO("AutoCompletion algorithm is currently not implemented.")]
+		[Browsable (true)]
+		//[EditorBrowsable (EditorBrowsableState.Always)]
+		[DefaultValue (AutoCompleteSource.None)]
+		public AutoCompleteSource AutoCompleteSource {
+			get { return auto_complete_source; }
+			set {
+				if(auto_complete_source == value)
+					return;
+
+				if(!Enum.IsDefined (typeof (AutoCompleteSource), value))
+					throw new InvalidEnumArgumentException (String.Format ("Enum argument value '{0}' is not valid for AutoCompleteSource", value));
+
+				auto_complete_source = value;
+				SetTextBoxAutoCompleteData ();
+			}
+		}
+
+		void SetTextBoxAutoCompleteData ()
+		{
+			if (textbox_ctrl == null)
+				return;
+
+			textbox_ctrl.AutoCompleteMode = auto_complete_mode;
+
+			if (auto_complete_source == AutoCompleteSource.ListItems) {
+				textbox_ctrl.AutoCompleteSource = AutoCompleteSource.CustomSource;
+				textbox_ctrl.AutoCompleteCustomSource = null;
+				textbox_ctrl.AutoCompleteInternalSource = this;
+			} else {
+				textbox_ctrl.AutoCompleteSource = auto_complete_source;
+				textbox_ctrl.AutoCompleteCustomSource = auto_complete_custom_source;
+				textbox_ctrl.AutoCompleteInternalSource = null;
+			}
+		}
+		public override Color BackColor {
+			get { return base.BackColor; }
+			set {
+				if (base.BackColor == value)
+					return;
+				base.BackColor = value;
+				Refresh ();
+			}
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public override Image BackgroundImage {
+			get { return base.BackgroundImage; }
+			set {
+				if (base.BackgroundImage == value)
+					return;
+ 				base.BackgroundImage = value;
+				Refresh ();
+			}
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public override ImageLayout BackgroundImageLayout {
+			get { return base.BackgroundImageLayout; }
+			set { base.BackgroundImageLayout = value; }
+		}
+
+		protected override CreateParams CreateParams {
+			get { return base.CreateParams;}
+		}
+
+		[DefaultValue ((string)null)]
+		[AttributeProvider (typeof (IListSource))]
+		[RefreshProperties (RefreshProperties.Repaint)]
+		[MWFCategory("Data")]
+		public new object DataSource {
+			get { return base.DataSource; }
+			set { base.DataSource = value; }
+		}
+
+		protected override Size DefaultSize {
+			get { return new Size (121, 21); }
+		}
+
+		[RefreshProperties(RefreshProperties.Repaint)]
+		[DefaultValue (DrawMode.Normal)]
+		[MWFCategory("Behavior")]
+		public DrawMode DrawMode {
+			get { return draw_mode; }
+			set {
+				if (!Enum.IsDefined (typeof (DrawMode), value))
+					throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for DrawMode", value));
+
+				if (draw_mode == value)
+					return;
+
+				if (draw_mode == DrawMode.OwnerDrawVariable)
+					item_heights = null;
+				draw_mode = value;
+				if (draw_mode == DrawMode.OwnerDrawVariable)
+					item_heights = new Hashtable ();
+				Refresh ();
+			}
+		}
+
+		[Browsable (true)]
+		[DefaultValue (106)]
+		//[EditorBrowsable (EditorBrowsableState.Always)]
+		[MWFCategory("Behavior")]
+		public int DropDownHeight {
+			get {
+				return drop_down_height;
+			}
+			set {
+				if (value < 1)
+					throw new ArgumentOutOfRangeException ("DropDownHeight", "DropDownHeight must be greater than 0.");
+					
+				if (value == drop_down_height)
+					return;
+
+				drop_down_height = value;
+				IntegralHeight = false;
+			}
+		}
+
+		[DefaultValue (ComboBoxStyle.DropDown)]
+		[RefreshProperties(RefreshProperties.Repaint)]
+		[MWFCategory("Appearance")]
+		public ComboBoxStyle DropDownStyle {
+			get { return dropdown_style; }
+			set {
+				if (!Enum.IsDefined (typeof (ComboBoxStyle), value))
+					throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for ComboBoxStyle", value));
+
+				if (dropdown_style == value)
+					return;
+
+				SuspendLayout ();
+
+				if (dropdown_style == ComboBoxStyle.Simple) {
+					if (listbox_ctrl != null) {
+						Widgets.RemoveImplicit (listbox_ctrl);
+						listbox_ctrl.Dispose ();
+						listbox_ctrl = null;
+					}
+				}
+
+				dropdown_style = value;
+				
+				if (dropdown_style == ComboBoxStyle.DropDownList && textbox_ctrl != null) {
+					Widgets.RemoveImplicit (textbox_ctrl);
+					textbox_ctrl.Dispose ();
+					textbox_ctrl = null;
+				}
+
+				if (dropdown_style == ComboBoxStyle.Simple) {
+					show_dropdown_button = false;
+					
+					CreateComboListBox ();
+					Widgets.AddImplicit (listbox_ctrl);
+					listbox_ctrl.Visible = true;
+
+					// This should give us a 150 default height
+					// for Simple mode if size hasn't been set
+					// (DefaultSize doesn't work for us in this case)
+					if (requested_height == -1)
+						requested_height = 150;
+				} else {
+					show_dropdown_button = true;
+					button_state = ButtonState.Normal;
+				}
+	
+				if (dropdown_style != ComboBoxStyle.DropDownList && textbox_ctrl == null) {
+					textbox_ctrl = new ComboTextBox (this);
+					object selected_item = SelectedItem;
+					if (selected_item != null)
+						textbox_ctrl.Text = GetItemText (selected_item);
+					textbox_ctrl.BorderStyle = BorderStyle.None;
+					textbox_ctrl.TextChanged += new EventHandler (OnTextChangedEdit);
+					textbox_ctrl.KeyPress += new KeyPressEventHandler (OnTextKeyPress);
+					textbox_ctrl.Click += new EventHandler (OnTextBoxClick);
+					textbox_ctrl.TopMargin = 1; // since we don't have borders, adjust manually the top
+
+					if (IsHandleCreated == true)
+						Widgets.AddImplicit (textbox_ctrl);
+					SetTextBoxAutoCompleteData ();
+				}
+				
+				ResumeLayout ();
+				OnDropDownStyleChanged (EventArgs.Empty);
+				
+				LayoutComboBox ();
+				UpdateComboBoxBounds ();
+				Refresh ();
+			}
+		}
+
+		[MWFCategory("Behavior")]
+		public int DropDownWidth {
+			get { 
+				if (dropdown_width == -1)
+					return Width;
+					
+				return dropdown_width; 
+			}
+			set {
+				if (dropdown_width == value)
+					return;
+					
+				if (value < 1)
+					throw new ArgumentOutOfRangeException ("DropDownWidth",
+						"The DropDownWidth value is less than one.");
+
+				dropdown_width = value;
+			}
+		}
+		
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public bool DroppedDown {
+			get { 
+				if (dropdown_style == ComboBoxStyle.Simple)
+					return true;
+				
+				return dropped_down;
+			}
+			set {
+				if (dropdown_style == ComboBoxStyle.Simple || dropped_down == value)
+					return;
+					
+				if (value) 
+					DropDownListBox ();
+				else
+					listbox_ctrl.HideWindow ();
+			}
+		}
+
+		[DefaultValue (FlatStyle.Standard)]
+		[Localizable (true)]
+		[MWFCategory("Appearance")]
+		public FlatStyle FlatStyle {
+			get { return flat_style; }
+			set {
+				if (!Enum.IsDefined (typeof (FlatStyle), value))
+					throw new InvalidEnumArgumentException ("FlatStyle", (int) value, typeof (FlatStyle));
+				
+				flat_style = value;
+				LayoutComboBox ();
+				Invalidate ();
+			}
+		}
+
+		public override bool Focused {
+			get { return base.Focused; }
+		}
+
+		public override Color ForeColor {
+			get { return base.ForeColor; }
+			set {
+				if (base.ForeColor == value)
+					return;
+				base.ForeColor = value;
+				Refresh ();
+			}
+		}
+
+		[DefaultValue (true)]
+		[Localizable (true)]
+		[MWFCategory("Behavior")]
+		public bool IntegralHeight {
+			get { return integral_height; }
+			set {
+				if (integral_height == value)
+					return;
+				integral_height = value;
+				UpdateComboBoxBounds ();
+				Refresh ();
+			}
+		}
+
+		[Localizable (true)]
+		[MWFCategory("Behavior")]
+		public int ItemHeight {
+			get {
+				if (item_height == -1) {
+					SizeF sz = TextRenderer.MeasureString ("The quick brown Fox", Font);
+					item_height = (int) sz.Height;
+				}
+				return item_height;
+			}
+			set {
+				if (value < 1)
+					throw new ArgumentOutOfRangeException ("ItemHeight",
+						"The item height value is less than one.");
+
+				item_height_specified = true;
+				item_height = value;
+				if (IntegralHeight)
+					UpdateComboBoxBounds ();
+				LayoutComboBox ();
+				Refresh ();
+			}
+		}
+
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
+		[Localizable (true)]
+		//[Editor ("ShiftUI.Design.ListWidgetStringCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
+		[MergableProperty (false)]
+		[MWFCategory("Data")]
+		public ComboBox.ObjectCollection Items {
+			get { return items; }
+		}
+
+		[DefaultValue (8)]
+		[Localizable (true)]
+		[MWFCategory("Behavior")]
+		public int MaxDropDownItems {
+			get { return maxdrop_items; }
+			set {
+				if (maxdrop_items == value)
+					return;
+				maxdrop_items = value;
+			}
+		}
+
+		public override Size MaximumSize {
+			get { return base.MaximumSize; }
+			set {
+				base.MaximumSize = new Size (value.Width, 0);
+			}
+		}
+
+		[DefaultValue (0)]
+		[Localizable (true)]
+		[MWFCategory("Behavior")]
+		public int MaxLength {
+			get { return max_length; }
+			set {
+				if (max_length == value)
+					return;
+
+				max_length = value;
+				
+				if (dropdown_style != ComboBoxStyle.DropDownList) {
+					if (value < 0) {
+						value = 0;
+					}
+					textbox_ctrl.MaxLength = value;
+				}
+			}
+		}
+
+		public override Size MinimumSize {
+			get { return base.MinimumSize; }
+			set {
+				base.MinimumSize = new Size (value.Width, 0);
+			}
+		}
+		
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		[Browsable (false)]
+		public new Padding Padding  {
+			get { return base.Padding; }
+			set { base.Padding = value; }
+		}
+
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		[Browsable (false)]
+		public int PreferredHeight {
+			get { return Font.Height + 8; }
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public override int SelectedIndex {
+			get { return selected_index; }
+			set {
+				SetSelectedIndex (value, false);
+			}
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		[Bindable(true)]
+		public object SelectedItem {
+			get { return selected_index == -1 ? null : Items [selected_index]; }
+			set {
+				object item = selected_index == -1 ? null : Items [selected_index];
+				if (item == value)
+					return;
+
+				if (value == null)
+					SelectedIndex = -1;
+				else
+					SelectedIndex = Items.IndexOf (value);
+			}
+		}
+		
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public string SelectedText {
+			get {
+				if (dropdown_style == ComboBoxStyle.DropDownList)
+					return string.Empty;
+					
+				string retval = textbox_ctrl.SelectedText;
+				
+				return retval;
+			}
+			set {
+				if (dropdown_style == ComboBoxStyle.DropDownList)
+					return;
+				textbox_ctrl.SelectedText = value;
+			}
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public int SelectionLength {
+			get {
+				if (dropdown_style == ComboBoxStyle.DropDownList) 
+					return 0;
+				
+				int result = textbox_ctrl.SelectionLength;
+				return result == -1 ? 0 : result;
+			}
+			set {
+				if (dropdown_style == ComboBoxStyle.DropDownList) 
+					return;
+				if (textbox_ctrl.SelectionLength == value)
+					return;
+				textbox_ctrl.SelectionLength = value;
+			}
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public int SelectionStart {
+			get { 
+				if (dropdown_style == ComboBoxStyle.DropDownList) 
+					return 0;
+				return textbox_ctrl.SelectionStart;
+			}
+			set {
+				if (dropdown_style == ComboBoxStyle.DropDownList) 
+					return;
+				if (textbox_ctrl.SelectionStart == value)
+					return;
+				textbox_ctrl.SelectionStart = value;
+			}
+		}
+
+		[DefaultValue (false)]
+		[MWFCategory("Behavior")]
+		public bool Sorted {
+			get { return sorted; }
+			set {
+				if (sorted == value)
+					return;
+				sorted = value;
+				SelectedIndex = -1;
+				if (sorted) {
+					Items.Sort ();
+					LayoutComboBox ();
+				}
+			}
+		}
+
+		[Bindable (true)]
+		[Localizable (true)]
+		public override string Text {
+			get {
+				if (dropdown_style != ComboBoxStyle.DropDownList) {
+					if (textbox_ctrl != null) {
+						return textbox_ctrl.Text;
+					}
+				}
+				
+				if (SelectedItem != null)
+					return GetItemText (SelectedItem);
+				
+				return base.Text;
+			}
+			set {
+				if (value == null) {
+					if (SelectedIndex == -1) {
+						if (dropdown_style != ComboBoxStyle.DropDownList)
+							SetWidgetText (string.Empty, false);
+					} else {
+						SelectedIndex = -1;
+					}
+					return;
+				}
+
+				// don't set the index if value exactly matches text of selected item
+				if (SelectedItem == null || string.Compare (value, GetItemText (SelectedItem), false, CultureInfo.CurrentCulture) != 0)
+				{
+					// find exact match using case-sensitive comparison, and if does
+					// not result in any match then use case-insensitive comparison
+					int index = FindStringExact (value, -1, false);
+					if (index == -1) {
+						index = FindStringExact (value, -1, true);
+					}
+					if (index != -1) {
+						SelectedIndex = index;
+						return;
+					}
+				}
+
+				// set directly the passed value
+				if (dropdown_style != ComboBoxStyle.DropDownList)
+					textbox_ctrl.Text = value;
+			}
+		}
+
+		#endregion Public Properties
+
+		#region Internal Properties
+		internal Rectangle ButtonArea {
+			get { return button_area; }
+		}
+
+		internal Rectangle TextArea {
+			get { return text_area; }
+		}
+		#endregion
+
+		#region UIA Framework Properties
+
+		internal TextBox UIATextBox {
+			get { return textbox_ctrl; }
+		}
+
+		internal ComboListBox UIAComboListBox {
+			get { return listbox_ctrl; }
+		}
+
+		#endregion UIA Framework Properties
+
+		#region Public Methods
+		[Obsolete ("This method has been deprecated")]
+		protected virtual void AddItemsCore (object[] value)
+		{
+			
+		}
+
+		public void BeginUpdate ()
+		{
+			suspend_ctrlupdate = true;
+		}
+
+		protected override AccessibleObject CreateAccessibilityInstance ()
+		{
+			return base.CreateAccessibilityInstance ();
+		}
+		
+		protected override void CreateHandle ()
+		{
+			base.CreateHandle ();
+		}
+
+		protected override void Dispose (bool disposing)
+		{
+			if (disposing) {
+				if (listbox_ctrl != null) {
+					listbox_ctrl.Dispose ();
+					Widgets.RemoveImplicit (listbox_ctrl);
+					listbox_ctrl = null;
+				}
+			
+				if (textbox_ctrl != null) {
+					Widgets.RemoveImplicit (textbox_ctrl);
+					textbox_ctrl.Dispose ();
+					textbox_ctrl = null;
+				}
+			}
+			
+			base.Dispose (disposing);
+		}
+
+		public void EndUpdate ()
+		{
+			suspend_ctrlupdate = false;
+			UpdatedItems ();
+			Refresh ();
+		}
+
+		public int FindString (string s)
+		{
+			return FindString (s, -1);
+		}
+
+		public int FindString (string s, int startIndex)
+		{
+			if (s == null || Items.Count == 0) 
+				return -1;
+
+			if (startIndex < -1 || startIndex >= Items.Count)
+				throw new ArgumentOutOfRangeException ("startIndex");
+
+			int i = startIndex;
+			if (i == (Items.Count - 1))
+				i = -1;
+			do {
+				i++;
+				if (string.Compare (s, 0, GetItemText (Items [i]), 0, s.Length, true) == 0)
+					return i;
+				if (i == (Items.Count - 1))
+					i = -1;
+			} while (i != startIndex);
+
+			return -1;
+		}
+
+		public int FindStringExact (string s)
+		{
+			return FindStringExact (s, -1);
+		}
+
+		public int FindStringExact (string s, int startIndex)
+		{
+			return FindStringExact (s, startIndex, true);
+		}
+
+		private int FindStringExact (string s, int startIndex, bool ignoreCase)
+		{
+			if (s == null || Items.Count == 0) 
+				return -1;
+
+			if (startIndex < -1 || startIndex >= Items.Count)
+				throw new ArgumentOutOfRangeException ("startIndex");
+
+			int i = startIndex;
+			if (i == (Items.Count - 1))
+				i = -1;
+			do {
+				i++;
+				if (string.Compare (s, GetItemText (Items [i]), ignoreCase, CultureInfo.CurrentCulture) == 0)
+					return i;
+				if (i == (Items.Count - 1))
+					i = -1;
+			} while (i != startIndex);
+
+			return -1;
+		}
+
+		public int GetItemHeight (int index)
+		{
+			if (DrawMode == DrawMode.OwnerDrawVariable && IsHandleCreated) {
+
+				if (index < 0 || index >= Items.Count )
+					throw new ArgumentOutOfRangeException ("The item height value is less than zero");
+				
+				object item = Items [index];
+				if (item_heights.Contains (item))
+					return (int) item_heights [item];
+				
+				MeasureItemEventArgs args = new MeasureItemEventArgs (DeviceContext, index, ItemHeight);
+				OnMeasureItem (args);
+				item_heights [item] = args.ItemHeight;
+				return args.ItemHeight;
+			}
+
+			return ItemHeight;
+		}
+
+		protected override bool IsInputKey (Keys keyData)
+		{
+			switch (keyData & ~Keys.Modifiers) {
+			case Keys.Up:
+			case Keys.Down:
+			case Keys.Left:
+			case Keys.Right:
+			case Keys.PageUp:
+			case Keys.PageDown:
+			case Keys.Home:
+			case Keys.End:
+				return true;
+			
+			default:
+				return false;
+			}
+		}
+
+		protected override void OnBackColorChanged (EventArgs e)
+		{
+			base.OnBackColorChanged (e);
+
+			if (textbox_ctrl != null)
+				textbox_ctrl.BackColor = BackColor;
+		}
+
+		protected override void OnDataSourceChanged (EventArgs e)
+		{
+			base.OnDataSourceChanged (e);
+			BindDataItems ();
+			
+			/** 
+			 ** This 'Debugger.IsAttached' hack is here because of
+			 ** Xamarin Bug #2234, which noted that when changing
+			 ** the DataSource, in Windows exceptions are eaten
+			 ** when SelectedIndexChanged is fired.  However, when
+			 ** the debugger is running (i.e. in MonoDevelop), we
+			 ** want to be alerted of exceptions.
+			 **/
+
+			if (Debugger.IsAttached) {
+				SetSelectedIndex ();
+			} else {
+				try {
+					SetSelectedIndex ();
+				} catch {
+					//ignore exceptions here per 
+					//bug 2234
+				}
+			}
+		}
+
+		private void SetSelectedIndex ()
+		{
+			if (DataSource == null || DataManager == null) {
+				SelectedIndex = -1;
+			} 
+			else {
+				SelectedIndex = DataManager.Position;
+			}
+		}
+
+		protected override void OnDisplayMemberChanged (EventArgs e)
+		{
+			base.OnDisplayMemberChanged (e);
+
+			if (DataManager == null)
+				return;
+
+			SelectedIndex = DataManager.Position;
+
+			if (selected_index != -1 && DropDownStyle != ComboBoxStyle.DropDownList)
+				SetWidgetText (GetItemText (Items [selected_index]), true);
+
+			if (!IsHandleCreated)
+				return;
+
+			Invalidate ();
+		}
+
+		protected virtual void OnDrawItem (DrawItemEventArgs e)
+		{
+			DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		internal void HandleDrawItem (DrawItemEventArgs e)
+		{
+			// Only raise OnDrawItem if we are in an OwnerDraw mode
+			switch (DrawMode) {
+				case DrawMode.OwnerDrawFixed:
+				case DrawMode.OwnerDrawVariable:
+					OnDrawItem (e);
+					break;
+				default:
+					ThemeEngine.Current.DrawComboBoxItem (this, e);
+					break;
+			}
+		}
+
+		protected virtual void OnDropDown (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [DropDownEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnDropDownClosed (EventArgs e)
+		{
+			EventHandler eh = (EventHandler) Events [DropDownClosedEvent];
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnDropDownStyleChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [DropDownStyleChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected override void OnFontChanged (EventArgs e)
+		{
+			base.OnFontChanged (e);
+
+			if (textbox_ctrl != null)
+				textbox_ctrl.Font = Font;
+			
+			if (!item_height_specified)
+				item_height = Font.Height + 2;
+
+			if (IntegralHeight)
+				UpdateComboBoxBounds ();
+
+			LayoutComboBox ();
+		}
+
+		protected override void OnForeColorChanged (EventArgs e)
+		{
+			base.OnForeColorChanged (e);
+			if (textbox_ctrl != null)
+				textbox_ctrl.ForeColor = ForeColor;
+		}
+
+		//[EditorBrowsable(EditorBrowsableState.Advanced)]
+		protected override void OnGotFocus (EventArgs e)
+		{
+			if (dropdown_style == ComboBoxStyle.DropDownList) {
+				// We draw DDL styles manually, so they require a
+				// refresh to have their selection drawn
+				Invalidate ();
+			}
+			
+			if (textbox_ctrl != null) {
+				textbox_ctrl.SetSelectable (false);
+				textbox_ctrl.ShowSelection = Enabled;
+				textbox_ctrl.ActivateCaret (true);
+				textbox_ctrl.SelectAll ();
+			}
+
+			base.OnGotFocus (e);
+		}
+
+		//[EditorBrowsable(EditorBrowsableState.Advanced)]
+		protected override void OnLostFocus (EventArgs e)
+		{
+			if (dropdown_style == ComboBoxStyle.DropDownList) {
+				// We draw DDL styles manually, so they require a
+				// refresh to have their selection drawn
+				Invalidate ();
+			}
+
+			if (listbox_ctrl != null && dropped_down) {
+				listbox_ctrl.HideWindow ();
+			}
+
+			if (textbox_ctrl != null) {
+				textbox_ctrl.SetSelectable (true);
+				textbox_ctrl.ActivateCaret (false);
+				textbox_ctrl.ShowSelection = false;
+				textbox_ctrl.SelectionLength = 0;
+				textbox_ctrl.HideAutoCompleteList ();
+			}
+
+			base.OnLostFocus (e);
+		}
+
+		protected override void OnHandleCreated (EventArgs e)
+		{
+			base.OnHandleCreated (e);
+
+			SetBoundsInternal (Left, Top, Width, PreferredHeight, BoundsSpecified.None);
+
+			if (textbox_ctrl != null)
+				Widgets.AddImplicit (textbox_ctrl);
+
+			LayoutComboBox ();
+			UpdateComboBoxBounds ();
+		}
+
+		protected override void OnHandleDestroyed (EventArgs e)
+		{
+			base.OnHandleDestroyed (e);
+		}
+
+		protected override void OnKeyPress (KeyPressEventArgs e)
+		{
+			if (dropdown_style == ComboBoxStyle.DropDownList) {
+				int index = FindStringCaseInsensitive (e.KeyChar.ToString (), SelectedIndex + 1);
+				if (index != -1) {
+					SelectedIndex = index;
+					if (DroppedDown) { //Scroll into view
+						if (SelectedIndex >= listbox_ctrl.LastVisibleItem ())
+							listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.LastVisibleItem () + 1);
+						// Or, selecting an item earlier in the list.
+						if (SelectedIndex < listbox_ctrl.FirstVisibleItem ())
+							listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.FirstVisibleItem ());
+					}
+				}
+			}
+
+			base.OnKeyPress (e);
+		}
+
+		protected virtual void OnMeasureItem (MeasureItemEventArgs e)
+		{
+			MeasureItemEventHandler eh = (MeasureItemEventHandler)(Events [MeasureItemEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected override void OnParentBackColorChanged (EventArgs e)
+		{
+			base.OnParentBackColorChanged (e);
+		}
+
+		protected override void OnResize (EventArgs e)
+		{
+			LayoutComboBox ();
+			if (listbox_ctrl != null)
+				listbox_ctrl.CalcListBoxArea ();
+		}
+
+		protected override void OnSelectedIndexChanged (EventArgs e)
+		{
+			base.OnSelectedIndexChanged (e);
+
+			EventHandler eh = (EventHandler)(Events [SelectedIndexChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnSelectedItemChanged (EventArgs e)
+		{
+		}
+
+		protected override void OnSelectedValueChanged (EventArgs e)
+		{
+			base.OnSelectedValueChanged (e);
+		}
+
+		protected virtual void OnSelectionChangeCommitted (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [SelectionChangeCommittedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected override void RefreshItem (int index)
+		{
+			if (index < 0 || index >= Items.Count)
+				throw new ArgumentOutOfRangeException ("index");
+				
+			if (draw_mode == DrawMode.OwnerDrawVariable)
+				item_heights.Remove (Items [index]);
+		}
+
+		protected override void RefreshItems ()
+		{
+			for (int i = 0; i < Items.Count; i++) {
+				RefreshItem (i);
+			}
+
+			LayoutComboBox ();
+			Refresh ();
+
+			if (selected_index != -1 && DropDownStyle != ComboBoxStyle.DropDownList)
+				SetWidgetText (GetItemText (Items [selected_index]), false);
+		}
+
+		public override void ResetText ()
+		{
+			Text = String.Empty;
+		}
+		
+		protected override bool ProcessKeyEventArgs (ref Message m)
+		{
+			return base.ProcessKeyEventArgs (ref m);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected override void OnKeyDown (KeyEventArgs e)
+		{
+			base.OnKeyDown (e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected override void OnValidating (CancelEventArgs e)
+		{
+			base.OnValidating (e);
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected override void OnTextChanged (EventArgs e)
+		{
+			base.OnTextChanged (e);
+		}
+
+		protected virtual void OnTextUpdate (EventArgs e)
+		{
+			EventHandler eh = (EventHandler) Events [TextUpdateEvent];
+			if (eh != null)
+				eh (this, e);
+		}
+		protected override void OnMouseLeave (EventArgs e)
+		{
+			if (flat_style == FlatStyle.Popup)
+				Invalidate ();
+			base.OnMouseLeave (e);
+		}
+		
+		protected override void OnMouseEnter (EventArgs e)
+		{
+			if (flat_style == FlatStyle.Popup)
+				Invalidate ();
+			base.OnMouseEnter (e);
+		}
+
+		protected override void ScaleWidget (SizeF factor, BoundsSpecified specified)
+		{
+			base.ScaleWidget (factor, specified);
+		}
+
+		public void Select (int start, int length)
+		{
+			if (start < 0)
+				throw new ArgumentException ("Start cannot be less than zero");
+				
+			if (length < 0)
+				throw new ArgumentException ("length cannot be less than zero");
+				
+			if (dropdown_style == ComboBoxStyle.DropDownList)
+				return;
+
+			textbox_ctrl.Select (start, length);
+		}
+
+		public void SelectAll ()
+		{
+			if (dropdown_style == ComboBoxStyle.DropDownList)
+				return;
+
+			if (textbox_ctrl != null) {
+				textbox_ctrl.ShowSelection = true;
+				textbox_ctrl.SelectAll ();
+			}
+		}
+
+		protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
+		{
+			bool vertically_anchored = (Anchor & AnchorStyles.Top) != 0 && (Anchor & AnchorStyles.Bottom) != 0;
+			bool vertically_docked = Dock == DockStyle.Left || Dock == DockStyle.Right || Dock == DockStyle.Fill;
+
+			if ((specified & BoundsSpecified.Height) != 0 ||
+				(specified == BoundsSpecified.None && (vertically_anchored || vertically_docked))) {
+
+				requested_height = height;
+				height = SnapHeight (height);
+			}
+
+			base.SetBoundsCore (x, y, width, height, specified);
+		}
+
+		protected override void SetItemCore (int index, object value)
+		{
+			if (index < 0 || index >= Items.Count)
+				return;
+
+			Items[index] = value;
+		}
+
+		protected override void SetItemsCore (IList value)
+		{
+			BeginUpdate ();
+			try {
+				Items.Clear ();
+				Items.AddRange (value);
+			} finally {
+				EndUpdate ();
+			}
+		}
+
+		public override string ToString ()
+		{
+			return base.ToString () + ", Items.Count:" + Items.Count;
+		}
+
+		protected override void WndProc (ref Message m)
+		{
+			switch ((Msg) m.Msg) {
+			case Msg.WM_KEYUP:
+			case Msg.WM_KEYDOWN:
+				Keys keys = (Keys) m.WParam.ToInt32 ();
+				// Don't pass the message to base if auto complete is being used and available.
+				if (textbox_ctrl != null && textbox_ctrl.CanNavigateAutoCompleteList) {
+					XplatUI.SendMessage (textbox_ctrl.Handle, (Msg) m.Msg, m.WParam, m.LParam);
+					return;
+				}
+				if (keys == Keys.Up || keys == Keys.Down)
+					break;
+				goto case Msg.WM_CHAR;
+			case Msg.WM_CHAR:
+				// Call our own handler first and send the message to the TextBox if still needed
+				if (!ProcessKeyMessage (ref m) && textbox_ctrl != null)
+					XplatUI.SendMessage (textbox_ctrl.Handle, (Msg) m.Msg, m.WParam, m.LParam);
+				return;
+			case Msg.WM_MOUSELEAVE:
+				Point location = PointToClient (Widget.MousePosition);
+				if (ClientRectangle.Contains (location))
+					return;
+				break;
+			default:
+				break;
+			}
+			base.WndProc (ref m);
+		}
+
+		#endregion Public Methods
+
+		#region Private Methods
+		void OnAutoCompleteCustomSourceChanged(object sender, CollectionChangeEventArgs e) {
+			if(auto_complete_source == AutoCompleteSource.CustomSource) {
+				//FIXME: handle add, remove and refresh events in AutoComplete algorithm.
+			}
+		}
+
+		internal override bool InternalCapture {
+			get { return Capture; }
+			set {}
+		}
+		
+		void LayoutComboBox ()
+		{
+			int border = ThemeEngine.Current.Border3DSize.Width;
+
+			text_area = ClientRectangle;
+			text_area.Height = PreferredHeight;
+			
+			listbox_area = ClientRectangle;
+			listbox_area.Y = text_area.Bottom + 3;
+			listbox_area.Height -= (text_area.Height + 2);
+
+			Rectangle prev_button_area = button_area;
+
+			if (DropDownStyle == ComboBoxStyle.Simple)
+				button_area = Rectangle.Empty;
+			else {
+				button_area = text_area;
+				button_area.X = text_area.Right - button_width - border;
+				button_area.Y = text_area.Y + border;
+				button_area.Width = button_width;
+				button_area.Height = text_area.Height - 2 * border;
+				if (flat_style == FlatStyle.Popup || flat_style == FlatStyle.Flat) {
+					button_area.Inflate (1, 1);
+					button_area.X += 2;
+					button_area.Width -= 2;
+				}
+			}
+
+			if (button_area != prev_button_area) {
+				prev_button_area.Y -= border;
+				prev_button_area.Width += border;
+				prev_button_area.Height += 2 * border;
+				Invalidate (prev_button_area);
+				Invalidate (button_area);
+			}
+
+			if (textbox_ctrl != null) {
+				int text_border = border + 1;
+				textbox_ctrl.Location = new Point (text_area.X + text_border, text_area.Y + text_border);
+				textbox_ctrl.Width = text_area.Width - button_area.Width - text_border * 2;
+				textbox_ctrl.Height = text_area.Height - text_border * 2;
+			}
+
+			if (listbox_ctrl != null && dropdown_style == ComboBoxStyle.Simple) {
+				listbox_ctrl.Location = listbox_area.Location;
+				listbox_ctrl.CalcListBoxArea ();
+			}
+		}
+
+		private void CreateComboListBox ()
+		{
+			listbox_ctrl = new ComboListBox (this);
+			listbox_ctrl.HighlightedIndex = SelectedIndex;
+		}
+		
+		internal void Draw (Rectangle clip, Graphics dc)
+		{
+			Theme theme = ThemeEngine.Current;
+			FlatStyle style = FlatStyle.Standard;
+			bool is_flat = false;
+
+			style = this.FlatStyle;
+			is_flat = style == FlatStyle.Flat || style == FlatStyle.Popup;
+
+			theme.ComboBoxDrawBackground (this, dc, clip, style);
+
+			int border = theme.Border3DSize.Width;
+
+			// No edit Widget, we paint the edit ourselves
+			if (dropdown_style == ComboBoxStyle.DropDownList) {
+				DrawItemState state = DrawItemState.None;
+				Color back_color = BackColor;
+				Color fore_color = ForeColor;
+				Rectangle item_rect = text_area;
+				item_rect.X += border;
+				item_rect.Y += border;
+				item_rect.Width -= (button_area.Width + 2 * border);
+				item_rect.Height -= 2 * border;
+				
+				if (Focused) {
+					state = DrawItemState.Selected;
+					state |= DrawItemState.Focus;
+					back_color = SystemColors.Highlight;
+					fore_color = SystemColors.HighlightText;
+				}
+				
+				state |= DrawItemState.ComboBoxEdit;
+				HandleDrawItem (new DrawItemEventArgs (dc, Font, item_rect, SelectedIndex, state, fore_color, back_color));
+			}
+			
+			if (show_dropdown_button) {
+				ButtonState current_state;
+				if (is_enabled)
+					current_state = button_state;
+				else
+					current_state = ButtonState.Inactive;
+
+				if (is_flat || theme.ComboBoxNormalDropDownButtonHasTransparentBackground (this, current_state))
+					dc.FillRectangle (theme.ResPool.GetSolidBrush (theme.ColorControl), button_area);
+
+				if (is_flat) {
+					theme.DrawFlatStyleComboButton (dc, button_area, current_state);
+				} else {
+					theme.ComboBoxDrawNormalDropDownButton (this, dc, clip, button_area, current_state); 
+				}
+			}
+		}
+
+		internal bool DropDownButtonEntered {
+			get { return drop_down_button_entered; }
+			private set {
+				if (drop_down_button_entered == value)
+					return;
+				drop_down_button_entered = value;
+				if (ThemeEngine.Current.ComboBoxDropDownButtonHasHotElementStyle (this))
+					Invalidate (button_area);
+			}
+		}
+
+		internal void DropDownListBox ()
+		{
+			DropDownButtonEntered = false;
+
+			if (DropDownStyle == ComboBoxStyle.Simple)
+				return;
+			
+			if (listbox_ctrl == null)
+				CreateComboListBox ();
+
+			listbox_ctrl.Location = PointToScreen (new Point (text_area.X, text_area.Y + text_area.Height));
+
+			FindMatchOrSetIndex(SelectedIndex);
+
+			if (textbox_ctrl != null)
+				textbox_ctrl.HideAutoCompleteList ();
+
+			if (listbox_ctrl.ShowWindow ())
+				dropped_down = true;
+
+			button_state = ButtonState.Pushed;
+			if (dropdown_style == ComboBoxStyle.DropDownList)
+				Invalidate (text_area);
+		}
+		
+		internal void DropDownListBoxFinished ()
+		{
+			if (DropDownStyle == ComboBoxStyle.Simple)
+				return;
+				
+			FindMatchOrSetIndex (SelectedIndex);
+			button_state = ButtonState.Normal;
+			Invalidate (button_area);
+			dropped_down = false;
+			OnDropDownClosed (EventArgs.Empty);
+			/*
+			 * Apples X11 looses override-redirect when doing a Unmap/Map on a previously mapped window
+			 * this causes the popup to appear under the main form.  This is horrible but necessary
+			 */
+			 
+			 // If the user opens a new form in an event, it will close our dropdown,
+			 // so we need a null check here
+			 if (listbox_ctrl != null) {
+				listbox_ctrl.Dispose ();
+				listbox_ctrl = null;
+			}
+			 // The auto complete list could have been shown after the listbox,
+			 // so make sure it's hidden.
+			 if (textbox_ctrl != null)
+				 textbox_ctrl.HideAutoCompleteList ();
+		}
+		
+		private int FindStringCaseInsensitive (string search)
+		{
+			if (search.Length == 0) {
+				return -1;
+			}
+			
+			for (int i = 0; i < Items.Count; i++) 
+			{
+				if (String.Compare (GetItemText (Items[i]), 0, search, 0, search.Length, true) == 0)
+					return i;
+			}
+
+			return -1;
+		}
+
+		// Search in the list for the substring, starting the search at the list 
+		// position specified, the search wraps thus covering all the list.
+		internal int FindStringCaseInsensitive (string search, int start_index)
+		{
+			if (search.Length == 0) {
+				return -1;
+			}
+			// Accept from first item to after last item. i.e. all cases of (SelectedIndex+1).
+			if (start_index < 0 || start_index > Items.Count)
+				throw new ArgumentOutOfRangeException("start_index");
+
+			for (int i = 0; i < Items.Count; i++) {
+				int index = (i + start_index) % Items.Count;
+				if (String.Compare (GetItemText (Items [index]), 0, search, 0, search.Length, true) == 0)
+					return index;
+			}
+
+			return -1;
+		}
+
+		internal override bool IsInputCharInternal (char charCode)
+		{
+			return true;
+		}
+
+		internal void RestoreContextMenu ()
+		{
+			textbox_ctrl.RestoreContextMenu ();
+		}
+
+		private void OnKeyDownCB(object sender, KeyEventArgs e)
+		{
+			if (Items.Count == 0)
+				return;
+
+			// for keyboard navigation, we have to do our own scroll, since
+			// the default behaviour for the SelectedIndex property is a little different,
+			// setting the selected index in the top always
+
+			int offset;
+			switch (e.KeyCode) 
+			{
+				case Keys.Up:
+					FindMatchOrSetIndex(Math.Max(SelectedIndex - 1, 0));
+
+					if (DroppedDown)
+						if (SelectedIndex < listbox_ctrl.FirstVisibleItem ())
+							listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.FirstVisibleItem ());
+					break;
+	
+				case Keys.Down:
+					if ((e.Modifiers & Keys.Alt) == Keys.Alt)
+						DropDownListBox ();
+					else
+						FindMatchOrSetIndex(Math.Min(SelectedIndex + 1, Items.Count - 1));
+						
+					if (DroppedDown)
+						if (SelectedIndex >= listbox_ctrl.LastVisibleItem ())
+							listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.LastVisibleItem () + 1);
+					break;
+				
+				case Keys.PageUp:
+					offset = listbox_ctrl == null ? MaxDropDownItems - 1 : listbox_ctrl.page_size - 1;
+					if (offset < 1)
+						offset = 1;
+
+					SetSelectedIndex (Math.Max (SelectedIndex - offset, 0), true);
+
+					if (DroppedDown)
+						if (SelectedIndex < listbox_ctrl.FirstVisibleItem ())
+							listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.FirstVisibleItem ());
+					break;
+	
+				case Keys.PageDown:
+					if (SelectedIndex == -1) {
+						SelectedIndex = 0;
+						if (dropdown_style != ComboBoxStyle.Simple)
+							return;
+					}
+
+					offset = listbox_ctrl == null ? MaxDropDownItems - 1 : listbox_ctrl.page_size - 1;
+					if (offset < 1)
+						offset = 1;
+
+					SetSelectedIndex (Math.Min (SelectedIndex + offset, Items.Count - 1), true);
+
+					if (DroppedDown)
+						if (SelectedIndex >= listbox_ctrl.LastVisibleItem ())
+							listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.LastVisibleItem () + 1);
+					break;
+				
+				case Keys.Enter:	
+				case Keys.Escape:
+					if (listbox_ctrl != null && listbox_ctrl.Visible)
+						DropDownListBoxFinished ();
+					break;
+					
+				case Keys.Home:
+					if (dropdown_style == ComboBoxStyle.DropDownList) {
+						SelectedIndex = 0;
+
+						if (DroppedDown)
+							if (SelectedIndex < listbox_ctrl.FirstVisibleItem ())
+								listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.FirstVisibleItem ());
+					}
+					
+					break;
+				case Keys.End:
+					if (dropdown_style == ComboBoxStyle.DropDownList) {
+						SetSelectedIndex (Items.Count - 1, true);
+
+						if (DroppedDown)
+							if (SelectedIndex >= listbox_ctrl.LastVisibleItem ())
+								listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.LastVisibleItem () + 1);
+					}
+					
+					break;
+				default:
+					break;
+			}
+		}
+
+		void SetSelectedIndex (int value, bool supressAutoScroll)
+		{
+			if (selected_index == value)
+				return;
+
+			if (value <= -2 || value >= Items.Count)
+				throw new ArgumentOutOfRangeException ("SelectedIndex");
+
+			selected_index = value;
+
+			if (dropdown_style != ComboBoxStyle.DropDownList) {
+				if (value == -1)
+					SetWidgetText (string.Empty, false, supressAutoScroll);
+				else
+					SetWidgetText (GetItemText (Items [value]), false, supressAutoScroll);
+			}
+
+			if (DropDownStyle == ComboBoxStyle.DropDownList)
+				Invalidate ();
+
+			if (listbox_ctrl != null)
+				listbox_ctrl.HighlightedIndex = value;
+
+			OnSelectedValueChanged (EventArgs.Empty);
+			OnSelectedIndexChanged (EventArgs.Empty);
+			OnSelectedItemChanged (EventArgs.Empty);
+		}
+
+		// If no item is currently selected, and an item is found matching the text 
+		// in the textbox, then selected that item.  Otherwise the item at the given 
+		// index is selected.
+		private void FindMatchOrSetIndex(int index)
+		{
+			int match = -1;
+			if (SelectedIndex == -1 && Text.Length != 0)
+				match = FindStringCaseInsensitive(Text);
+			if (match != -1)
+				SetSelectedIndex (match, true);
+			else
+				SetSelectedIndex (index, true);
+		}
+		
+		void OnMouseDownCB (object sender, MouseEventArgs e)
+		{
+			Rectangle area;
+			if (DropDownStyle == ComboBoxStyle.DropDownList)
+				area = ClientRectangle;
+			else
+				area = button_area;
+
+			if (area.Contains (e.X, e.Y)) {
+				if (Items.Count > 0)
+					DropDownListBox ();
+				else {
+					button_state = ButtonState.Pushed;
+					OnDropDown (EventArgs.Empty);
+				}
+				
+				Invalidate (button_area);
+				Update ();
+			}
+			Capture = true;
+		}
+
+		void OnMouseEnter (object sender, EventArgs e)
+		{
+			if (ThemeEngine.Current.CombBoxBackgroundHasHotElementStyle (this))
+				Invalidate ();
+		}
+
+		void OnMouseLeave (object sender, EventArgs e)
+		{
+			if (ThemeEngine.Current.CombBoxBackgroundHasHotElementStyle (this)) {
+				drop_down_button_entered = false;
+				Invalidate ();
+			} else {
+				if (show_dropdown_button)
+					DropDownButtonEntered = false;
+			}
+		}
+
+		void OnMouseMoveCB (object sender, MouseEventArgs e)
+		{
+			if (show_dropdown_button && !dropped_down)
+				DropDownButtonEntered = button_area.Contains (e.Location);
+
+			if (DropDownStyle == ComboBoxStyle.Simple)
+				return;
+
+			if (listbox_ctrl != null && listbox_ctrl.Visible) {
+				Point location = listbox_ctrl.PointToClient (Widget.MousePosition);
+				if (listbox_ctrl.ClientRectangle.Contains (location))
+					listbox_ctrl.Capture = true;
+			}
+		}
+
+		void OnMouseUpCB (object sender, MouseEventArgs e)
+		{
+			Capture = false;
+			
+			button_state = ButtonState.Normal;
+			Invalidate (button_area);
+
+			OnClick (EventArgs.Empty);
+
+			if (dropped_down)
+				listbox_ctrl.Capture = true;
+		}
+
+		private void OnMouseWheelCB (object sender, MouseEventArgs me)
+		{
+			if (Items.Count == 0)
+				return;
+
+			if (listbox_ctrl != null && listbox_ctrl.Visible) {
+				int lines = me.Delta / 120 * SystemInformation.MouseWheelScrollLines;
+				listbox_ctrl.Scroll (-lines);
+			} else {
+				int lines = me.Delta / 120;
+				int index = SelectedIndex - lines;
+				if (index < 0)
+					index = 0;
+				else if (index >= Items.Count)
+					index = Items.Count - 1;
+				SelectedIndex = index;
+			}
+		}
+
+		MouseEventArgs TranslateMouseEventArgs (MouseEventArgs args)
+		{
+			Point loc = PointToClient (Widget.MousePosition);
+			return new MouseEventArgs (args.Button, args.Clicks, loc.X, loc.Y, args.Delta);
+		}
+
+		internal override void OnPaintInternal (PaintEventArgs pevent)
+		{
+			if (suspend_ctrlupdate)
+				return;
+
+			Draw (ClientRectangle, pevent.Graphics);
+		}
+		
+		private void OnTextBoxClick (object sender, EventArgs e)
+		{
+			OnClick (e);
+		}
+
+		private void OnTextChangedEdit (object sender, EventArgs e)
+		{
+			if (process_textchanged_event == false)
+				return; 
+
+			int item = FindStringCaseInsensitive (textbox_ctrl.Text);
+			
+			if (item == -1) {
+				// Setting base.Text below will raise this event
+				// if we found something
+				OnTextChanged (EventArgs.Empty);
+				return;
+			}
+			
+			if (listbox_ctrl != null) {
+				// Set as top item
+				if (process_texchanged_autoscroll)
+					listbox_ctrl.EnsureTop (item);
+			}
+
+			base.Text = textbox_ctrl.Text;
+		}
+
+		private void OnTextKeyPress (object sender, KeyPressEventArgs e)
+		{
+			selected_index = -1;
+			if (listbox_ctrl != null)
+				listbox_ctrl.HighlightedIndex = -1;
+		}
+
+		internal void SetWidgetText (string s, bool suppressTextChanged)
+		{
+			SetWidgetText (s, suppressTextChanged, false);
+		}
+
+		internal void SetWidgetText (string s, bool suppressTextChanged, bool supressAutoScroll)
+		{
+			if (suppressTextChanged)
+				process_textchanged_event = false;
+			if (supressAutoScroll)
+				process_texchanged_autoscroll = false;
+				
+			textbox_ctrl.Text = s;
+			textbox_ctrl.SelectAll ();
+			process_textchanged_event = true;
+			process_texchanged_autoscroll = true;
+		}
+		
+		void UpdateComboBoxBounds ()
+		{
+			if (requested_height == -1)
+				return;
+
+			// Save the requested height since set bounds can destroy it
+			int save_height = requested_height;
+			SetBounds (bounds.X, bounds.Y, bounds.Width, SnapHeight (requested_height),
+				BoundsSpecified.Height);
+			requested_height = save_height;
+		}
+
+		int SnapHeight (int height)
+		{
+			if (DropDownStyle == ComboBoxStyle.Simple && height > PreferredHeight) {
+				if (IntegralHeight) {
+					int border = ThemeEngine.Current.Border3DSize.Height;
+					int lb_height = (height - PreferredHeight - 2) - border * 2;
+					if (lb_height > ItemHeight) {
+						int partial = (lb_height) % ItemHeight;
+						height -= partial;
+					} else if (lb_height < ItemHeight)
+						height = PreferredHeight;
+				}
+			} else
+				height = PreferredHeight;
+
+			return height;
+		}
+
+		private void UpdatedItems ()
+		{
+			if (listbox_ctrl != null) {
+				listbox_ctrl.UpdateLastVisibleItem ();
+				listbox_ctrl.CalcListBoxArea ();
+				listbox_ctrl.Refresh ();
+			}
+		}
+
+		#endregion Private Methods
+
+		[ListBindableAttribute (false)]
+		public class ObjectCollection : IList, ICollection, IEnumerable
+		{
+
+			private ComboBox owner;
+			internal ArrayList object_items = new ArrayList ();
+			
+            public ComboBox Owner
+            {
+                get { return owner; }
+            }
+
+			#region UIA Framework Events
+
+			//NOTE:
+			//	We are using Reflection to add/remove internal events.
+			//	Class ListProvider uses the events.
+			//
+			//Event used to generate UIA StructureChangedEvent
+			static object UIACollectionChangedEvent = new object ();
+
+			internal event CollectionChangeEventHandler UIACollectionChanged {
+				add { owner.Events.AddHandler (UIACollectionChangedEvent, value); }
+				remove { owner.Events.RemoveHandler (UIACollectionChangedEvent, value); }
+			}
+			
+			internal void OnUIACollectionChangedEvent (CollectionChangeEventArgs args)
+			{
+				CollectionChangeEventHandler eh
+					= (CollectionChangeEventHandler) owner.Events [UIACollectionChangedEvent];
+				if (eh != null)
+					eh (owner, args);
+			}
+
+			#endregion UIA Framework Events
+
+			public ObjectCollection (ComboBox owner)
+			{
+				this.owner = owner;
+			}
+
+			#region Public Properties
+			public int Count {
+				get { return object_items.Count; }
+			}
+
+			public bool IsReadOnly {
+				get { return false; }
+			}
+
+			[Browsable (false)]
+			//[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+			public virtual object this [int index] {
+				get {
+					if (index < 0 || index >= Count)
+						throw new ArgumentOutOfRangeException ("index");
+
+					return object_items[index];
+				}
+				set {
+					if (index < 0 || index >= Count)
+						throw new ArgumentOutOfRangeException ("index");
+					if (value == null)
+						throw new ArgumentNullException ("value");
+
+					//UIA Framework event: Item Removed
+					OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, object_items [index]));
+
+					object_items[index] = value;
+					
+					//UIA Framework event: Item Added
+					OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, value));
+
+					if (owner.listbox_ctrl != null)
+						owner.listbox_ctrl.InvalidateItem (index);
+					if (index == owner.SelectedIndex) {
+						if (owner.textbox_ctrl == null)
+							owner.Refresh ();
+						else {
+							owner.textbox_ctrl.Text = value.ToString ();
+							owner.textbox_ctrl.SelectAll ();
+						}
+					}
+				}
+			}
+
+			bool ICollection.IsSynchronized {
+				get { return false; }
+			}
+
+			object ICollection.SyncRoot {
+				get { return this; }
+			}
+
+			bool IList.IsFixedSize {
+				get { return false; }
+			}
+
+			#endregion Public Properties
+			
+			#region Public Methods
+			public int Add (object item)
+			{
+				int idx;
+
+				idx = AddItem (item, false);
+				owner.UpdatedItems ();
+				return idx;
+			}
+
+			public void AddRange (object[] items)
+			{
+				if (items == null)
+					throw new ArgumentNullException ("items");
+
+				foreach (object mi in items)
+					AddItem (mi, true);
+
+				if (owner.sorted)
+					Sort ();
+				
+				owner.UpdatedItems ();
+			}
+
+			public void Clear ()
+			{
+				owner.selected_index = -1;
+				object_items.Clear ();
+				owner.UpdatedItems ();
+				owner.Refresh ();
+				
+				//UIA Framework event: Items list cleared
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, null));
+			}
+			
+			public bool Contains (object value)
+			{
+				if (value == null)
+					throw new ArgumentNullException ("value");
+
+				return object_items.Contains (value);
+			}
+
+			public void CopyTo (object [] destination, int arrayIndex)
+			{
+				object_items.CopyTo (destination, arrayIndex);
+			}
+
+			void ICollection.CopyTo (Array destination, int index)
+			{
+				object_items.CopyTo (destination, index);
+			}
+
+			public IEnumerator GetEnumerator ()
+			{
+				return object_items.GetEnumerator ();
+			}
+
+			int IList.Add (object item)
+			{
+				return Add (item);
+			}
+
+			public int IndexOf (object value)
+			{
+				if (value == null)
+					throw new ArgumentNullException ("value");
+
+				return object_items.IndexOf (value);
+			}
+
+			public void Insert (int index,  object item)
+			{
+				if (index < 0 || index > Count)
+					throw new ArgumentOutOfRangeException ("index");
+				if (item == null)
+					throw new ArgumentNullException ("item");
+				
+				owner.BeginUpdate ();
+				
+				if (owner.Sorted)
+					AddItem (item, false);
+				else {
+					object_items.Insert (index, item);
+					//UIA Framework event: Item added
+					OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
+				}
+				
+				owner.EndUpdate ();	// Calls UpdatedItems
+			}
+
+			public void Remove (object value)
+			{
+				if (value == null)
+					return;
+				int index = IndexOf (value);
+				if (index >= 0)
+					RemoveAt (index);
+			}
+
+			public void RemoveAt (int index)
+			{
+				if (index < 0 || index >= Count)
+					throw new ArgumentOutOfRangeException ("index");
+					
+				if (index < owner.SelectedIndex)
+					--owner.SelectedIndex;
+				else if (index == owner.SelectedIndex)
+					owner.SelectedIndex = -1;
+
+				object removed = object_items [index];
+
+				object_items.RemoveAt (index);
+				owner.UpdatedItems ();
+				
+				//UIA Framework event: Item removed
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, removed));
+			}
+			#endregion Public Methods
+
+			#region Private Methods
+			private int AddItem (object item, bool suspend)
+			{
+				// suspend means do not sort as we put new items in, we will do a
+				// big sort at the end
+				if (item == null)
+					throw new ArgumentNullException ("item");
+
+				if (owner.Sorted && !suspend) {
+					int index = 0;
+					foreach (object o in object_items) {
+						if (String.Compare (item.ToString (), o.ToString ()) < 0) {
+							object_items.Insert (index, item);
+							
+							// If we added the new item before the selectedindex
+							// bump the selectedindex by one, behavior differs if
+							// Handle has not been created.
+							if (index <= owner.selected_index && owner.IsHandleCreated)
+								owner.selected_index++;
+								
+							//UIA Framework event: Item added
+							OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
+
+							return index;
+						}
+						index++;
+					}
+				}
+				object_items.Add (item);
+				
+				//UIA Framework event: Item added
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
+				
+				return object_items.Count - 1;
+			}
+			
+			internal void AddRange (IList items)
+			{
+				foreach (object mi in items)
+					AddItem (mi, false);
+				
+				if (owner.sorted)
+					Sort ();
+				
+				owner.UpdatedItems ();
+			}
+
+			internal void Sort ()
+			{
+				// If the objects the user put here don't have their own comparer,
+				// use one that compares based on the object's ToString
+				if (object_items.Count > 0 && object_items[0] is IComparer)
+					object_items.Sort ();
+				else
+					object_items.Sort (new ObjectComparer (owner));
+			}
+
+			private class ObjectComparer : IComparer
+			{
+				private ListWidget owner;
+				
+				public ObjectComparer (ListWidget owner)
+				{
+					this.owner = owner;
+				}
+				
+				#region IComparer Members
+				public int Compare (object x, object y)
+				{
+					return string.Compare (owner.GetItemText (x), owner.GetItemText (y));
+				}
+				#endregion
+			}
+			#endregion Private Methods
+		}
+
+		internal class ComboTextBox : TextBox {
+
+			private ComboBox owner;
+
+			public ComboTextBox (ComboBox owner)
+			{
+				this.owner = owner;
+				ShowSelection = false;
+				owner.EnabledChanged += OwnerEnabledChangedHandler;
+				owner.LostFocus += OwnerLostFocusHandler;
+			}
+
+			void OwnerEnabledChangedHandler (object o, EventArgs args)
+			{
+				ShowSelection = owner.Focused && owner.Enabled;
+			}
+
+			void OwnerLostFocusHandler (object o, EventArgs args)
+			{
+				if (IsAutoCompleteAvailable)
+					owner.Text = Text;
+			}
+
+			protected override void OnKeyDown (KeyEventArgs args)
+			{
+				if (args.KeyCode == Keys.Enter && IsAutoCompleteAvailable)
+					owner.Text = Text;
+
+				base.OnKeyDown (args);
+			}
+
+			internal override void OnAutoCompleteValueSelected (EventArgs args)
+			{
+				base.OnAutoCompleteValueSelected (args);
+				owner.Text = Text;
+			}
+
+			internal void SetSelectable (bool selectable)
+			{
+				SetStyle (Widgetstyles.Selectable, selectable);
+			}
+
+			internal void ActivateCaret (bool active)
+			{
+				if (active)
+					document.CaretHasFocus ();
+				else
+					document.CaretLostFocus ();
+			}
+			
+			internal override void OnTextUpdate ()
+			{
+				base.OnTextUpdate ();
+				owner.OnTextUpdate (EventArgs.Empty);
+			}
+			
+			protected override void OnGotFocus (EventArgs e)
+			{
+				owner.Select (false, true);
+			}
+
+			protected override void OnLostFocus (EventArgs e)
+			{
+				owner.Select (false, true);
+			}
+
+			// We have to pass these events to our owner - MouseMove is not, however.
+
+			protected override void OnMouseDown (MouseEventArgs e)
+			{
+				base.OnMouseDown (e);
+				owner.OnMouseDown (owner.TranslateMouseEventArgs (e));
+			}
+
+			protected override void OnMouseUp (MouseEventArgs e)
+			{
+				base.OnMouseUp (e);
+				owner.OnMouseUp (owner.TranslateMouseEventArgs (e));
+			}
+
+			protected override void OnMouseClick (MouseEventArgs e)
+			{
+				base.OnMouseClick (e);
+				owner.OnMouseClick (owner.TranslateMouseEventArgs (e));
+			}
+
+			protected override void OnMouseDoubleClick (MouseEventArgs e)
+			{
+				base.OnMouseDoubleClick (e);
+				owner.OnMouseDoubleClick (owner.TranslateMouseEventArgs (e));
+			}
+
+			public override bool Focused {
+				get {
+					return owner.Focused;
+				}
+			}
+			protected override void Dispose(bool disposing)
+			{
+				if (disposing ) {
+					// Prevents corruption of combobox text by disposed object
+					owner.EnabledChanged -= OwnerEnabledChangedHandler;
+					owner.LostFocus -= OwnerLostFocusHandler;
+				}
+				base.Dispose(disposing);
+			}
+
+			internal override bool ActivateOnShow { get { return false; } }
+		}
+
+		internal class ComboListBox : Widget
+		{
+			private ComboBox owner;
+			private VScrollBarLB vscrollbar_ctrl;
+			private int top_item;			/* First item that we show the in the current page */
+			private int last_item;			/* Last visible item */
+			internal int page_size;			/* Number of listbox items per page */
+			private Rectangle textarea_drawable;	/* Rectangle of the drawable text area */
+			
+			internal enum ItemNavigation
+			{
+				First,
+				Last,
+				Next,
+				Previous,
+				NextPage,
+				PreviousPage,
+			}
+
+			#region UIA Framework: Properties
+
+			internal int UIATopItem {
+				get { return top_item; }
+			}
+			
+			internal int UIALastItem {
+				get { return last_item; }
+			}
+
+			internal ScrollBar UIAVScrollBar {
+				get { return vscrollbar_ctrl; }
+			}
+
+			#endregion
+			
+			class VScrollBarLB : VScrollBar
+			{
+				public VScrollBarLB ()
+				{
+				}
+				
+				internal override bool InternalCapture {
+					get { return Capture; }
+					set { }
+				}
+
+				public void FireMouseDown (MouseEventArgs e) 
+				{
+					if (!Visible) 
+						return;
+
+					e = TranslateEvent (e);
+					OnMouseDown (e);
+				}
+				
+				public void FireMouseUp (MouseEventArgs e) 
+				{
+					if (!Visible)
+						return;
+
+					e = TranslateEvent (e);
+					OnMouseUp (e);
+				}
+				
+				public void FireMouseMove (MouseEventArgs e) 
+				{
+					if (!Visible)
+						return;
+
+					e = TranslateEvent (e);
+					OnMouseMove (e);
+				}
+				
+				MouseEventArgs TranslateEvent (MouseEventArgs e)
+				{
+					Point loc = PointToClient (Widget.MousePosition);
+					return new MouseEventArgs (e.Button, e.Clicks, loc.X, loc.Y, e.Delta);
+				}
+			}
+
+			public ComboListBox (ComboBox owner)
+			{
+				this.owner = owner;
+				top_item = 0;
+				last_item = 0;
+				page_size = 0;
+
+				MouseWheel += new MouseEventHandler (OnMouseWheelCLB);
+
+				SetStyle (Widgetstyles.UserPaint | Widgetstyles.AllPaintingInWmPaint, true);
+				SetStyle (Widgetstyles.ResizeRedraw | Widgetstyles.Opaque, true);
+
+				this.is_visible = false;
+
+				if (owner.DropDownStyle == ComboBoxStyle.Simple)
+					InternalBorderStyle = BorderStyle.Fixed3D;
+				else
+					InternalBorderStyle = BorderStyle.FixedSingle;
+			}
+
+			protected override CreateParams CreateParams
+			{
+				get {
+					CreateParams cp = base.CreateParams;
+					if (owner == null || owner.DropDownStyle == ComboBoxStyle.Simple)
+						return cp;
+
+					cp.Style ^= (int)WindowStyles.WS_CHILD;
+					cp.Style ^= (int)WindowStyles.WS_VISIBLE;
+					cp.Style |= (int)WindowStyles.WS_POPUP;
+					cp.ExStyle |= (int) WindowExStyles.WS_EX_TOOLWINDOW | (int) WindowExStyles.WS_EX_TOPMOST;
+					return cp;
+				}
+			}
+
+			internal override bool InternalCapture {
+				get {
+					return Capture;
+				}
+
+				set {
+				}
+			}
+
+			internal override bool ActivateOnShow { get { return false; } }
+			#region Private Methods
+
+			// Calcs the listbox area
+			internal void CalcListBoxArea ()
+			{
+				int width, height;
+				bool show_scrollbar;
+
+				if (owner.DropDownStyle == ComboBoxStyle.Simple) {
+					Rectangle area = owner.listbox_area;
+					width = area.Width;
+					height = area.Height;
+					show_scrollbar = owner.Items.Count * owner.ItemHeight > height;
+
+					// No calculation needed
+					if (height <= 0 || width <= 0)
+						return;
+
+				}
+				else { // DropDown or DropDownList
+					
+					width = owner.DropDownWidth;
+					int visible_items_count = (owner.Items.Count <= owner.MaxDropDownItems) ? owner.Items.Count : owner.MaxDropDownItems;
+					
+					if (owner.DrawMode == DrawMode.OwnerDrawVariable) {
+						height = 0;
+						for (int i = 0; i < visible_items_count; i++) {
+							height += owner.GetItemHeight (i);
+						}
+
+						show_scrollbar = owner.Items.Count > owner.MaxDropDownItems;
+						
+					} else	{
+						if (owner.DropDownHeight == default_drop_down_height) { // ignore DropDownHeight
+							height = owner.ItemHeight * visible_items_count;
+							show_scrollbar = owner.Items.Count > owner.MaxDropDownItems;
+						} else {
+							// ignore visible items count, and use manual height instead
+							height = owner.DropDownHeight;
+							show_scrollbar = (owner.Items.Count * owner.ItemHeight) > height;
+						}
+					}
+				}
+				
+				page_size = Math.Max (height / owner.ItemHeight, 1);
+
+				ComboBoxStyle dropdown_style = owner.DropDownStyle;
+				if (!show_scrollbar) {
+
+					if (vscrollbar_ctrl != null)
+						vscrollbar_ctrl.Visible = false;
+					if (dropdown_style != ComboBoxStyle.Simple)
+						height = owner.ItemHeight * owner.items.Count;
+				} else {
+					/* Need vertical scrollbar */
+					if (vscrollbar_ctrl == null) {
+						vscrollbar_ctrl = new VScrollBarLB ();
+						vscrollbar_ctrl.Minimum = 0;
+						vscrollbar_ctrl.SmallChange = 1;
+						vscrollbar_ctrl.LargeChange = 1;
+						vscrollbar_ctrl.Maximum = 0;
+						vscrollbar_ctrl.ValueChanged += new EventHandler (VerticalScrollEvent);
+						Widgets.AddImplicit (vscrollbar_ctrl);
+					}
+					
+					vscrollbar_ctrl.Dock = DockStyle.Right;
+
+					vscrollbar_ctrl.Maximum = owner.Items.Count - 1;
+					int large = page_size;
+					if (large < 1)
+						large = 1;
+					vscrollbar_ctrl.LargeChange = large;
+					vscrollbar_ctrl.Visible = true;
+
+					int hli = HighlightedIndex;
+					if (hli > 0) {
+						hli = Math.Min (hli, vscrollbar_ctrl.Maximum);
+						vscrollbar_ctrl.Value = hli;
+					}
+				}
+
+				var borderWidth = Hwnd.GetBorderWidth (CreateParams);
+				var borderAdjustment = dropdown_style == ComboBoxStyle.Simple ? new Size (0, 0) :
+					new Size (borderWidth.top + borderWidth.bottom, borderWidth.left + borderWidth.right);
+				Size = new Size (width, height + borderAdjustment.Height);
+				textarea_drawable = new Rectangle (ClientRectangle.Location,
+					new Size (width - borderAdjustment.Width, height));
+
+				if (vscrollbar_ctrl != null && show_scrollbar)
+					textarea_drawable.Width -= vscrollbar_ctrl.Width;
+
+				last_item = LastVisibleItem ();
+			}
+
+			private void Draw (Rectangle clip, Graphics dc)
+			{
+				dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (owner.BackColor), clip);
+
+				if (owner.Items.Count > 0) {
+					
+					for (int i = top_item; i <= last_item; i++) {
+						Rectangle item_rect = GetItemDisplayRectangle (i, top_item);
+
+						if (!clip.IntersectsWith (item_rect))
+							continue;
+
+						DrawItemState state = DrawItemState.None;
+						Color back_color = owner.BackColor;
+						Color fore_color = owner.ForeColor;
+
+						if (i == HighlightedIndex) {
+							state |= DrawItemState.Selected;
+							back_color = SystemColors.Highlight;
+							fore_color = SystemColors.HighlightText;
+							
+							if (owner.DropDownStyle == ComboBoxStyle.DropDownList) {
+								state |= DrawItemState.Focus;
+							}
+						}
+
+						owner.HandleDrawItem (new DrawItemEventArgs (dc, owner.Font, item_rect,
+							i, state, fore_color, back_color));
+					}
+				}
+			}
+
+			int highlighted_index = -1;
+
+			public int HighlightedIndex {
+				get { return highlighted_index; }
+				set { 
+					if (highlighted_index == value)
+						return;
+
+					if (highlighted_index != -1 && highlighted_index < this.owner.Items.Count)
+						Invalidate (GetItemDisplayRectangle (highlighted_index, top_item));
+					highlighted_index = value;
+					if (highlighted_index != -1)
+						Invalidate (GetItemDisplayRectangle (highlighted_index, top_item));
+				}
+			}
+
+			private Rectangle GetItemDisplayRectangle (int index, int top_index)
+			{
+				if (index < 0 || index >= owner.Items.Count)
+					throw new  ArgumentOutOfRangeException ("GetItemRectangle index out of range.");
+
+				Rectangle item_rect = new Rectangle ();
+				int height = owner.GetItemHeight (index);
+
+				item_rect.X = 0;
+				item_rect.Width = textarea_drawable.Width;
+				if (owner.DrawMode == DrawMode.OwnerDrawVariable) {
+					item_rect.Y = 0;
+					for (int i = top_index; i < index; i++)
+						item_rect.Y += owner.GetItemHeight (i);
+				} else
+					item_rect.Y = height * (index - top_index);
+
+				item_rect.Height = height;
+				return item_rect;
+			}
+
+			public void HideWindow ()
+			{
+				if (owner.DropDownStyle == ComboBoxStyle.Simple)
+					return;
+					
+				Capture = false;
+				Hide ();
+				owner.DropDownListBoxFinished ();
+			}
+
+			private int IndexFromPointDisplayRectangle (int x, int y)
+			{
+				for (int i = top_item; i <= last_item; i++) {
+					if (GetItemDisplayRectangle (i, top_item).Contains (x, y) == true)
+						return i;
+				}
+
+				return -1;
+			}
+
+			public void InvalidateItem (int index)
+			{
+				if (Visible)
+					Invalidate (GetItemDisplayRectangle (index, top_item));
+			}
+
+			public int LastVisibleItem ()
+			{
+				Rectangle item_rect;
+				int top_y = textarea_drawable.Y + textarea_drawable.Height;
+				int i = 0;
+				
+				for (i = top_item; i < owner.Items.Count; i++) {
+					item_rect = GetItemDisplayRectangle (i, top_item);
+					if (item_rect.Y + item_rect.Height > top_y) {
+						return i;
+					}
+				}
+				return i - 1;
+			}
+
+			public void SetTopItem (int item)
+			{
+				if (top_item == item)
+					return;
+				top_item = item;
+				UpdateLastVisibleItem ();
+				Invalidate ();
+			}
+
+			public int FirstVisibleItem ()
+			{
+				return top_item;
+			}
+
+			public void EnsureTop (int item)
+			{
+				if (owner.Items.Count == 0)
+					return;
+				if (vscrollbar_ctrl == null || !vscrollbar_ctrl.Visible)
+					return;
+
+				int max = vscrollbar_ctrl.Maximum - page_size + 1;
+				if (item > max)
+					item = max;
+				else if (item < vscrollbar_ctrl.Minimum)
+					item = vscrollbar_ctrl.Minimum;
+
+				vscrollbar_ctrl.Value = item;
+			}
+
+			bool scrollbar_grabbed = false;
+
+			bool InScrollBar {
+				get {
+					if (vscrollbar_ctrl == null || !vscrollbar_ctrl.is_visible)
+						return false;
+
+					return vscrollbar_ctrl.Bounds.Contains (PointToClient (Widget.MousePosition));
+				}
+			}
+
+			protected override void OnMouseDown (MouseEventArgs e)
+			{
+				if (InScrollBar) {
+					vscrollbar_ctrl.FireMouseDown (e);
+					scrollbar_grabbed = true;
+				}
+			}
+
+			protected override void OnMouseMove (MouseEventArgs e)
+			{
+				if (owner.DropDownStyle == ComboBoxStyle.Simple)
+					return;
+
+				if (scrollbar_grabbed || (!Capture && InScrollBar)) {
+					vscrollbar_ctrl.FireMouseMove (e);
+					return;
+				}
+
+				Point pt = PointToClient (Widget.MousePosition);
+				int index = IndexFromPointDisplayRectangle (pt.X, pt.Y);
+
+				if (index != -1)
+					HighlightedIndex = index;
+			}
+			
+			protected override void OnMouseUp (MouseEventArgs e)
+			{
+				int index = IndexFromPointDisplayRectangle (e.X, e.Y);
+
+				if (scrollbar_grabbed) {
+					vscrollbar_ctrl.FireMouseUp (e);
+					scrollbar_grabbed = false;
+					if (index != -1)
+						HighlightedIndex = index;
+					return;
+				}
+
+				if (index == -1) {
+					HideWindow ();
+					return;
+				}
+
+				bool is_change = owner.SelectedIndex != index;
+				
+				owner.SetSelectedIndex (index, true);
+				owner.OnSelectionChangeCommitted (new EventArgs ());
+				
+				// If the user selected the already selected item, SelectedIndex
+				// won't fire these events, but .Net does, so we do it here
+				if (!is_change) {
+					owner.OnSelectedValueChanged (EventArgs.Empty);
+					owner.OnSelectedIndexChanged (EventArgs.Empty);
+				}
+				
+				HideWindow ();
+			}
+
+			internal override void OnPaintInternal (PaintEventArgs pevent)
+			{
+				Draw (pevent.ClipRectangle,pevent.Graphics);
+			}
+
+			public bool ShowWindow ()
+			{
+				if (owner.DropDownStyle == ComboBoxStyle.Simple && owner.Items.Count == 0)
+					return false;
+
+				HighlightedIndex = owner.SelectedIndex;
+
+				CalcListBoxArea ();
+				// If the listbox would extend below the screen, move it above the textbox.
+				Rectangle scrn_rect = Screen.FromControl (owner).Bounds;
+				if (this.Location.Y + this.Height >= scrn_rect.Bottom)
+					this.Location = new Point (this.Location.X, this.Location.Y - (this.Height + owner.TextArea.Height));
+				Show ();
+
+				Refresh ();
+				owner.OnDropDown (EventArgs.Empty);
+				return true;
+			}
+			
+			public void UpdateLastVisibleItem ()
+			{
+				last_item = LastVisibleItem ();
+			}
+
+			public void Scroll (int delta)
+			{
+				if (delta == 0 || vscrollbar_ctrl == null || !vscrollbar_ctrl.Visible)
+					return;
+
+				int max = vscrollbar_ctrl.Maximum - page_size + 1;
+
+				int val = vscrollbar_ctrl.Value + delta;
+				if (val > max)
+					val = max;
+				else if (val < vscrollbar_ctrl.Minimum)
+					val = vscrollbar_ctrl.Minimum;
+				vscrollbar_ctrl.Value = val;
+			}
+
+			private void OnMouseWheelCLB (object sender, MouseEventArgs me)
+			{
+				if (owner.Items.Count == 0)
+					return;
+
+				int lines = me.Delta / 120 * SystemInformation.MouseWheelScrollLines;
+				Scroll (-lines);
+			}
+
+			// Value Changed
+			private void VerticalScrollEvent (object sender, EventArgs e)
+			{
+				if (top_item == vscrollbar_ctrl.Value)
+					return;
+
+				top_item =  vscrollbar_ctrl.Value;
+				UpdateLastVisibleItem ();
+				Invalidate ();
+			}
+			
+			protected override void WndProc(ref Message m) {
+				if (m.Msg == (int)Msg.WM_SETFOCUS) {
+					owner.Select (false, true);
+				}
+				base.WndProc (ref m);
+			}
+
+			#endregion Private Methods
+		}
+	}
+}