Move ShiftUI source code to ShiftOS

This'll be a lot easier to work on.

1 files changed, 3093 insertions, 0 deletions

diff --git a/source/ShiftUI/Widgets/ListBox.cs b/source/ShiftUI/Widgets/ListBox.cs
new file mode 100644
index 0000000..ed705f6
--- /dev/null
+++ b/source/ShiftUI/Widgets/ListBox.cs
@@ -0,0 +1,3093 @@
+/// 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]>
+//
+
+// COMPLETE
+
+using System;
+using System.Drawing;
+using System.Collections;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.ComponentModel.Design.Serialization;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+
+namespace ShiftUI
+{
+	[DefaultProperty("Items")]
+	[DefaultEvent("SelectedIndexChanged")]
+	//[Designer ("ShiftUI.Design.ListBoxDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
+	[DefaultBindingProperty ("SelectedValue")]
+	[ClassInterface (ClassInterfaceType.AutoDispatch)]
+	[ComVisible (true)]
+    [ToolboxWidget]
+    public class ListBox : ListWidget
+	{
+		public const int DefaultItemHeight = 13;
+		public const int NoMatches = -1;
+		
+		internal enum ItemNavigation
+		{
+			First,
+			Last,
+			Next,
+			Previous,
+			NextPage,
+			PreviousPage,
+			PreviousColumn,
+			NextColumn
+		}
+		
+		Hashtable item_heights;
+		private int item_height = -1;
+		private int column_width = 0;
+		private int requested_height;
+		private DrawMode draw_mode = DrawMode.Normal;
+		private int horizontal_extent = 0;
+		private bool horizontal_scrollbar = false;
+		private bool integral_height = true;
+		private bool multicolumn = false;
+		private bool scroll_always_visible = false;
+		private SelectedIndexCollection selected_indices;
+		private SelectedObjectCollection selected_items;
+		private SelectionMode selection_mode = SelectionMode.One;
+		private bool sorted = false;
+		private bool use_tabstops = true;
+		private int column_width_internal = 120;
+		private ImplicitVScrollBar vscrollbar;
+		private ImplicitHScrollBar hscrollbar;
+		private int hbar_offset;
+		private bool suspend_layout;
+		private bool ctrl_pressed = false;
+		private bool shift_pressed = false;
+		private bool explicit_item_height = false;
+		private int top_index = 0;
+		private int last_visible_index = 0;
+		private Rectangle items_area;
+		private int focused_item = -1;
+		private ObjectCollection items;
+		private IntegerCollection custom_tab_offsets;
+		private Padding padding;
+		private bool use_custom_tab_offsets;
+
+		public ListBox ()
+		{
+			items = CreateItemCollection ();
+			selected_indices = new SelectedIndexCollection (this);
+			selected_items = new SelectedObjectCollection (this);
+
+			requested_height = bounds.Height;
+			InternalBorderStyle = BorderStyle.Fixed3D;
+			BackColor = ThemeEngine.Current.ColorControl;
+
+			/* Vertical scrollbar */
+			vscrollbar = new ImplicitVScrollBar ();
+			vscrollbar.Minimum = 0;
+			vscrollbar.SmallChange = 1;
+			vscrollbar.LargeChange = 1;
+			vscrollbar.Maximum = 0;
+			vscrollbar.ValueChanged += new EventHandler (VerticalScrollEvent);
+			vscrollbar.Visible = false;
+
+			/* Horizontal scrollbar */
+			hscrollbar = new ImplicitHScrollBar ();
+			hscrollbar.Minimum = 0;
+			hscrollbar.SmallChange = 1;
+			hscrollbar.LargeChange = 1;
+			hscrollbar.Maximum = 0;
+			hscrollbar.Visible = false;
+			hscrollbar.ValueChanged += new EventHandler (HorizontalScrollEvent);
+
+			Widgets.AddImplicit (vscrollbar);
+			Widgets.AddImplicit (hscrollbar);
+
+			/* Events */
+			MouseDown += new MouseEventHandler (OnMouseDownLB);
+			MouseMove += new MouseEventHandler (OnMouseMoveLB);
+			MouseUp += new MouseEventHandler (OnMouseUpLB);
+			MouseWheel += new MouseEventHandler (OnMouseWheelLB);
+			KeyUp += new KeyEventHandler (OnKeyUpLB);
+			GotFocus += new EventHandler (OnGotFocus);
+			LostFocus += new EventHandler (OnLostFocus);
+			
+			SetStyle (Widgetstyles.UserPaint, false);
+
+			custom_tab_offsets = new IntegerCollection (this);
+		}
+
+		#region Events
+		static object DrawItemEvent = new object ();
+		static object MeasureItemEvent = new object ();
+		static object SelectedIndexChangedEvent = new object ();
+
+		[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 (true)]
+		//[EditorBrowsable (EditorBrowsableState.Always)]
+		public new event EventHandler Click {
+			add { base.Click += value; }
+			remove { base.Click -= value; }
+		}
+
+		public event DrawItemEventHandler DrawItem {
+			add { Events.AddHandler (DrawItemEvent, value); }
+			remove { Events.RemoveHandler (DrawItemEvent, value); }
+		}
+
+		public event MeasureItemEventHandler MeasureItem {
+			add { Events.AddHandler (MeasureItemEvent, value); }
+			remove { Events.RemoveHandler (MeasureItemEvent, value); }
+		}
+
+		[Browsable (true)]
+		//[EditorBrowsable (EditorBrowsableState.Always)]
+		public new event MouseEventHandler MouseClick {
+			add { base.MouseClick += value; }
+			remove { base.MouseClick -= 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); }
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public new event EventHandler TextChanged {
+			add { base.TextChanged += value; }
+			remove { base.TextChanged -= value; }
+		}
+		#endregion // Events
+
+		#region UIA Framework Events 
+		//NOTE:
+		//	We are using Reflection to add/remove internal events.
+		//	Class ListProvider uses the events.
+		//
+		//Event used to generate UIA Selection Pattern 
+		static object UIASelectionModeChangedEvent = new object ();
+
+		internal event EventHandler UIASelectionModeChanged {
+			add { Events.AddHandler (UIASelectionModeChangedEvent, value); }
+			remove { Events.RemoveHandler (UIASelectionModeChangedEvent, value); }
+		}
+
+		internal void OnUIASelectionModeChangedEvent ()
+		{
+			EventHandler eh = (EventHandler) Events [UIASelectionModeChangedEvent];
+			if (eh != null)
+				eh (this, EventArgs.Empty);
+		}
+
+		static object UIAFocusedItemChangedEvent = new object ();
+
+		internal event EventHandler UIAFocusedItemChanged {
+			add { Events.AddHandler (UIAFocusedItemChangedEvent, value); }
+			remove { Events.RemoveHandler (UIAFocusedItemChangedEvent, value); }
+		}
+
+		internal void OnUIAFocusedItemChangedEvent ()
+		{
+			EventHandler eh = (EventHandler) Events [UIAFocusedItemChangedEvent];
+			if (eh != null)
+				eh (this, EventArgs.Empty);
+		}
+		#endregion UIA Framework Events 
+
+		#region Public Properties
+		public override Color BackColor {
+			get { return base.BackColor; }
+			set {
+				if (base.BackColor == value)
+					return;
+
+    				base.BackColor = value;
+				base.Refresh ();	// Careful. Calling the base method is not the same that calling 
+			}				// the overriden one that refresh also all the items
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public override Image BackgroundImage {
+			get { return base.BackgroundImage; }
+			set { 
+    				base.BackgroundImage = value;
+				base.Refresh ();
+			}
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		public override ImageLayout BackgroundImageLayout {
+			get { return base.BackgroundImageLayout; }
+			set { base.BackgroundImageLayout = value; }
+		}
+
+		[DefaultValue (BorderStyle.Fixed3D)]
+		[DispId(-504)]
+		public BorderStyle BorderStyle {
+			get { return InternalBorderStyle; }
+			set { 
+				InternalBorderStyle = value; 
+				UpdateListBoxBounds ();
+			}
+		}
+
+		[DefaultValue (0)]
+		[Localizable (true)]
+		public int ColumnWidth {
+			get { return column_width; }
+			set {
+				if (value < 0)
+					throw new ArgumentException ("A value less than zero is assigned to the property.");
+
+				column_width = value;
+
+				if (value == 0)
+					ColumnWidthInternal = 120;
+				else
+					ColumnWidthInternal = value;
+
+				base.Refresh ();
+			}
+		}
+
+		protected override CreateParams CreateParams {
+			get { return base.CreateParams;}
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
+		public IntegerCollection CustomTabOffsets {
+			get { return custom_tab_offsets; }
+		}
+
+		protected override Size DefaultSize {
+			get { return new Size (120, 96); }
+		}
+
+		[RefreshProperties(RefreshProperties.Repaint)]
+		[DefaultValue (DrawMode.Normal)]
+		public virtual 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 (value == DrawMode.OwnerDrawVariable && multicolumn == true)
+					throw new ArgumentException ("Cannot have variable height and multicolumn");
+
+				if (draw_mode == value)
+					return;
+
+				draw_mode = value;
+
+				if (draw_mode == DrawMode.OwnerDrawVariable)
+					item_heights = new Hashtable ();
+				else
+					item_heights = null;
+
+				if (Parent != null)
+					Parent.PerformLayout (this, "DrawMode");
+				base.Refresh ();
+			}
+		}
+
+		public override Font Font {
+			get { return base.Font; }
+			set { base.Font = value; }
+		}
+
+		public override Color ForeColor {
+			get { return base.ForeColor; }
+			set {
+				if (base.ForeColor == value)
+					return;
+
+				base.ForeColor = value;
+				base.Refresh ();
+			}
+		}
+
+		[DefaultValue (0)]
+		[Localizable (true)]
+		public int HorizontalExtent {
+			get { return horizontal_extent; }
+			set {
+				if (horizontal_extent == value)
+					return;
+
+				horizontal_extent = value;
+				base.Refresh ();
+			}
+		}
+
+		[DefaultValue (false)]
+		[Localizable (true)]
+		public bool HorizontalScrollbar {
+			get { return horizontal_scrollbar; }
+			set {
+				if (horizontal_scrollbar == value)
+					return;
+
+				horizontal_scrollbar = value;
+				UpdateScrollBars ();
+				base.Refresh ();
+			}
+		}
+
+		[DefaultValue (true)]
+		[Localizable (true)]
+		[RefreshProperties(RefreshProperties.Repaint)]
+		public bool IntegralHeight {
+			get { return integral_height; }
+			set {
+				if (integral_height == value)
+					return;
+
+				integral_height = value;
+				UpdateListBoxBounds ();
+			}
+		}
+
+		[DefaultValue (13)]
+		[Localizable (true)]
+		[RefreshProperties(RefreshProperties.Repaint)]
+		public virtual 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 > 255)
+					throw new ArgumentOutOfRangeException ("The ItemHeight property was set beyond 255 pixels");
+
+				explicit_item_height = true;
+				if (item_height == value)
+					return;
+
+				item_height = value;
+				if (IntegralHeight)
+					UpdateListBoxBounds ();
+				LayoutListBox ();
+			}
+		}
+
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
+		[Localizable (true)]
+		//[Editor ("ShiftUI.Design.ListWidgetstringCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
+		[MergableProperty (false)]
+		public ObjectCollection Items {
+			get { return items; }
+		}
+
+		[DefaultValue (false)]
+		public bool MultiColumn {
+			get { return multicolumn; }
+			set {
+				if (multicolumn == value)
+					return;
+
+				if (value == true && DrawMode == DrawMode.OwnerDrawVariable)
+					throw new ArgumentException ("A multicolumn ListBox cannot have a variable-sized height.");
+					
+				multicolumn = value;
+				LayoutListBox ();
+				Invalidate ();
+			}
+		}
+
+		[Browsable (false)]
+		//[EditorBrowsable (EditorBrowsableState.Never)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public new Padding Padding {
+			get { return padding; }
+			set { padding = value; }
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public int PreferredHeight {
+			get {
+				int itemsHeight = 0;
+				if (draw_mode == DrawMode.Normal)
+					itemsHeight = FontHeight * items.Count;
+				else if (draw_mode == DrawMode.OwnerDrawFixed)
+					itemsHeight = ItemHeight * items.Count;
+				else if (draw_mode == DrawMode.OwnerDrawVariable) {
+					for (int i = 0; i < items.Count; i++)
+						itemsHeight += (int) item_heights [Items [i]];
+				}
+				
+				return itemsHeight;
+			}
+		}
+
+		public override RightToLeft RightToLeft {
+			get { return base.RightToLeft; }
+			set {
+				base.RightToLeft = value;
+				if (base.RightToLeft == RightToLeft.Yes)
+					StringFormat.Alignment = StringAlignment.Far;
+				else
+					StringFormat.Alignment = StringAlignment.Near;
+				base.Refresh ();
+			}
+		}
+
+		// Only affects the Vertical ScrollBar
+		[DefaultValue (false)]
+		[Localizable (true)]
+		public bool ScrollAlwaysVisible {
+			get { return scroll_always_visible; }
+			set {
+				if (scroll_always_visible == value)
+					return;
+
+				scroll_always_visible = value;
+				UpdateScrollBars ();
+			}
+		}
+
+		[Bindable(true)]
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public override int SelectedIndex {
+			get { 
+				if (selected_indices == null)
+					return -1;
+					
+				return selected_indices.Count > 0 ? selected_indices [0] : -1;
+			}
+			set {
+				if (value < -1 || value >= Items.Count)
+					throw new ArgumentOutOfRangeException ("Index of out range");
+
+				if (SelectionMode == SelectionMode.None)
+					throw new ArgumentException ("cannot call this method if SelectionMode is SelectionMode.None");
+
+				if (value == -1)
+					selected_indices.Clear ();
+				else
+					selected_indices.Add (value);
+			}
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public SelectedIndexCollection SelectedIndices {
+			get { return selected_indices; }
+		}
+
+		[Bindable(true)]
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public object SelectedItem {
+			get {
+				if (SelectedItems.Count > 0)
+					return SelectedItems[0];
+				else
+					return null;
+			}
+			set {
+				if (value != null && !Items.Contains (value))
+					return; // FIXME: this is probably an exception
+					
+				SelectedIndex = value == null ? - 1 : Items.IndexOf (value);
+			}
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public SelectedObjectCollection SelectedItems {
+			get {return selected_items;}
+		}
+
+		[DefaultValue (SelectionMode.One)]
+		public virtual SelectionMode SelectionMode {
+			get { return selection_mode; }
+			set {
+				if (!Enum.IsDefined (typeof (SelectionMode), value))
+					throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for SelectionMode", value));
+
+				if (selection_mode == value)
+					return;
+					
+				selection_mode = value;
+					
+				switch (selection_mode) {
+				case SelectionMode.None: 
+					SelectedIndices.Clear ();
+					break;
+
+				case SelectionMode.One:
+					// FIXME: Probably this can be improved
+					ArrayList old_selection = (ArrayList) SelectedIndices.List.Clone ();
+					for (int i = 1; i < old_selection.Count; i++)
+						SelectedIndices.Remove ((int)old_selection [i]);
+					break;
+
+				default:
+					break;
+				}
+
+				// UIA Framework: Generates SelectionModeChanged event.
+				OnUIASelectionModeChangedEvent ();
+			}
+		}
+
+		[DefaultValue (false)]
+		public bool Sorted {
+			get { return sorted; }
+			set {
+				if (sorted == value)
+					return;
+
+				sorted = value;
+				if (sorted)
+					Sort ();
+			}
+		}
+
+		[Bindable (false)]
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		public override string Text {
+			get {
+				if (SelectionMode != SelectionMode.None && SelectedIndex != -1)
+					return GetItemText (SelectedItem);
+
+				return base.Text;
+			}
+			set {
+
+				base.Text = value;
+
+				if (SelectionMode == SelectionMode.None)
+					return;
+
+				int index;
+
+				index = FindStringExact (value);
+
+				if (index == -1)
+					return;
+
+				SelectedIndex = index;
+			}
+		}
+
+		[Browsable (false)]
+		//[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+		public int TopIndex {
+			get { return top_index; }
+			set {
+				if (value == top_index)
+					return;
+
+				if (value < 0 || value >= Items.Count)
+					return;
+
+				int page_size = (items_area.Height / ItemHeight);
+				
+				if (Items.Count < page_size)
+					value = 0;
+				else if (!multicolumn)
+					top_index = Math.Min (value, Items.Count - page_size);
+				else
+					top_index = value;
+					
+				UpdateTopItem ();
+				base.Refresh ();
+			}
+		}
+
+		[Browsable (false)]
+		[DefaultValue (false)]
+		public bool UseCustomTabOffsets {
+			get { return use_custom_tab_offsets; }
+			set { 
+				if (use_custom_tab_offsets != value) {
+					use_custom_tab_offsets = value;
+					CalculateTabStops ();
+				}
+			 }
+		}
+
+		[DefaultValue (true)]
+		public bool UseTabStops {
+			get { return use_tabstops; }
+			set {
+				if (use_tabstops == value)
+					return;
+
+				use_tabstops = value;
+				CalculateTabStops ();
+			}
+		}
+
+		protected override bool AllowSelection {
+			get {
+				return SelectionMode != SelectionMode.None;
+			}
+		}
+		#endregion Public Properties
+
+		#region Private Properties
+
+		private int ColumnWidthInternal {
+			get { return column_width_internal; }
+			set { column_width_internal = value; }
+		}
+
+		private int row_count = 1;
+		private int RowCount {
+			get {
+				return MultiColumn ? row_count : Items.Count;
+			}
+		}
+
+		#endregion Private Properties
+
+		#region UIA Framework Properties
+
+		internal ScrollBar UIAHScrollBar {
+			get { return hscrollbar; }
+		}
+
+		internal ScrollBar UIAVScrollBar {
+			get { return vscrollbar; }
+		}
+
+		#endregion UIA Framework Properties
+
+		#region Public Methods
+		[Obsolete ("this method has been deprecated")]
+		protected virtual void AddItemsCore (object[] value)
+		{
+			Items.AddRange (value);
+		}
+
+		public void BeginUpdate ()
+		{
+			suspend_layout = true;
+		}
+
+		public void ClearSelected ()
+		{
+			selected_indices.Clear ();
+		}
+
+		protected virtual ObjectCollection CreateItemCollection ()
+		{
+			return new ObjectCollection (this);
+		}
+
+		public void EndUpdate ()
+		{
+			suspend_layout = false;
+			LayoutListBox ();
+			base.Refresh ();
+		}
+
+		public int FindString (String s)
+		{
+			return FindString (s, -1);
+		}
+
+		public int FindString (string s,  int startIndex)
+		{
+			if (Items.Count == 0)
+				return -1; // No exception throwing if empty
+
+			if (startIndex < -1 || startIndex >= Items.Count)
+				throw new ArgumentOutOfRangeException ("Index of out range");
+
+			startIndex = (startIndex == Items.Count - 1) ? 0 : startIndex + 1;
+
+			int i = startIndex;
+			while (true) {
+				string text = GetItemText (Items [i]);
+				if (CultureInfo.CurrentCulture.CompareInfo.IsPrefix (text, s,
+						CompareOptions.IgnoreCase))
+					return i;
+
+				i = (i == Items.Count - 1) ? 0 : i + 1;
+				if (i == startIndex)
+					break;
+			}
+
+			return NoMatches;
+		}
+
+		public int FindStringExact (string s)
+		{
+			return FindStringExact (s, -1);
+		}
+
+		public int FindStringExact (string s,  int startIndex)
+		{
+			if (Items.Count == 0)
+				return -1; // No exception throwing if empty
+
+			if (startIndex < -1 || startIndex >= Items.Count)
+				throw new ArgumentOutOfRangeException ("Index of out range");
+
+			startIndex = (startIndex + 1 == Items.Count) ? 0 : startIndex + 1;
+
+			int i = startIndex;
+			while (true) {
+				if (String.Compare (GetItemText (Items[i]), s, true) == 0)
+					return i;
+
+				i = (i + 1 == Items.Count) ? 0 : i + 1;
+				if (i == startIndex)
+					break;
+			}
+
+			return NoMatches;
+		}
+
+		public int GetItemHeight (int index)
+		{
+			if (index < 0 || index >= Items.Count)
+				throw new ArgumentOutOfRangeException ("Index of out range");
+				
+			if (DrawMode == DrawMode.OwnerDrawVariable && IsHandleCreated == true) {
+				
+				object o = Items [index];
+				if (item_heights.Contains (o))
+					return (int) item_heights [o];
+				
+				MeasureItemEventArgs args = new MeasureItemEventArgs (DeviceContext, index, ItemHeight);
+				OnMeasureItem (args);
+				item_heights [o] = args.ItemHeight;
+				return args.ItemHeight;
+			}
+
+			return ItemHeight;
+		}
+
+		public Rectangle GetItemRectangle (int index)
+		{
+			if (index < 0 || index >= Items.Count)
+				throw new  ArgumentOutOfRangeException ("GetItemRectangle index out of range.");
+
+			Rectangle rect = new Rectangle ();
+
+			if (MultiColumn) {
+				int col = index / RowCount;
+				int y = index;
+				if (y < 0) // We convert it to valid positive value 
+					y += RowCount * (top_index / RowCount);
+				rect.Y = (y % RowCount) * ItemHeight;
+				rect.X = (col - (top_index / RowCount)) * ColumnWidthInternal;
+				rect.Height = ItemHeight;
+				rect.Width = ColumnWidthInternal;
+			} else {
+				rect.X = 0;
+				rect.Height = GetItemHeight (index);
+				rect.Width = items_area.Width;
+				
+				if (DrawMode == DrawMode.OwnerDrawVariable) {
+					rect.Y = 0;
+					if (index >= top_index) {
+						for (int i = top_index; i < index; i++) {
+							rect.Y += GetItemHeight (i);
+						}
+					} else {
+						for (int i = index; i < top_index; i++) {
+							rect.Y -= GetItemHeight (i);
+						}
+					}
+				} else {
+					rect.Y = ItemHeight * (index - top_index);	
+				}
+			}
+
+			if (this is CheckedListBox)
+				rect.Width += 15;
+				
+			return rect;
+		}
+
+		//[EditorBrowsable (EditorBrowsableState.Advanced)]
+		protected override Rectangle GetScaledBounds (Rectangle bounds, SizeF factor, BoundsSpecified specified)
+		{
+			bounds.Height = requested_height;
+
+			return base.GetScaledBounds (bounds, factor, specified);
+		}
+
+		public bool GetSelected (int index)
+		{
+			if (index < 0 || index >= Items.Count)
+				throw new ArgumentOutOfRangeException ("Index of out range");
+
+			return SelectedIndices.Contains (index);
+		}
+
+		public int IndexFromPoint (Point p)
+		{
+			return IndexFromPoint (p.X, p.Y);
+		}
+
+		// Only returns visible points
+		public int IndexFromPoint (int x, int y)
+		{
+
+			if (Items.Count == 0) {
+				return -1;
+			}
+
+			for (int i = top_index; i <= last_visible_index; i++) {
+				if (GetItemRectangle (i).Contains (x,y) == true)
+					return i;
+			}
+
+			return -1;
+		}
+
+		protected override void OnChangeUICues (UICuesEventArgs e)
+		{
+			base.OnChangeUICues (e);
+		}
+
+		protected override void OnDataSourceChanged (EventArgs e)
+		{
+			base.OnDataSourceChanged (e);
+			BindDataItems ();
+			
+			if (DataSource == null || DataManager == null) {
+				SelectedIndex = -1;
+			} else {
+				SelectedIndex = DataManager.Position;
+			}
+		}
+
+		protected override void OnDisplayMemberChanged (EventArgs e)
+		{
+			base.OnDisplayMemberChanged (e);
+
+			if (DataManager == null || !IsHandleCreated)
+				return;
+
+			BindDataItems ();
+			base.Refresh ();
+		}
+
+		protected virtual void OnDrawItem (DrawItemEventArgs e)
+		{			
+			switch (DrawMode) {
+			case DrawMode.OwnerDrawFixed:
+			case DrawMode.OwnerDrawVariable:
+				DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
+				if (eh != null)
+					eh (this, e);
+
+				break;
+
+			default:
+				ThemeEngine.Current.DrawListBoxItem (this, e);
+				break;
+			}
+		}
+
+		protected override void OnFontChanged (EventArgs e)
+		{
+			base.OnFontChanged (e);
+
+			if (use_tabstops)
+				StringFormat.SetTabStops (0, new float [] {(float)(Font.Height * 3.7)});
+
+			if (explicit_item_height) {
+				base.Refresh ();
+			} else {
+				SizeF sz = TextRenderer.MeasureString ("The quick brown Fox", Font);
+				item_height = (int) sz.Height;
+				if (IntegralHeight)
+					UpdateListBoxBounds ();
+				LayoutListBox ();
+			}
+		}
+
+		protected override void OnHandleCreated (EventArgs e)
+		{
+			base.OnHandleCreated (e);
+
+			if (IntegralHeight)
+				UpdateListBoxBounds ();
+
+			LayoutListBox ();
+			EnsureVisible (focused_item);
+		}
+
+		protected override void OnHandleDestroyed (EventArgs e)
+		{
+			base.OnHandleDestroyed (e);
+		}
+
+		protected virtual void OnMeasureItem (MeasureItemEventArgs e)
+		{
+			if (draw_mode != DrawMode.OwnerDrawVariable)
+				return;
+
+			MeasureItemEventHandler eh = (MeasureItemEventHandler)(Events [MeasureItemEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected override void OnParentChanged (EventArgs e)
+		{
+			base.OnParentChanged (e);
+		}
+
+		protected override void OnResize (EventArgs e)
+		{
+			base.OnResize (e);
+			if (canvas_size.IsEmpty || MultiColumn)
+				LayoutListBox ();
+				
+			Invalidate ();
+		}
+
+		protected override void OnSelectedIndexChanged (EventArgs e)
+		{
+			base.OnSelectedIndexChanged (e);
+
+			EventHandler eh = (EventHandler)(Events [SelectedIndexChangedEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected override void OnSelectedValueChanged (EventArgs e)
+		{
+			base.OnSelectedValueChanged (e);
+		}
+
+		public override void Refresh ()
+		{
+			if (draw_mode == DrawMode.OwnerDrawVariable)
+				item_heights.Clear ();
+			
+			base.Refresh ();
+		}
+
+		protected override void RefreshItem (int index)
+		{
+			if (index < 0 || index >= Items.Count)
+				throw new ArgumentOutOfRangeException ("Index of out range");
+				
+			if (draw_mode == DrawMode.OwnerDrawVariable)
+				item_heights.Remove (Items [index]);
+		}
+
+		protected override void RefreshItems ()
+		{
+			for (int i = 0; i < Items.Count; i++) {
+				RefreshItem (i);
+			}
+
+			LayoutListBox ();
+			Refresh ();
+		}
+
+		public override void ResetBackColor ()
+		{
+			base.ResetBackColor ();
+		}
+
+		public override void ResetForeColor ()
+		{
+			base.ResetForeColor ();
+		}
+
+		protected override void ScaleWidget (SizeF factor, BoundsSpecified specified)
+		{
+			base.ScaleWidget (factor, specified);
+		}
+
+		private int SnapHeightToIntegral (int height)
+		{
+			int border;
+
+			switch (border_style) {
+			case BorderStyle.Fixed3D:
+				border = ThemeEngine.Current.Border3DSize.Height;
+				break;
+			case BorderStyle.FixedSingle:
+				border = ThemeEngine.Current.BorderSize.Height;
+				break;
+			case BorderStyle.None:
+			default:
+				border = 0;
+				break;
+			}
+
+			height -= (2 * border);
+			height -= height % ItemHeight;
+			height += (2 * border);
+
+			return height;
+		}
+		
+		protected override void SetBoundsCore (int x,  int y, int width, int height, BoundsSpecified specified)
+		{
+			if ((specified & BoundsSpecified.Height) == BoundsSpecified.Height)
+				requested_height = height;
+
+			if (IntegralHeight && IsHandleCreated)
+				height = SnapHeightToIntegral (height);
+
+			base.SetBoundsCore (x, y, width, height, specified);
+			UpdateScrollBars ();
+			last_visible_index = LastVisibleItem ();
+		}
+
+		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.AddItems (value);
+			} finally {
+				EndUpdate ();
+			}
+		}
+
+		public void SetSelected (int index, bool value)
+		{
+			if (index < 0 || index >= Items.Count)
+				throw new ArgumentOutOfRangeException ("Index of out range");
+
+			if (SelectionMode == SelectionMode.None)
+				throw new InvalidOperationException ();
+
+			if (value)
+				SelectedIndices.Add (index);
+			else
+				SelectedIndices.Remove (index);
+		}
+
+		protected virtual void Sort ()
+		{
+			Sort (true);
+		}
+
+		//
+		// Sometimes we could need to Sort, and request a Refresh
+		// in a different place, to not have the painting done twice
+		//
+		void Sort (bool paint)
+		{
+			if (Items.Count == 0)
+				return;
+
+			Items.Sort ();
+
+			if (paint)
+				base.Refresh ();
+		}
+
+		public override string ToString ()
+		{
+			return base.ToString ();
+		}
+
+		protected virtual void WmReflectCommand (ref Message m)
+		{
+		}
+
+		protected override void WndProc (ref Message m)
+		{
+			if ((Msg)m.Msg == Msg.WM_KEYDOWN) {
+				if (ProcessKeyMessage (ref m))
+					m.Result = IntPtr.Zero;
+				else {
+					HandleKeyDown ((Keys)m.WParam.ToInt32 ());
+					DefWndProc (ref m);
+				}
+
+				return;
+			}
+
+			base.WndProc (ref m);
+		}
+
+		#endregion Public Methods
+
+		#region Private Methods
+
+		private void CalculateTabStops ()
+		{
+			if (use_tabstops) {
+				if (use_custom_tab_offsets) {
+					float[] f = new float[custom_tab_offsets.Count];
+					custom_tab_offsets.CopyTo (f, 0);
+					StringFormat.SetTabStops (0, f);
+				}
+				else
+					StringFormat.SetTabStops (0, new float[] { (float)(Font.Height * 3.7) });
+			} else
+				StringFormat.SetTabStops (0, new float[0]);
+
+			this.Invalidate ();
+		}
+
+		private Size canvas_size;
+
+		private void LayoutListBox ()
+		{
+			if (!IsHandleCreated || suspend_layout)
+				return;
+
+			if (MultiColumn)
+				LayoutMultiColumn ();
+			else
+				LayoutSingleColumn ();
+
+			last_visible_index = LastVisibleItem ();
+			UpdateScrollBars ();
+		}
+
+		private void LayoutSingleColumn ()
+		{
+			int height, width;
+
+			switch (DrawMode) {
+			case DrawMode.OwnerDrawVariable:
+				height = 0;
+				width = HorizontalExtent;
+				for (int i = 0; i < Items.Count; i++) {
+					height += GetItemHeight (i);
+				}
+				break;
+
+			case DrawMode.OwnerDrawFixed:
+				height = Items.Count * ItemHeight;
+				width = HorizontalExtent;
+				break;
+
+			case DrawMode.Normal:
+			default:
+				height = Items.Count * ItemHeight;
+				width = 0;
+				for (int i = 0; i < Items.Count; i++) {
+					SizeF sz = TextRenderer.MeasureString (GetItemText (Items[i]), Font);
+					int t = (int)sz.Width;
+					
+					if (this is CheckedListBox)
+						t += 15;
+						
+					if (t > width)
+						width = t;
+				}
+				break;
+			}
+
+			canvas_size = new Size (width, height);
+		}
+
+		private void LayoutMultiColumn ()
+		{
+			int usable_height = ClientRectangle.Height - (ScrollAlwaysVisible ? hscrollbar.Height : 0);
+			row_count = Math.Max (1, usable_height / ItemHeight);
+
+			int cols = (int) Math.Ceiling ((float)Items.Count / (float) row_count);
+			Size sz = new Size (cols * ColumnWidthInternal, row_count * ItemHeight);
+			if (!ScrollAlwaysVisible && sz.Width > ClientRectangle.Width && row_count > 1) {
+				usable_height = ClientRectangle.Height - hscrollbar.Height;
+				row_count = Math.Max (1, usable_height / ItemHeight);
+				cols = (int) Math.Ceiling ((float)Items.Count / (float) row_count);
+				sz = new Size (cols * ColumnWidthInternal, row_count * ItemHeight);
+			}
+			canvas_size = sz;
+		}
+
+		internal void Draw (Rectangle clip, Graphics dc)
+		{
+			Theme theme = ThemeEngine.Current;
+
+			if (hscrollbar.Visible && vscrollbar.Visible) {
+				// Paint the dead space in the bottom right corner
+				Rectangle rect = new Rectangle (hscrollbar.Right, vscrollbar.Bottom, vscrollbar.Width, hscrollbar.Height);
+				if (rect.IntersectsWith (clip))
+					dc.FillRectangle (theme.ResPool.GetSolidBrush (theme.ColorControl), rect);
+			}
+
+			dc.FillRectangle (theme.ResPool.GetSolidBrush (BackColor), items_area);
+
+			if (Items.Count == 0)
+				return;
+
+			for (int i = top_index; i <= last_visible_index; i++) {
+				Rectangle rect = GetItemDisplayRectangle (i, top_index);
+
+				if (!clip.IntersectsWith (rect))
+					continue;
+
+				DrawItemState state = DrawItemState.None;
+
+				if (SelectedIndices.Contains (i))
+					state |= DrawItemState.Selected;
+					
+				if (has_focus && FocusedItem == i)
+					state |= DrawItemState.Focus;
+					
+				if (MultiColumn == false && hscrollbar != null && hscrollbar.Visible) {
+					rect.X -= hscrollbar.Value;
+					rect.Width += hscrollbar.Value;
+				}
+
+				Color fore_color = !Enabled ? ThemeEngine.Current.ColorGrayText :
+					(state & DrawItemState.Selected) != 0 ? ThemeEngine.Current.ColorHighlightText : ForeColor;
+				OnDrawItem (new DrawItemEventArgs (dc, Font, rect, i, state, fore_color, BackColor));
+			}
+		}
+
+		// Converts a GetItemRectangle to a one that we can display
+		internal Rectangle GetItemDisplayRectangle (int index, int first_displayble)
+		{
+			Rectangle item_rect;
+			Rectangle first_item_rect = GetItemRectangle (first_displayble);
+			item_rect = GetItemRectangle (index);
+			item_rect.X -= first_item_rect.X;
+			item_rect.Y -= first_item_rect.Y;
+			
+			// Subtract the checkboxes from the width
+			if (this is CheckedListBox)
+				item_rect.Width -= 14;
+
+			return item_rect;
+		}
+
+		// Value Changed
+		private void HorizontalScrollEvent (object sender, EventArgs e)
+		{
+			if (multicolumn) {
+				int top_item = top_index;
+				int last_item = last_visible_index;
+
+				top_index = RowCount * hscrollbar.Value;
+				last_visible_index = LastVisibleItem ();
+
+				if (top_item != top_index || last_item != last_visible_index)
+					Invalidate (items_area);
+			}
+			else {
+				int old_offset = hbar_offset;
+				hbar_offset = hscrollbar.Value;
+
+				if (hbar_offset < 0)
+					hbar_offset = 0;
+
+				if (IsHandleCreated) {
+					XplatUI.ScrollWindow (Handle, items_area, old_offset - hbar_offset, 0, false);
+
+					// Invalidate the previous selection border, to keep it properly updated.
+					Rectangle selection_border_area = new Rectangle (items_area.Width - (hbar_offset - old_offset) - 3, 0, 
+							3, items_area.Height);
+					Invalidate (selection_border_area);
+				}
+			}
+		}
+
+		// Only returns visible points. The diference of with IndexFromPoint is that the rectangle
+		// has screen coordinates
+		private int IndexAtClientPoint (int x, int y)
+		{	
+			if (Items.Count == 0)
+				return -1;
+			
+			if (x < 0)
+				x = 0;
+			else if (x > ClientRectangle.Right)
+				x = ClientRectangle.Right;
+
+			if (y < 0)
+				y = 0;
+			else if (y > ClientRectangle.Bottom)
+				y = ClientRectangle.Bottom;
+
+			for (int i = top_index; i <= last_visible_index; i++)
+				if (GetItemDisplayRectangle (i, top_index).Contains (x, y))
+					return i;
+
+			return -1;
+		}
+
+		internal override bool IsInputCharInternal (char charCode)
+		{
+			return true;
+		}
+
+		private int LastVisibleItem ()
+		{
+			Rectangle item_rect;
+			int top_y = items_area.Y + items_area.Height;
+			int i = 0;
+
+			if (top_index >= Items.Count)
+				return top_index;
+
+			for (i = top_index; i < Items.Count; i++) {
+				item_rect = GetItemDisplayRectangle (i, top_index);
+				if (MultiColumn) {
+					if (item_rect.X > items_area.Width)
+						return i - 1;
+				} else {
+					if (item_rect.Y + item_rect.Height > top_y)
+						return i;
+				}
+			}
+			return i - 1;
+		}
+
+		private void UpdateTopItem ()
+		{
+			if (MultiColumn) {
+				int col = top_index / RowCount;
+				
+				if (col > hscrollbar.Maximum)
+					hscrollbar.Value = hscrollbar.Maximum;
+				else
+					hscrollbar.Value = col;
+			} else {
+				if (top_index > vscrollbar.Maximum)
+					vscrollbar.Value = vscrollbar.Maximum;
+				else
+					vscrollbar.Value = top_index;
+				Scroll (vscrollbar, vscrollbar.Value - top_index);
+			}
+		}
+		
+		// Navigates to the indicated item and returns the new item
+		private int NavigateItemVisually (ItemNavigation navigation)
+		{			
+			int page_size, columns, selected_index = -1;
+
+			if (multicolumn) {
+				columns = items_area.Width / ColumnWidthInternal; 
+				page_size = columns * RowCount;
+				if (page_size == 0) {
+					page_size = RowCount;
+				}
+			} else {
+				page_size = items_area.Height / ItemHeight;	
+			}
+
+			switch (navigation) {
+
+			case ItemNavigation.PreviousColumn: {
+				if (SelectedIndex - RowCount < 0) {
+					return -1;
+				}
+
+				if (SelectedIndex - RowCount < top_index) {
+					top_index = SelectedIndex - RowCount;
+					UpdateTopItem ();
+				}
+					
+				selected_index = SelectedIndex - RowCount;
+				break;
+			}
+			
+			case ItemNavigation.NextColumn: {
+				if (SelectedIndex + RowCount >= Items.Count) {
+					break;
+				}
+
+				if (SelectedIndex + RowCount > last_visible_index) {
+					top_index = SelectedIndex;
+					UpdateTopItem ();
+				}
+					
+				selected_index = SelectedIndex + RowCount;
+				break;
+			}
+
+			case ItemNavigation.First: {
+				top_index = 0;
+				selected_index  = 0;
+				UpdateTopItem ();
+				break;
+			}
+
+			case ItemNavigation.Last: {
+
+				int rows = items_area.Height / ItemHeight;
+				
+				if (multicolumn) {
+					selected_index = Items.Count - 1;
+					break;
+				}
+				if (Items.Count < rows) {
+					top_index = 0;
+					selected_index  = Items.Count - 1;
+					UpdateTopItem ();
+				} else {
+					top_index = Items.Count - rows;
+					selected_index  = Items.Count - 1;
+					UpdateTopItem ();
+				}
+				break;
+			}
+
+			case ItemNavigation.Next: {
+				if (FocusedItem == Items.Count - 1)
+					return -1;
+
+				if (multicolumn) {
+					selected_index = FocusedItem + 1;
+					break;
+				}
+				
+				int bottom = 0;
+				ArrayList heights = new ArrayList ();
+				if (draw_mode == DrawMode.OwnerDrawVariable) {
+					for (int i = top_index; i <= FocusedItem + 1; i++) {
+						int h = GetItemHeight (i);
+						bottom += h;
+						heights.Add (h);
+					}
+				} else {
+					bottom = ((FocusedItem + 1) - top_index + 1) * ItemHeight;
+				}
+
+				if (bottom >= items_area.Height) {
+					int overhang = bottom - items_area.Height;
+
+					int offset = 0;
+					if (draw_mode == DrawMode.OwnerDrawVariable)
+						while (overhang > 0)
+							overhang -= (int) heights [offset];
+					else
+						offset = (int) Math.Ceiling ((float)overhang / (float) ItemHeight);
+					top_index += offset;
+					UpdateTopItem ();
+				}
+				selected_index = FocusedItem + 1;
+				break;
+			}
+
+			case ItemNavigation.Previous: {
+				if (FocusedItem > 0) {
+					if (FocusedItem - 1 < top_index) {
+						top_index--;
+						UpdateTopItem ();
+					}
+					selected_index = FocusedItem - 1;
+				}
+				break;
+			}
+
+			case ItemNavigation.NextPage: {
+				if (Items.Count < page_size) {
+					NavigateItemVisually (ItemNavigation.Last);
+					break;
+				}
+
+				if (FocusedItem + page_size - 1 >= Items.Count) {
+					top_index = Items.Count - page_size;
+					UpdateTopItem ();
+					selected_index = Items.Count - 1;
+				}
+				else {
+					if (FocusedItem + page_size - 1  > last_visible_index) {
+						top_index = FocusedItem;
+						UpdateTopItem ();
+					}
+					
+					selected_index = FocusedItem + page_size - 1;
+				}
+					
+				break;
+			}			
+
+			case ItemNavigation.PreviousPage: {
+					
+				int rows = items_area.Height / ItemHeight;
+				if (FocusedItem - (rows - 1) <= 0) {
+					top_index = 0;
+					UpdateTopItem ();
+					selected_index = 0;
+				}
+				else { 
+					if (SelectedIndex - (rows - 1)  < top_index) {
+						top_index = FocusedItem - (rows - 1);
+						UpdateTopItem ();
+					}
+					
+					selected_index = FocusedItem - (rows - 1);
+				}
+					
+				break;
+			}		
+			default:
+				break;
+			}
+			
+			return selected_index;
+		}
+		
+		
+		private void OnGotFocus (object sender, EventArgs e)
+		{
+			if (Items.Count == 0)
+				return;
+
+			if (FocusedItem == -1)
+				FocusedItem = 0;
+
+			InvalidateItem (FocusedItem);
+		}
+		
+		private void OnLostFocus (object sender, EventArgs e)
+		{
+			if (FocusedItem != -1)
+				InvalidateItem (FocusedItem);
+		}
+
+		private bool KeySearch (Keys key)
+		{
+			char c = (char) key;
+			if (!Char.IsLetterOrDigit (c))
+				return false;
+
+			int idx = FindString (c.ToString (), SelectedIndex);
+			if (idx != ListBox.NoMatches)
+				SelectedIndex = idx;
+
+			return true;
+		}
+
+		internal void HandleKeyDown (Keys key)
+		{
+			int new_item = -1;
+			
+			if (Items.Count == 0)
+				return;
+
+			if (KeySearch (key))
+				return;
+
+			switch (key) {
+				
+				case Keys.ControlKey:
+					ctrl_pressed = true;
+					break;
+					
+				case Keys.ShiftKey:
+					shift_pressed = true;
+					break;
+					
+				case Keys.Home:
+					new_item = NavigateItemVisually (ItemNavigation.First);
+					break;
+
+				case Keys.End:
+					new_item = NavigateItemVisually (ItemNavigation.Last);
+					break;
+
+				case Keys.Up:
+					new_item = NavigateItemVisually (ItemNavigation.Previous);
+					break;
+	
+				case Keys.Down:
+					new_item = NavigateItemVisually (ItemNavigation.Next);
+					break;
+				
+				case Keys.PageUp:
+					new_item = NavigateItemVisually (ItemNavigation.PreviousPage);
+					break;
+	
+				case Keys.PageDown:
+					new_item = NavigateItemVisually (ItemNavigation.NextPage);
+					break;
+
+				case Keys.Right:
+					if (multicolumn == true) {
+						new_item = NavigateItemVisually (ItemNavigation.NextColumn);
+					}
+					break;
+	
+				case Keys.Left:
+					if (multicolumn == true) {
+						new_item = NavigateItemVisually (ItemNavigation.PreviousColumn);
+					}
+					break;
+					
+				case Keys.Space:
+					if (selection_mode == SelectionMode.MultiSimple) {
+						SelectedItemFromNavigation (FocusedItem);
+					}
+					break;
+				
+
+				default:
+					break;
+				}
+				
+				if (new_item != -1) {
+					FocusedItem = new_item;
+
+					if (selection_mode != SelectionMode.MultiSimple)
+						SelectedItemFromNavigation (new_item);
+				}
+		}
+		
+		private void OnKeyUpLB (object sender, KeyEventArgs e)
+		{
+			switch (e.KeyCode) {
+				case Keys.ControlKey:
+					ctrl_pressed = false;
+					break;
+				case Keys.ShiftKey:
+					shift_pressed = false;
+					break;
+				default: 
+					break;
+			}
+		}
+
+		internal void InvalidateItem (int index)
+		{
+			if (!IsHandleCreated)
+				return;
+			Rectangle bounds = GetItemDisplayRectangle (index, top_index);
+			if (ClientRectangle.IntersectsWith (bounds))
+				Invalidate (bounds);
+		}
+
+		internal virtual void OnItemClick (int index)
+		{
+			OnSelectedIndexChanged  (EventArgs.Empty);
+			OnSelectedValueChanged (EventArgs.Empty);
+		}
+
+		int anchor = -1;
+		int[] prev_selection;
+		bool button_pressed = false;
+		Point button_pressed_loc = new Point (-1, -1);
+
+		private void SelectExtended (int index)
+		{
+			SuspendLayout ();
+
+			ArrayList new_selection = new ArrayList ();
+			int start = anchor < index ? anchor : index;
+			int end = anchor > index ? anchor : index;
+			for (int i = start; i <= end; i++)
+				new_selection.Add (i);
+
+			if (ctrl_pressed)
+				foreach (int i in prev_selection)
+					if (!new_selection.Contains (i))
+						new_selection.Add (i);
+
+			// Need to make a copy since we can't enumerate and modify the collection
+			// at the same time
+			ArrayList sel_indices = (ArrayList) selected_indices.List.Clone ();
+			foreach (int i in sel_indices)
+				if (!new_selection.Contains (i))
+					selected_indices.Remove (i);
+
+			foreach (int i in new_selection)
+				if (!sel_indices.Contains (i))
+					selected_indices.AddCore (i);
+			ResumeLayout ();
+		}
+
+		private void OnMouseDownLB (object sender, MouseEventArgs e)
+		{
+			// Only do stuff with the left mouse button
+			if ((e.Button & MouseButtons.Left) == 0)
+				return;
+			
+			int index = IndexAtClientPoint (e.X, e.Y);
+			if (index == -1)
+				return;
+
+			switch (SelectionMode) {
+			case SelectionMode.One:
+				SelectedIndices.AddCore (index); // Unselects previous one
+				break;
+
+			case SelectionMode.MultiSimple:
+				if (SelectedIndices.Contains (index))
+					SelectedIndices.RemoveCore (index);
+				else
+					SelectedIndices.AddCore (index);
+				break;
+
+			case SelectionMode.MultiExtended:
+				shift_pressed = (XplatUI.State.ModifierKeys & Keys.Shift) != 0;
+				ctrl_pressed = (XplatUI.State.ModifierKeys & Keys.Widget) != 0;
+
+				if (shift_pressed) {
+					SelectedIndices.ClearCore ();
+					SelectExtended (index);
+					break;
+				}
+
+				anchor = index;
+
+				if (ctrl_pressed) {
+					prev_selection = new int [SelectedIndices.Count];
+					SelectedIndices.CopyTo (prev_selection, 0);
+
+					if (SelectedIndices.Contains (index))
+						SelectedIndices.RemoveCore (index);
+					else
+						SelectedIndices.AddCore (index);
+
+					break;
+				}
+
+				SelectedIndices.ClearCore ();
+				SelectedIndices.AddCore (index);
+				break;
+
+			case SelectionMode.None:
+				break;
+			default:
+				return;
+			}
+
+			button_pressed = true;
+			button_pressed_loc = new Point (e.X, e.Y);
+			FocusedItem = index;
+		}
+
+		private void OnMouseMoveLB (object sender, MouseEventArgs e)
+		{
+			// Don't take into account MouseMove events generated with MouseDown
+			if (!button_pressed || button_pressed_loc == new Point (e.X, e.Y))
+				return;
+
+			int index = IndexAtClientPoint (e.X, e.Y);
+			if (index == -1)
+				return;
+
+			switch (SelectionMode) {
+			case SelectionMode.One:
+				SelectedIndices.AddCore (index); // Unselects previous one
+				break;
+
+			case SelectionMode.MultiSimple:
+				break;
+
+			case SelectionMode.MultiExtended:
+				SelectExtended (index);
+				break;
+
+			case SelectionMode.None:
+				break;
+			default:
+				return;
+			}
+
+			FocusedItem = index;
+		}
+
+		internal override void OnDragDropEnd (DragDropEffects effects)
+		{
+			// In the case of a DnD operation (started on MouseDown)
+			// there will be no MouseUp event, so we need to reset 
+			// the state here
+			button_pressed = false;
+		}
+
+		private void OnMouseUpLB (object sender, MouseEventArgs e)
+		{
+			// Only do stuff with the left mouse button
+			if ((e.Button & MouseButtons.Left) == 0)
+				return;
+
+			if (e.Clicks > 1) {
+				OnDoubleClick (EventArgs.Empty);
+				OnMouseDoubleClick (e);
+			}
+			else if (e.Clicks == 1) {
+				OnClick (EventArgs.Empty);
+				OnMouseClick (e);
+			}
+			
+			if (!button_pressed)
+				return;
+
+			int index = IndexAtClientPoint (e.X, e.Y);
+			OnItemClick (index);
+			button_pressed = ctrl_pressed = shift_pressed = false;
+		}
+
+		private void Scroll (ScrollBar scrollbar, int delta)
+		{
+			if (delta == 0 || !scrollbar.Visible || !scrollbar.Enabled)
+				return;
+
+			int max;
+			if (scrollbar == hscrollbar)
+				max = hscrollbar.Maximum - (items_area.Width / ColumnWidthInternal) + 1;
+			else
+				max = vscrollbar.Maximum - (items_area.Height / ItemHeight) + 1;
+
+			int val = scrollbar.Value + delta;
+			if (val > max)
+				val = max;
+			else if (val < scrollbar.Minimum)
+				val = scrollbar.Minimum;
+			scrollbar.Value = val;
+		}
+
+		private void OnMouseWheelLB (object sender, MouseEventArgs me)
+		{
+			if (Items.Count == 0)
+				return;
+
+			int lines = me.Delta / 120;
+
+			if (MultiColumn)
+				Scroll (hscrollbar, -SystemInformation.MouseWheelScrollLines * lines);
+			else
+				Scroll (vscrollbar, -lines);
+		}
+
+		internal override void OnPaintInternal (PaintEventArgs pevent)
+		{
+			if (suspend_layout)
+				return;
+
+			Draw (pevent.ClipRectangle, pevent.Graphics);
+		}
+
+		internal void RepositionScrollBars ()
+		{
+			if (vscrollbar.is_visible) {
+				vscrollbar.Size = new Size (vscrollbar.Width, items_area.Height);
+				vscrollbar.Location = new Point (items_area.Width, 0);
+			}
+
+			if (hscrollbar.is_visible) {
+				hscrollbar.Size = new Size (items_area.Width, hscrollbar.Height);
+				hscrollbar.Location = new Point (0, items_area.Height);
+			}
+		}
+
+		// An item navigation operation (mouse or keyboard) has caused to select a new item
+		internal void SelectedItemFromNavigation (int index)
+		{
+			switch (SelectionMode) {
+				case SelectionMode.None:
+					// .Net doesn't select the item, only ensures that it's visible
+					// and fires the selection related events
+					EnsureVisible (index);
+					OnSelectedIndexChanged (EventArgs.Empty);
+					OnSelectedValueChanged (EventArgs.Empty);
+					break;
+				case SelectionMode.One: {
+					SelectedIndex = index;
+					break;
+				}
+				case SelectionMode.MultiSimple: {
+					if (SelectedIndex == -1) {
+						SelectedIndex = index;
+					} else {
+
+						if (SelectedIndices.Contains (index))
+							SelectedIndices.Remove (index);
+						else {
+							SelectedIndices.AddCore (index);
+
+							OnSelectedIndexChanged  (EventArgs.Empty);
+							OnSelectedValueChanged (EventArgs.Empty);
+						}
+					}
+					break;
+				}
+				
+				case SelectionMode.MultiExtended: {
+					if (SelectedIndex == -1) {
+						SelectedIndex = index;
+					} else {
+
+						if (ctrl_pressed == false && shift_pressed == false) {
+							SelectedIndices.Clear ();
+						}
+						
+						if (shift_pressed == true) {
+							ShiftSelection (index);
+						} else { // ctrl_pressed or single item
+							SelectedIndices.AddCore (index);
+
+						}
+
+						OnSelectedIndexChanged  (EventArgs.Empty);
+						OnSelectedValueChanged (EventArgs.Empty);
+					}
+					break;
+				}
+				
+				default:
+					break;
+			}
+		}
+		
+		private void ShiftSelection (int index)
+		{
+			int shorter_item = -1, dist = Items.Count + 1, cur_dist;
+			
+			foreach (int idx in selected_indices) {
+				if (idx > index) {
+					cur_dist = idx - index;
+				} else {
+					cur_dist = index - idx;
+				}
+
+				if (cur_dist < dist) {
+					dist = cur_dist;
+					shorter_item = idx;
+				}
+			}
+			
+			if (shorter_item != -1) {
+				int start, end;
+				
+				if (shorter_item > index) {
+					start = index;
+					end = shorter_item;
+				} else {
+					start = shorter_item;
+					end = index;
+				}
+				
+				selected_indices.Clear ();
+				for (int idx = start; idx <= end; idx++) {
+					selected_indices.AddCore (idx);
+				}
+			}
+		}
+		
+		internal int FocusedItem {
+			get { return focused_item; }
+			set {
+				if (focused_item == value)
+					return;
+
+				int prev = focused_item;
+			
+				focused_item = value;
+			
+				if (has_focus == false)
+					return;
+
+				if (prev != -1)
+					InvalidateItem (prev);
+			
+				if (value != -1)
+					InvalidateItem (value);
+
+				// UIA Framework: Generates FocusedItemChanged event.
+				OnUIAFocusedItemChangedEvent ();
+			}
+		}
+
+		StringFormat string_format;
+		internal StringFormat StringFormat {
+			get {
+				if (string_format == null) {
+					string_format = new StringFormat ();
+					string_format.FormatFlags = StringFormatFlags.NoWrap;
+
+					if (RightToLeft == RightToLeft.Yes)
+						string_format.Alignment = StringAlignment.Far;
+					else
+						string_format.Alignment = StringAlignment.Near;
+					CalculateTabStops ();
+				}
+				return string_format;
+			}
+		}
+
+		internal virtual void CollectionChanged ()
+		{
+			if (sorted) 
+				Sort (false);
+
+			if (Items.Count == 0) {
+				selected_indices.List.Clear ();
+				focused_item = -1;
+				top_index = 0;
+			}
+			if (Items.Count <= focused_item)
+				focused_item = Items.Count - 1;
+
+			if (!IsHandleCreated || suspend_layout)
+				return;
+
+			LayoutListBox ();
+
+			base.Refresh ();
+		}
+
+		void EnsureVisible (int index)
+		{
+			if (!IsHandleCreated || index == -1)
+				return;
+
+			if (index < top_index) {
+				top_index = index;
+				UpdateTopItem ();
+				Invalidate ();
+			} else if (!multicolumn) {
+				int rows = items_area.Height / ItemHeight;
+				if (index >= (top_index + rows))
+					top_index = index - rows + 1;
+
+				UpdateTopItem ();
+			} else {
+				int rows = Math.Max (1, items_area.Height / ItemHeight);
+				int cols = Math.Max (1, items_area.Width / ColumnWidthInternal);
+				
+				if (index >= (top_index + (rows * cols))) {
+					int incolumn = index / rows;
+					top_index = (incolumn - (cols - 1)) * rows;
+
+					UpdateTopItem ();
+					Invalidate ();
+				}
+			}
+		}
+
+		private void UpdateListBoxBounds ()
+		{
+			if (IsHandleCreated)
+				SetBoundsInternal (bounds.X, bounds.Y, bounds.Width, IntegralHeight ? SnapHeightToIntegral (requested_height) : requested_height, BoundsSpecified.None);
+		}
+
+		private void UpdateScrollBars ()
+		{
+			items_area = ClientRectangle;
+			if (UpdateHorizontalScrollBar ()) {
+				items_area.Height -= hscrollbar.Height;
+				if (UpdateVerticalScrollBar ()) {
+					items_area.Width -= vscrollbar.Width;
+					UpdateHorizontalScrollBar ();
+				}
+			} else if (UpdateVerticalScrollBar ()) {
+				items_area.Width -= vscrollbar.Width;
+				if (UpdateHorizontalScrollBar ()) {
+					items_area.Height -= hscrollbar.Height;
+					UpdateVerticalScrollBar ();
+				}
+			}
+
+			RepositionScrollBars ();
+		}
+
+		/* Determines if the horizontal scrollbar has to be displyed */
+		private bool UpdateHorizontalScrollBar ()
+		{
+			bool show = false;
+			bool enabled = true;
+
+			if (MultiColumn) {
+				if (canvas_size.Width > items_area.Width) {
+					show = true;
+					hscrollbar.Maximum  = canvas_size.Width / ColumnWidthInternal - 1;
+				} else if (ScrollAlwaysVisible == true) {
+					enabled = false;
+					show = true;
+					hscrollbar.Maximum  = 0;
+				}
+			} else if (canvas_size.Width > ClientRectangle.Width && HorizontalScrollbar) {
+				show = true;
+				hscrollbar.Maximum = canvas_size.Width;
+				hscrollbar.LargeChange = Math.Max (0, items_area.Width);
+			} else if (scroll_always_visible && horizontal_scrollbar) {
+				show = true;
+				enabled = false;
+				hscrollbar.Maximum = 0;
+			}
+
+			hbar_offset = hscrollbar.Value;
+			hscrollbar.Enabled = enabled;
+			hscrollbar.Visible = show;
+
+			return show;
+		}
+
+		/* Determines if the vertical scrollbar has to be displyed */
+		private bool UpdateVerticalScrollBar ()
+		{
+			if (MultiColumn || (Items.Count == 0 && !scroll_always_visible)) {
+				vscrollbar.Visible = false;
+				return false;
+			} else if (Items.Count == 0) {
+				vscrollbar.Visible = true;
+				vscrollbar.Enabled = false;
+				vscrollbar.Maximum = 0;
+				return true;
+			}
+
+			bool show = false;
+			bool enabled = true;
+			if (canvas_size.Height > items_area.Height) {
+				show = true;
+				vscrollbar.Maximum = Items.Count - 1;
+				vscrollbar.LargeChange = Math.Max (items_area.Height / ItemHeight, 0);
+			} else if (ScrollAlwaysVisible) {
+				show = true;
+				enabled = false;
+				vscrollbar.Maximum = 0;
+			}
+
+			vscrollbar.Enabled = enabled;
+			vscrollbar.Visible = show;
+
+			return show;
+		}
+
+		// Value Changed
+		private void VerticalScrollEvent (object sender, EventArgs e)
+		{
+			int top_item = top_index;
+
+			top_index = /*row_count + */ vscrollbar.Value;
+			last_visible_index = LastVisibleItem ();
+
+			int delta = (top_item - top_index) * ItemHeight;
+			if (DrawMode == DrawMode.OwnerDrawVariable) {
+				delta = 0;
+
+				if (top_index < top_item)
+					for (int i = top_index; i < top_item; i++)
+						delta += GetItemHeight (i);
+				else 
+					for (int i = top_item; i < top_index; i++)
+						delta -= GetItemHeight (i);
+			}
+
+			if (IsHandleCreated)
+				XplatUI.ScrollWindow (Handle, items_area, 0, delta, false);
+		}
+
+		#endregion Private Methods
+
+		public class IntegerCollection : IList, ICollection, IEnumerable
+		{
+			private ListBox owner;
+			private List<int> list;
+			
+			#region Public Constructor
+			public IntegerCollection (ListBox owner)
+			{
+				this.owner = owner;
+				list = new List<int> ();
+			}
+			#endregion
+
+			#region Public Properties
+			[Browsable (false)]
+			public int Count {
+				get { return list.Count; }
+			}
+			
+			public int this [int index] {
+				get { return list[index]; }
+				set { list[index] = value; owner.CalculateTabStops (); }
+			}
+			#endregion
+
+			#region Public Methods
+			public int Add (int item)
+			{
+				// This collection does not allow duplicates
+				if (!list.Contains (item)) {
+					list.Add (item);
+					list.Sort ();
+					owner.CalculateTabStops ();
+				}
+				
+				return list.IndexOf (item);
+			}
+			
+			public void AddRange (int[] items)
+			{
+				AddItems (items);
+			}
+			
+			public void AddRange (IntegerCollection value)
+			{
+				AddItems (value);
+			}
+
+			void AddItems (IList items)
+			{
+				if (items == null)
+					throw new ArgumentNullException ("items");
+
+				foreach (int i in items)
+					if (!list.Contains (i))
+						list.Add (i);
+
+				list.Sort ();
+			}
+
+			public void Clear ()
+			{
+				list.Clear ();
+				owner.CalculateTabStops ();
+			}
+			
+			public bool Contains (int item)
+			{
+				return list.Contains (item);
+			}
+			
+			public void CopyTo (Array destination, int index)
+			{
+				for (int i = 0; i < list.Count; i++)
+					destination.SetValue (list[i], index++);
+			}
+			
+			public int IndexOf (int item)
+			{
+				return list.IndexOf (item);
+			}
+			
+			public void Remove (int item)
+			{
+				list.Remove (item);
+				list.Sort ();
+				owner.CalculateTabStops ();
+			}
+			
+			public void RemoveAt (int index)
+			{
+				if (index < 0)
+					throw new IndexOutOfRangeException ();
+
+				list.RemoveAt (index);
+				list.Sort ();
+				owner.CalculateTabStops ();
+			}
+			#endregion
+
+			#region IEnumerable Members
+			IEnumerator IEnumerable.GetEnumerator ()
+			{
+				return list.GetEnumerator ();
+			}
+			#endregion
+
+			#region IList Members
+			int IList.Add (object item)
+			{
+				int? intValue = item as int?;
+				if (!intValue.HasValue)
+					throw new ArgumentException ("item");
+				return Add (intValue.Value);
+			}
+
+			void IList.Clear ()
+			{
+				Clear ();
+			}
+
+			bool IList.Contains (object item)
+			{
+				int? intValue = item as int?;
+				if (!intValue.HasValue)
+					return false;
+				return Contains (intValue.Value);
+			}
+
+			int IList.IndexOf (object item)
+			{
+				int? intValue = item as int?;
+				if (!intValue.HasValue)
+					return -1;
+				return IndexOf (intValue.Value);
+			}
+
+			void IList.Insert (int index, object value)
+			{
+				throw new NotSupportedException (string.Format (
+					CultureInfo.InvariantCulture, "No items "
+					+ "can be inserted into {0}, since it is"
+					+ " a sorted collection.", this.GetType ()));
+			}
+
+			bool IList.IsFixedSize
+			{
+				get { return false; }
+			}
+
+			bool IList.IsReadOnly
+			{
+				get { return false; }
+			}
+
+			void IList.Remove (object value)
+			{
+				int? intValue = value as int?;
+				if (!intValue.HasValue)
+					throw new ArgumentException ("value");
+
+				Remove (intValue.Value);
+			}
+
+			void IList.RemoveAt (int index)
+			{
+				RemoveAt (index);
+			}
+
+			object IList.this[int index] {
+				get { return this[index]; }
+				set { this[index] = (int)value; }
+			}
+			#endregion
+
+			#region ICollection Members
+			bool ICollection.IsSynchronized {
+				get { return true; }
+			}
+
+			object ICollection.SyncRoot {
+				get { return this; }
+			}
+			#endregion
+		}
+
+		[ListBindable (false)]
+		public class ObjectCollection : IList, ICollection, IEnumerable
+		{
+			internal class ListObjectComparer : IComparer
+			{
+				public int Compare (object a, object b)
+				{
+					string str1 = a.ToString ();
+					string str2 = b.ToString ();
+					return str1.CompareTo (str2);
+				}
+			}
+
+			private ListBox owner;
+			internal ArrayList object_items = new ArrayList ();
+			
+			#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 (ListBox owner)
+			{
+				this.owner = owner;
+			}
+
+			public ObjectCollection (ListBox owner, object[] value)
+			{
+				this.owner = owner;
+				AddRange (value);
+			}
+
+			public ObjectCollection (ListBox owner,  ObjectCollection value)
+			{
+				this.owner = owner;
+				AddRange (value);
+			}
+
+			#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 of out range");
+
+					return object_items[index];
+				}
+				set {
+					if (index < 0 || index >= Count)
+						throw new ArgumentOutOfRangeException ("Index of out range");
+					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));
+
+					owner.CollectionChanged ();
+				}
+			}
+
+			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;
+				object[] selectedItems = null;
+
+				// we need to remember the original selected items so that we can update the indices
+				if (owner.sorted) {
+					selectedItems = new object[owner.SelectedItems.Count];
+					owner.SelectedItems.CopyTo (selectedItems, 0);
+				}
+
+				idx = AddItem (item);
+				owner.CollectionChanged ();
+				
+				// If we are sorted, the item probably moved indexes, get the real one
+				if (owner.sorted) {
+					// update indices of selected items
+					owner.SelectedIndices.Clear ();
+					for (int i = 0; i < selectedItems.Length; i++) {
+						owner.SelectedIndex = this.IndexOf (selectedItems [i]);
+					}
+					return this.IndexOf (item);
+				}
+					
+				return idx;
+			}
+
+			public void AddRange (object[] items)
+			{
+				AddItems (items);
+			}
+
+			public void AddRange (ObjectCollection value)
+			{
+				AddItems (value);
+			}
+
+			internal void AddItems (IList items)
+			{
+				if (items == null)
+					throw new ArgumentNullException ("items");
+
+				foreach (object mi in items)
+					AddItem (mi);
+
+				owner.CollectionChanged ();
+			}
+
+			public virtual void Clear ()
+			{
+				owner.selected_indices.ClearCore ();
+				object_items.Clear ();
+				owner.CollectionChanged ();
+
+				//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 of out range");
+				if (item == null)
+					throw new ArgumentNullException ("item");
+					
+				owner.BeginUpdate ();
+				object_items.Insert (index, item);
+				owner.CollectionChanged ();
+				owner.EndUpdate ();
+				
+				//UIA Framework event: Item Added
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
+			}
+
+			public void Remove (object value)
+			{
+				if (value == null)
+					return;
+
+				int index = IndexOf (value);
+				if (index != -1)
+					RemoveAt (index);
+			}
+
+			public void RemoveAt (int index)
+			{
+				if (index < 0 || index >= Count)
+					throw new ArgumentOutOfRangeException ("Index of out range");
+
+				//UIA Framework element removed
+				object removed = object_items [index];
+				UpdateSelection (index);
+				object_items.RemoveAt (index);
+				owner.CollectionChanged ();
+
+				//UIA Framework event: Item Removed
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, removed));
+			}
+			#endregion Public Methods
+
+			#region Private Methods
+			internal int AddItem (object item)
+			{
+				if (item == null)
+					throw new ArgumentNullException ("item");
+
+				int cnt = object_items.Count;
+				object_items.Add (item);
+
+				//UIA Framework event: Item Added
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
+
+				return cnt;
+			}
+
+			// we receive the index to be removed
+			void UpdateSelection (int removed_index)
+			{
+				owner.selected_indices.Remove (removed_index);
+
+				if (owner.selection_mode != SelectionMode.None) {
+					int last_idx = object_items.Count - 1;
+
+					// if the last item was selected, remove it from selection,
+					// since it will become invalid after the removal
+					if (owner.selected_indices.Contains (last_idx)) {
+						owner.selected_indices.Remove (last_idx);
+
+						// in SelectionMode.One try to put the selection on the new last item
+						int new_idx = last_idx - 1;
+						if (owner.selection_mode == SelectionMode.One && new_idx > -1)
+							owner.selected_indices.Add (new_idx);
+					}
+				}
+
+			}
+
+			internal void Sort ()
+			{
+				object_items.Sort (new ListObjectComparer ());
+			}
+
+			#endregion Private Methods
+		}
+
+		public class SelectedIndexCollection : IList, ICollection, IEnumerable
+		{
+			private ListBox owner;
+			ArrayList selection;
+			bool sorting_needed; // Selection state retrieval is done sorted - we do it lazyly
+
+			#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 SelectedIndexCollection (ListBox owner)
+			{
+				this.owner = owner;
+				selection = new ArrayList ();
+			}
+
+			#region Public Properties
+			[Browsable (false)]
+			public int Count {
+				get { return selection.Count; }
+			}
+
+			public bool IsReadOnly {
+				get { return true; }
+			}
+
+			public int this [int index] {
+				get {
+					if (index < 0 || index >= Count)
+						throw new ArgumentOutOfRangeException ("Index of out range");
+
+					CheckSorted ();
+					return (int)selection [index];
+				}
+			}
+
+			bool ICollection.IsSynchronized {
+				get { return true; }
+			}
+
+			bool IList.IsFixedSize{
+				get { return true; }
+			}
+
+			object ICollection.SyncRoot {
+				get { return selection; }
+			}
+
+			#endregion Public Properties
+
+			#region Public Methods
+			public void Add (int index)
+			{
+				if (AddCore (index)) {
+					owner.OnSelectedIndexChanged (EventArgs.Empty);
+					owner.OnSelectedValueChanged (EventArgs.Empty);
+				}
+			}
+
+			// Need to separate selection logic from events,
+			// since selection changes using keys/mouse handle them their own way
+			internal bool AddCore (int index)
+			{
+				if (selection.Contains (index))
+					return false;
+
+				if (index == -1) // Weird MS behaviour
+					return false;
+				if (index < -1 || index >= owner.Items.Count)
+					throw new ArgumentOutOfRangeException ("index");
+				if (owner.selection_mode == SelectionMode.None)
+					throw new InvalidOperationException ("Cannot call this method when selection mode is SelectionMode.None");
+
+				if (owner.selection_mode == SelectionMode.One && Count > 0) // Unselect previously selected item
+					RemoveCore ((int)selection [0]);
+
+				selection.Add (index);
+				sorting_needed = true;
+				owner.EnsureVisible (index);
+				owner.FocusedItem = index;
+				owner.InvalidateItem (index);
+
+				// UIA Framework event: Selected item added
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, index));
+
+				return true;
+			}
+
+			public void Clear ()
+			{
+				if (ClearCore ()) {
+					owner.OnSelectedIndexChanged (EventArgs.Empty);
+					owner.OnSelectedValueChanged (EventArgs.Empty);
+				}
+			}
+
+			internal bool ClearCore ()
+			{
+				if (selection.Count == 0)
+					return false;
+
+				foreach (int index in selection)
+					owner.InvalidateItem (index);
+
+				selection.Clear ();
+
+				// UIA Framework event: Selected items list updated
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, -1));
+
+				return true;
+			}
+
+			public bool Contains (int selectedIndex)
+			{
+				foreach (int index in selection)
+					if (index == selectedIndex)
+						return true;
+				return false;
+			}
+
+			public void CopyTo (Array destination, int index)
+			{
+				CheckSorted ();
+				selection.CopyTo (destination, index);
+			}
+
+			public IEnumerator GetEnumerator ()
+			{
+				CheckSorted ();
+				return selection.GetEnumerator ();
+			}
+
+			// FIXME: Probably we can avoid sorting when calling
+			// IndexOf (imagine a scenario where multiple removal of items
+			// happens)
+			public void Remove (int index)
+			{
+				// Separate logic from events here too
+				if (RemoveCore (index)) {
+					owner.OnSelectedIndexChanged (EventArgs.Empty);
+					owner.OnSelectedValueChanged (EventArgs.Empty);
+				}
+			}
+
+			internal bool RemoveCore (int index)
+			{
+				int idx = IndexOf (index);
+				if (idx == -1)
+					return false;
+
+				selection.RemoveAt (idx);
+				owner.InvalidateItem (index);
+
+				// UIA Framework event: Selected item removed from selection
+				OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, index));
+
+				return true;
+			}
+
+			int IList.Add (object value)
+			{
+				throw new NotSupportedException ();
+			}
+
+			void IList.Clear ()
+			{
+				throw new NotSupportedException ();
+			}
+
+			bool IList.Contains (object selectedIndex)
+			{
+				return Contains ((int)selectedIndex);
+			}
+
+			int IList.IndexOf (object selectedIndex)
+			{
+				return IndexOf ((int) selectedIndex);
+			}
+
+			void IList.Insert (int index, object value)
+			{
+				throw new NotSupportedException ();
+			}
+
+			void IList.Remove (object value)
+			{
+				throw new NotSupportedException ();
+			}
+
+			void IList.RemoveAt (int index)
+			{
+				throw new NotSupportedException ();
+			}
+
+			object IList.this[int index]{
+				get { return this [index]; }
+				set {throw new NotImplementedException (); }
+			}
+
+			public int IndexOf (int selectedIndex)
+			{
+				CheckSorted ();
+
+				for (int i = 0; i < selection.Count; i++)
+					if ((int)selection [i] == selectedIndex)
+						return i;
+
+				return -1;
+			}
+			#endregion Public Methods
+			internal ArrayList List {
+				get {
+					CheckSorted ();
+					return selection;
+				}
+			}
+
+			void CheckSorted ()
+			{
+				if (sorting_needed) {
+					sorting_needed = false;
+					selection.Sort ();
+				}
+			}
+		}
+
+		public class SelectedObjectCollection : IList, ICollection, IEnumerable
+		{
+			private ListBox owner;
+
+			public SelectedObjectCollection (ListBox owner)
+			{
+				this.owner = owner;
+			}
+
+			#region Public Properties
+			public int Count {
+				get { return owner.selected_indices.Count; }
+			}
+
+			public bool IsReadOnly {
+				get { return true; }
+			}
+
+			[Browsable(false)]
+			//[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+			public object this [int index] {
+				get {
+					if (index < 0 || index >= Count)
+						throw new ArgumentOutOfRangeException ("Index of out range");
+
+					return owner.items [owner.selected_indices [index]];
+				}
+				set {throw new NotSupportedException ();}
+			}
+
+			bool ICollection.IsSynchronized {
+				get { return true; }
+			}
+
+			object ICollection.SyncRoot {
+				get { return this; }
+			}
+
+			bool IList.IsFixedSize {
+				get { return true; }
+			}
+
+			#endregion Public Properties
+
+			#region Public Methods
+			public void Add (object value)
+			{
+				if (owner.selection_mode == SelectionMode.None)
+					throw new ArgumentException ("Cannot call this method if SelectionMode is SelectionMode.None");
+
+				int idx = owner.items.IndexOf (value);
+				if (idx == -1)
+					return;
+
+				owner.selected_indices.Add (idx);
+			}
+
+			public void Clear ()
+			{
+				owner.selected_indices.Clear ();
+			}
+
+			public bool Contains (object selectedObject)
+			{
+				int idx = owner.items.IndexOf (selectedObject);
+				return idx == -1 ? false : owner.selected_indices.Contains (idx);
+			}
+
+			public void CopyTo (Array destination, int index)
+			{
+				for (int i = 0; i < Count; i++)
+					destination.SetValue (this [i], index++);
+			}
+
+			public void Remove (object value)
+			{
+				if (value == null)
+					return;
+
+				int idx = owner.items.IndexOf (value);
+				if (idx == -1)
+					return;
+
+				owner.selected_indices.Remove (idx);
+			}
+
+			int IList.Add (object value)
+			{
+				throw new NotSupportedException ();
+			}
+
+			void IList.Clear ()
+			{
+				throw new NotSupportedException ();
+			}
+
+			void IList.Insert (int index, object value)
+			{
+				throw new NotSupportedException ();
+			}
+
+			void IList.Remove (object value)
+			{
+				throw new NotSupportedException ();
+			}
+
+			void IList.RemoveAt (int index)
+			{
+				throw new NotSupportedException ();
+			}
+	
+			public int IndexOf (object selectedObject)
+			{
+				int idx = owner.items.IndexOf (selectedObject);
+				return idx == -1 ? -1 : owner.selected_indices.IndexOf (idx);
+			}
+
+			public IEnumerator GetEnumerator ()
+			{
+				//FIXME: write an enumerator that uses selection.GetEnumerator
+				//  so that invalidation is write on selection changes
+				object [] items = new object [Count];
+				for (int i = 0; i < Count; i++) {
+					items [i] = owner.items [owner.selected_indices [i]];
+				}
+
+				return items.GetEnumerator ();
+			}
+
+			#endregion Public Methods
+		}
+	}
+}