**** Merged from MCS ****

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

//
// System.Windows.Forms.ListBox.cs
//
// Author:
//   stubbed out by Daniel Carrera (dcarrera@math.toronto.edu)
//   Dennis Hayes (dennish@Raytek.com)
//   Alexandre Pigolkine (pigolkine@gmx.de)
//
// (C) 2002/3 Ximian, Inc
//

//
// 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.
//
using System.Collections;
using System.Drawing;
using System.Runtime.InteropServices;

namespace System.Windows.Forms {

        // <summary>
        // </summary>

        public class ListBox : ListControl {

                //
                //  --- Constructor
                //
                [MonoTODO]
                public ListBox() {
                        SubClassWndProc_ = true;
                        BorderStyle_ = BorderStyle.Fixed3D;
                        BackColor = SystemColors.Window;
                        controlStyles_ |= ControlStyles.AllPaintingInWmPaint; 
                }

                //
                //       --- Protected Fields
                //
                internal int ColumnWidth_ = 0; // The columns will have default width
                internal bool IntegralHeight_ = true;
                internal ListBox.ObjectCollection       Items_ = null;
                internal ListBox.SelectedIndexCollection SelectedIndices_ = null;
                internal ListBox.SelectedObjectCollection SelectedObjects_ = null;
                internal DrawMode DrawMode_ = DrawMode.Normal;
                internal bool UseTabStops_ = false;
                internal bool MultiColumn_ = false;
                int selectedIndex = -1;
                internal bool Sorted_ = false;
                internal int prevSelectedIndex = -1;
                internal BorderStyle    BorderStyle_;
                
                //
                //       --- Public Fields
                //
                public const int DefaultItemHeight = 13;//correct
                public const int NoMatches = -1 ;//correct
                

                //
                //  --- Public Properties
                //
                [MonoTODO]
                public override Color ForeColor {
                        get {
                                //FIXME:
                                return base.ForeColor;
                        }
                        set {
                                //FIXME:
                                base.ForeColor = value;
                        }
                }

                [MonoTODO]
                public override Color BackColor {
                        get {
                                //FIXME:
                                return base.BackColor;
                        }
                        set {
                                //FIXME:
                                base.BackColor = value;
                        }
                }
                [MonoTODO]
                public override Image BackgroundImage {
                        get {
                                //FIXME:
                                return base.BackgroundImage;
                        }
                        set {
                                //FIXME:
                                base.BackgroundImage = value;
                        }
                }

                public BorderStyle BorderStyle {
                        get {
                                return BorderStyle_;                            
                        }
                        set {
                                if( BorderStyle_ != value) {
                                        BorderStyle_ = value;
                                        if( IsHandleCreated) {
                                                
                                        }
                                }
                        }
                }

                [MonoTODO]
                public int HorizontalExtent {
                        get {
                                throw new NotImplementedException ();
                        }
                        set {
                                //Fixme
                        }
                }
                public bool MultiColumn {
                        get {
                                return MultiColumn_;
                        }
                        set {
                                if( MultiColumn_ != value) {
                                        MultiColumn_ = value;
                                        RecreateHandle();
                                }
                        }
                }

                [MonoTODO]
                public override RightToLeft RightToLeft {
                        get {
                                //FIXME:
                                return base.RightToLeft;
                        }
                        set {
                                //FIXME:
                                base.RightToLeft = value;
                        }
                }
                [MonoTODO]
                public bool ScrollAlwaysVisible {
                        get {
                                throw new NotImplementedException ();
                        }
                        set {
                                //FIXME:
                        }
                }

                [MonoTODO]
                public bool HorizontalScrollbar {
                        get {
                                throw new NotImplementedException ();
                        }
                        set {
                                // FIXME
                        }
                }

                [MonoTODO]
                public int PreferredHeight {
                        get {
                                throw new NotImplementedException ();
                        }
                }
                
                [MonoTODO]
                public override int SelectedIndex {
                        get {
                                if( IsHandleCreated) {
                                        return Win32.SendMessage(Handle, (int)ListBoxMessages.LB_GETCURSEL, 0, 0);
                                }
                                else {
                                        return selectedIndex;
                                }
                        }
                        set {
                                prevSelectedIndex = selectedIndex;
                                if( selectedIndex != value) {
                                        //FIXME: set exception parameters
                                        selectedIndex = value;
                                        if( IsHandleCreated) {
                                                Win32.SendMessage(Handle, (int)ListBoxMessages.LB_SETCURSEL, selectedIndex, 0);
                                        }
                                        OnSelectedIndexChanged(new EventArgs());
                                }
                        }
                }
                
                [MonoTODO]
                public ListBox.SelectedIndexCollection SelectedIndices {
                        get {
                                if( SelectedIndices_ == null) {
                                        SelectedIndices_ = new ListBox.SelectedIndexCollection(this);
                                }
                                return SelectedIndices_;
                        }
                }
                [MonoTODO]
                public object SelectedItem {
                        get {
                                throw new NotImplementedException ();
                        }
                        set {
                                //FIXME:
                        }
                }
                [MonoTODO]
                public ListBox.SelectedObjectCollection SelectedItems {
                        get {
                                if( SelectedObjects_ == null) {
                                        SelectedObjects_ = new ListBox.SelectedObjectCollection(this);
                                }
                                return SelectedObjects_;
                        }
                }
                [MonoTODO]
                public virtual SelectionMode SelectionMode {
                        get {
                                throw new NotImplementedException ();
                        }
                        set {
                                //FIXME:
                        }
                }
                [MonoTODO]
                public bool Sorted {
                        get {
                                return Sorted_;
                        }
                        set {
                                if( Sorted_ != value){
                                        Sorted_ = value;
                                        if( Sorted_) {
                                                Items_.SwitchToSortedStyle();
/*                                              
                                                object[] items = new object[Items.Count];
                                                Items.CopyTo(items, 0);
                                                Items.Clear();
                                                Items.AddRange(items);
*/
                                        }
                                }
                        }
                }
                [MonoTODO]
                public override string Text {
                        get {
                                return base.Text;
                        }
                        set {
                                base.Text = value;
                        }
                }
                [MonoTODO]
                public int TopIndex {
                        get {
                                throw new NotImplementedException ();
                        }
                        set {
                                //FIXME:
                        }
                }
                [MonoTODO]
                public bool UseTabStops {
                        get {
                                return UseTabStops_;
                        }
                        set {
                                UseTabStops_ = value;
                        }
                }

                [MonoTODO]
                public virtual DrawMode DrawMode {
                        get {
                                return DrawMode_;
                        }
                        set {
                                DrawMode_ = value;
                                // FIXME: change styles of Windows control/ recreate control
                        }
                }

                public int ColumnWidth {
                        get {
                                return ColumnWidth_;
                        }
                        set {
                                ColumnWidth_ = value;
                        }
                }
                
                [MonoTODO]
                public virtual int ItemHeight {
                        get {
                                throw new NotImplementedException ();
                        }
                        set {
                                //FIXME:
                        }
                }
                public bool IntegralHeight {
                        get {
                                return IntegralHeight_;
                        }
                        set {
                                IntegralHeight_ = value;
                        }
                }
                
                public ListBox.ObjectCollection Items {
                        get {
                                if( Items_ == null) {
                                        Items_ = CreateItemCollection();
                                }
                                return Items_;
                        }
                }
                
                internal virtual void OnObjectCollectionChanged() {
                        SelectedIndices_ = null;
                }
                
                //
                //  --- Public Methods
                //
                [MonoTODO]
                public void BeginUpdate() {
                        //FIXME:
                }
                [MonoTODO]
                public void ClearSelected() {
                        //FIXME:
                }
                [MonoTODO]
                public void EndUpdate() {
                        //FIXME:
                }
                [MonoTODO]
                public int FindString(string s) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public int FindString(string s, int startIndex) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public int FindStringExact(string s) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public int FindStringExact(string s, int startIndex) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public int GetItemHeight(int index) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public Rectangle GetItemRectangle(int index) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public bool GetSelected(int index) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public int IndexFromPoint(Point p) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public int IndexFromPoint(int x, int y) {
                        throw new NotImplementedException ();
                }
                [MonoTODO]
                public void SetSelected(int index, bool value) {
                        //FIXME:
                }
                [MonoTODO]
                public override string ToString() {
                        //FIXME:
                        return base.ToString();
                }

                //
                //  --- Public Events
                //
                [MonoTODO]
                public event DrawItemEventHandler DrawItem;
                [MonoTODO]
                public event MeasureItemEventHandler MeasureItem;
                public event EventHandler SelectedIndexChanged;
                //
                //  --- Protected Properties
                //
                [MonoTODO]
                protected override CreateParams CreateParams {
                        get {
                                        CreateParams createParams = base.CreateParams;
                                        createParams.ClassName = "LISTBOX";
                                        createParams.ExStyle = (int)WindowExStyles.WS_EX_CLIENTEDGE;
                                        createParams.Style = (int) (
                                                WindowStyles.WS_CHILD | 
                                                WindowStyles.WS_VISIBLE |
                                                WindowStyles.WS_CLIPSIBLINGS);
                                        createParams.Style |= (int) (ListBoxStyles.LBS_NOTIFY | 
                                                ListBoxStyles.LBS_HASSTRINGS );
                                        if( !IntegralHeight_) {
                                                createParams.Style |= (int)ListBoxStyles.LBS_NOINTEGRALHEIGHT;
                                        }
                                        if( UseTabStops_ ) {
                                                createParams.Style |= (int)ListBoxStyles.LBS_USETABSTOPS;
                                        }
                                        switch( DrawMode_){
                                                case DrawMode.OwnerDrawFixed:
                                                        createParams.Style |= (int)ListBoxStyles.LBS_OWNERDRAWFIXED;
                                                        break;
                                                case DrawMode.OwnerDrawVariable:
                                                        createParams.Style |= (int)ListBoxStyles.LBS_OWNERDRAWVARIABLE;
                                                        break;
                                        }
                                        if( MultiColumn_) {
                                                createParams.Style |= (int)ListBoxStyles.LBS_MULTICOLUMN | (int)WindowStyles.WS_HSCROLL;
                                        }
                                        else {
                                                createParams.Style |= (int)WindowStyles.WS_VSCROLL;
                                        }
                                        return createParams;
                        }               
                }

                [MonoTODO]
                protected override Size DefaultSize {
                        get {
                                return new Size(120,95);
                        }
                }

                //
                //  --- Protected Methods
                //

                [MonoTODO]
                protected virtual void AddItemsCore(object [] value) {
                        //Fixme
                }

                [MonoTODO]
                protected virtual ObjectCollection CreateItemCollection() {
                        return new ListBox.ObjectCollection( this);
                }

                [MonoTODO]
                protected override void OnChangeUICues(UICuesEventArgs e) {
                        //FIXME:
                        base.OnChangeUICues(e);
                }
                [MonoTODO]
                protected override void OnDataSourceChanged(EventArgs e) {
                        //FIXME:
                        base.OnDataSourceChanged(e);
                }
                [MonoTODO]
                protected override void OnDisplayMemberChanged(EventArgs e) {
                        //FIXME:
                        base.OnDisplayMemberChanged(e);
                }

                [MonoTODO]
                protected virtual void OnDrawItem(DrawItemEventArgs e) {
                        if( DrawItem != null) {
                                DrawItem(this, e);
                        }
                }

                [MonoTODO]
                protected override void OnFontChanged(EventArgs e) {
                        //FIXME:
                        base.OnFontChanged(e);
                }
                [MonoTODO]
                protected override void OnHandleCreated(EventArgs e) {
                        //FIXME:
                        base.OnHandleCreated(e);
                        if( Items_ != null) {
                                Items_.PopulateControl();
                        }
                        if( ColumnWidth_ != 0 && MultiColumn_) {
                                Win32.SendMessage( Handle, (int)ListBoxMessages.LB_SETCOLUMNWIDTH, ColumnWidth_, 0);
                        }
                        
                }
                [MonoTODO]
                protected override void OnHandleDestroyed(EventArgs e) {
                        //FIXME:
                        base.OnHandleDestroyed(e);
                }

                [MonoTODO]
                protected virtual void OnMeasureItem(MeasureItemEventArgs e) {
                        if( MeasureItem != null) {
                                MeasureItem(this, e);
                        }
                }

                [MonoTODO]
                protected override void OnParentChanged(EventArgs e) {
                        //FIXME:
                        base.OnParentChanged(e);
                }
                [MonoTODO]
                protected override void OnResize(EventArgs e) {
                        //FIXME:
                        base.OnResize(e);
                }
                [MonoTODO]
                protected override void OnSelectedIndexChanged(EventArgs e) {
                        //FIXME:
                        base.OnSelectedIndexChanged(e);
                        if( SelectedIndexChanged != null) {
                                SelectedIndexChanged(this, e);
                        }
                }

                [MonoTODO]
                protected override void OnSelectedValueChanged(EventArgs e) {
                        //FIXME:
                        base.OnSelectedValueChanged(e);
                }

                protected override void RefreshItem(int index) {
                        //FIXME:
                }

                public override void Refresh() { // .NET V1.1 Beta
                        base.Refresh();
                }
                
                [MonoTODO]
                protected override void SetBoundsCore( int x, int y,  int width, int height,  BoundsSpecified specified) {
                        //FIXME:
                        base.SetBoundsCore(x, y, width, height, specified);
                }

                [MonoTODO]
                protected override void SetItemCore (int index, object value) {
                        //FIXME:
                }

                protected override void SetItemsCore (IList value){
                }

                [MonoTODO]
                protected virtual void Sort() {
                        //FIXME:
                }

                protected virtual void WmReflectCommand(ref Message m){
                        throw new NotImplementedException ();
                }
                
                [MonoTODO]
                protected override void WndProc(ref Message m) {
                        switch ((Msg) m.Msg) {
                                case Msg.WM_MEASUREITEM: {
                                        MEASUREITEMSTRUCT mis = new MEASUREITEMSTRUCT();
                                        mis = (MEASUREITEMSTRUCT)Marshal.PtrToStructure(m.LParam, mis.GetType());
                                        MeasureItemEventArgs args = new MeasureItemEventArgs(CreateGraphics(),mis.itemID);
                                        args.ItemHeight = mis.itemHeight;
                                        args.ItemWidth = mis.itemWidth;
                                        OnMeasureItem( args);
                                        mis.itemHeight = args.ItemHeight;
                                        mis.itemWidth = args.ItemWidth;
                                        Marshal.StructureToPtr(mis, m.LParam, false);
                                        m.Result = (IntPtr)1;
                                        }
                                        break;
                                case Msg.WM_DRAWITEM: {
                                        DRAWITEMSTRUCT dis = new DRAWITEMSTRUCT();
                                        dis = (DRAWITEMSTRUCT)Marshal.PtrToStructure(m.LParam, dis.GetType());
                                        Rectangle       rect = new Rectangle(dis.rcItem.left, dis.rcItem.top, dis.rcItem.right - dis.rcItem.left, dis.rcItem.bottom - dis.rcItem.top);
                                        DrawItemEventArgs args = new DrawItemEventArgs(Graphics.FromHdc(dis.hDC), Font,
                                                rect, dis.itemID, (DrawItemState)dis.itemState);
                                        OnDrawItem( args);
                                        //Marshal.StructureToPtr(dis, m.LParam, false);
                                        m.Result = (IntPtr)1;
                                        }
                                        break;
                                case Msg.WM_COMMAND: 
                                        switch(m.HiWordWParam) {
                                                case (uint)ListBoxNotifications.LBN_SELCHANGE:
                                                        SelectedIndex = Win32.SendMessage(Handle, (int)ListBoxMessages.LB_GETCURSEL, 0, 0);
                                                        m.Result = IntPtr.Zero;
                                                        CallControlWndProc(ref m);
                                                        break;
                                                default:
                                                        CallControlWndProc(ref m);
                                                        break;
                                        }
                                        break;
                                default:
                                        base.WndProc(ref m);
                                        break;
                        }
                }

                //
                // <summary>
                // This is a subclass
                // </summary>

                public class SelectedObjectCollection :  IList, ICollection, IEnumerable {

                        ArrayList   collection_;
                        ListBox         owner_;
                        //
                        //  --- Constructor
                        //
                        [MonoTODO]
                        public SelectedObjectCollection(ListBox owner) {
                                owner_ = owner;
                                collection_ = owner_.Items.CreateSelectedObjectsList();
                        }

                        //
                        //  --- Public Properties
                        //
                        [MonoTODO]
                        public int Count {
                                get {
                                        return collection_.Count;
                                }
                        }
                        [MonoTODO]
                        public bool IsReadOnly {
                                get {
                                        return true;
                                }
                        }
                        [MonoTODO]
                        public object this[int index] {
                                get {
                                        return collection_[index];
                                }
                                set {
                                        //FIXME:
                                }
                        }

                        //
                        //  --- Public Methods
                        //
                        [MonoTODO]
                        public bool Contains(object selectedObject) {
                                return collection_.Contains(selectedObject);;
                        }
                        [MonoTODO]
                        public void CopyTo(Array dest, int index) {
                                collection_.CopyTo(dest, index);
                        }
                        [MonoTODO]
                        public override bool Equals(object obj) {
                                //FIXME:
                                return base.Equals(obj);
                        }
                        [MonoTODO]
                        public override int GetHashCode() {
                                //FIXME add our proprities
                                return base.GetHashCode();
                        }
                        [MonoTODO]
                        public IEnumerator GetEnumerator() {
                                return collection_.GetEnumerator();
                        }
                        [MonoTODO]
                        public int IndexOf(object selectedObject) {
                                return collection_.IndexOf(selectedObject);
                        }
                        /// <summary>
                        /// IList Interface implmentation.
                        /// </summary>
                        bool IList.IsReadOnly{
                                get{
                                        // We allow addition, removeal, and editing of items after creation of the list.
                                        return false;
                                }
                        }
                        bool IList.IsFixedSize{
                                get{
                                        // We allow addition and removeal of items after creation of the list.
                                        return false;
                                }
                        }

                        //[MonoTODO]
#if A
                        object IList.this[int index]{
                                get{
                                        throw new NotImplementedException ();
                                }
                                set{
                                        throw new NotImplementedException ();
                                }
                        }
#endif
                
                        [MonoTODO]
                        void IList.Clear(){
                                //FIXME:
                        }
                
                        [MonoTODO]
                        int IList.Add( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        bool IList.Contains( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        int IList.IndexOf( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        void IList.Insert(int index, object value){
                                //FIXME:
                        }

                        [MonoTODO]
                        void IList.Remove( object value){
                                //FIXME:
                        }

                        [MonoTODO]
                        void IList.RemoveAt( int index){
                                //FIXME:
                        }
                        // End of IList interface
                        /// <summary>
                        /// ICollection Interface implmentation.
                        /// </summary>
                        int ICollection.Count{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        bool ICollection.IsSynchronized{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        object ICollection.SyncRoot{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        void ICollection.CopyTo(Array array, int index){
                                throw new NotImplementedException ();
                        }
                        // End Of ICollection
                }//End of subclass

                // <summary>
                // </summary>

                public class ObjectCollection : IList, ICollection {

                        internal class ListBoxItem {
                                public object theData_ = null;
                                public string dataRepresentation_ = String.Empty;
                                // FIXME: change those fields to flags
                                //public bool wasSorted_ = false;
                                //public bool wasAddedToControl_ = false;
                                public bool IsAddedToControl_ = false;
                                public bool Selected_ = false;
                                public bool Checked_ = false;
                                
                                public ListBoxItem( object data, string representation) {
                                        theData_ = data;
                                        dataRepresentation_ = representation;
                                }
                        }
                        
                        internal class ListItemRepresentationComparer : IComparer {
                                public ListItemRepresentationComparer() {
                                }
        
                                public int Compare(object x, object y) {
                                        ListBoxItem left = x as ListBoxItem;
                                        ListBoxItem right = y as ListBoxItem;
                                        if( left == null || right == null) {
                                                throw new ArgumentException();
                                        }
                                        return left.dataRepresentation_.CompareTo(right.dataRepresentation_);
                                }
                        }
/*
                        internal class ListItemDataComparer : IComparer {
                                public ListItemDataComparer() {
                                }
        
                                public int Compare(object x, object y) {
                                        ListBoxItem left = x as ListBoxItem;
                                        ListBoxItem right = y as ListBoxItem;
                                        if( left == null || right == null) {
                                                throw new ArgumentException();
                                        }
                                        return left.theData_.CompareTo(right.dataRepresentation_);
                                }
                        }
*/                      
                        internal ArrayList CreateSelectedIndicesList() {
                                ArrayList result = new ArrayList();
                                int ordinalNumber = 0;
                                foreach( ListBoxItem lbi in items_) {
                                        if( lbi.Selected_) {
                                                result.Add(ordinalNumber);      
                                        }
                                        ++ordinalNumber;
                                }
                                return result;
                        }
                        
                        internal ArrayList CreateSelectedObjectsList() {
                                ArrayList result = new ArrayList();
                                foreach( ListBoxItem lbi in items_) {
                                        if( lbi.Selected_) {
                                                result.Add(lbi.theData_);       
                                        }
                                }
                                return result;
                        }
                        
                        internal ArrayList CreateCheckedIndexList() {
                                ArrayList result = new ArrayList();
                                int ordinalNumber = 0;
                                foreach( ListBoxItem lbi in items_) {
                                        if( lbi.Checked_) {
                                                result.Add(ordinalNumber);      
                                        }
                                        ++ordinalNumber;
                                }
                                return result;
                        }
                        
                        internal ArrayList CreateCheckedItemList() {
                                ArrayList result = new ArrayList();
                                foreach( ListBoxItem lbi in items_) {
                                        if( lbi.Checked_) {
                                                result.Add(lbi.theData_);       
                                        }
                                }
                                return result;
                        }
                        
                        internal ListBoxItem getItemAt(int index) {
                                return (ListBoxItem)items_[index];
                        }
                        
                        internal void SwitchToSortedStyle() {
                                if( owner_.IsHandleCreated) {
                                        Win32.SendMessage(owner_.Handle, (int)ListBoxMessages.LB_RESETCONTENT, 0, 0);
                                }
                                items_.Sort(new ListItemRepresentationComparer());
                                if( owner_.IsHandleCreated) {
                                        foreach( ListBoxItem lbi in items_) {
                                                Win32.SendMessage(owner_.Handle, (int)ListBoxMessages.LB_ADDSTRING, 0, lbi.dataRepresentation_);
                                        }
                                }
                                owner_.OnObjectCollectionChanged();
                        }
                        
                        internal void PopulateControl() {
                                foreach( ListBoxItem lbi in items_) {
                                        Win32.SendMessage(owner_.Handle, (int)ListBoxMessages.LB_ADDSTRING, 0, lbi.dataRepresentation_);
                                        lbi.IsAddedToControl_ = true;
                                }
                        }
                        
                        internal void DumpItems() {
                                int ordinalNumber = 0;
                                foreach( ListBoxItem lbi in items_) {
                                        Console.WriteLine("ListBoxItem {0} order {1} checked {2}", lbi.dataRepresentation_,
                                                          ordinalNumber, lbi.Checked_);
                                        ++ordinalNumber;                                        
                                }
                        }
                        
                        internal class ListBoxItemEnumerator : IEnumerator {
                                private IEnumerator containerEnum_ = null;
                                
                                public ListBoxItemEnumerator( IEnumerator containerEnum) {
                                        containerEnum_ = containerEnum;
                                }
                                
                                public object Current {
                                        get {
                                                return ((ListBoxItem)containerEnum_.Current).theData_;
                                        }
                                }
                                
                                public bool MoveNext() {
                                        return containerEnum_.MoveNext();
                                }
                                
                                public void Reset() {
                                        containerEnum_.Reset();
                                }
                        }
                        
                        
                        protected ListBox owner_ = null;
                        protected ArrayList items_ = new ArrayList(); // has ListBoxItem
                        
                        //
                        //  --- Constructor
                        //
                        [MonoTODO]
                        public ObjectCollection(ListBox box) {
                                owner_ = box;
                        }
                        [MonoTODO]
                        public ObjectCollection(ListBox box, object[] objs) {
                                owner_ = box;
                                AddRange(objs);
                        }

                        //
                        //  --- Public Properties
                        //
                        [MonoTODO]
                        public int Count {
                                get {
                                        return items_.Count;
                                }
                        }
                        [MonoTODO]
                        public bool IsReadOnly {
                                get {
                                        // FIXME: Is it always not ReadOnly
                                        return false;
                                }
                        }
                        [MonoTODO]
                        public virtual object this[int index] {
                                get {
                                        return ((ListBoxItem)items_[index]).theData_;
                                }
                                set {
                                        ((ListBoxItem)items_[index]).theData_ = value;
                                        // FIXME: assing representation and sort if needed
                                }
                        }

                        //
                        //  --- Public Methods
                        //
                        [MonoTODO]
                        public int Add(object item) {
                                string representation = owner_.getDisplayMemberOfObj(item);
                                ListBoxItem  newItem = new ListBoxItem(item, representation);
                                int result = items_.Add(newItem);
                                if( owner_.Sorted) {
                                        items_.Sort(new ListItemRepresentationComparer());
                                        result = items_.BinarySearch(newItem);
                                        if( owner_.IsHandleCreated) {
                                                Win32.SendMessage(owner_.Handle, (int)ListBoxMessages.LB_INSERTSTRING, result, representation);
                                        }
                                        owner_.OnObjectCollectionChanged();
                                }                                       
                                else {
                                        if( owner_.IsHandleCreated) {
                                                Win32.SendMessage(owner_.Handle, (int)ListBoxMessages.LB_ADDSTRING, 0, representation);
                                        }
                                }
                                newItem.IsAddedToControl_ = true;
                                return result;
                        }
                        
                        [MonoTODO]
                        public void AddRange(object[] items) {
                                if( items == null) throw new ArgumentException();
                                ListBoxItem[] newItems = new ListBoxItem[items.Length];
                                int idx = 0;
                                foreach( object obj in items ) {
                                        newItems[idx] = new ListBoxItem(obj, owner_.getDisplayMemberOfObj(obj));
                                        ++idx;
                                }
                                items_.AddRange(newItems);
                                if( owner_.Sorted) {
                                        items_.Sort(new ListItemRepresentationComparer());
                                        if( owner_.IsHandleCreated) {
                                                int index = 0;
                                                foreach( ListBoxItem lbi in items_) {
                                                        if(!lbi.IsAddedToControl_){
                                                                Win32.SendMessage(owner_.Handle, (int)ListBoxMessages.LB_INSERTSTRING, index, lbi.dataRepresentation_);
                                                        }
                                                        ++index;
                                                }
                                        }
                                        owner_.OnObjectCollectionChanged();
                                }
                                else {
                                        if( owner_.IsHandleCreated) {
                                                foreach(ListBoxItem lbi in newItems) {
                                                        Win32.SendMessage(owner_.Handle, (int)ListBoxMessages.LB_ADDSTRING, 0, lbi.dataRepresentation_);
                                                        lbi.IsAddedToControl_ = true;
                                                }
                                        }
                                }
                                // FIXME: Add items to control
                        }
                        [MonoTODO]
                        public void AddRange(ListBox.ObjectCollection collection) {
                                //FIXME:
                        }
                        [MonoTODO]
                        public void Clear() {
                                //FIXME:
                                items_.Clear();
                                if( owner_.IsHandleCreated) {
                                        Win32.SendMessage(owner_.Handle, (int)ListBoxMessages.LB_RESETCONTENT, 0, 0);
                                }
                                owner_.OnObjectCollectionChanged();
                        }
                        [MonoTODO]
                        public bool Contains(object value) {
                                // FIXME: determine whether some of ListBoxItem has value as theData_
                                foreach( ListBoxItem lbi in items_) {
                                        if( lbi.theData_ == value) {
                                                return true;
                                        }
                                }
                                return false;
                        }
                        [MonoTODO]
                        public void CopyTo(object[] dest, int arrayIndex) {
                                // FIXME: copy theData_ from ListBoxItem, not the ListBoxItems
                                items_.CopyTo(dest, arrayIndex);
                        }
                        [MonoTODO]
                        public override bool Equals(object obj) {
                                //FIXME:
                                return base.Equals(obj);
                        }
                        [MonoTODO]
                        public override int GetHashCode() {
                                //FIXME add our proprities
                                return base.GetHashCode();
                        }
                        [MonoTODO]
                        public IEnumerator GetEnumerator() {
                                return new ListBoxItemEnumerator(items_.GetEnumerator());
                        }
                        [MonoTODO]
                        public int IndexOf(object val) {
                                // FIXME: find ListBoxItem object which has the val as theData_
                                int result = -1;
                                int index = 0;
                                foreach( ListBoxItem lbi in items_) {
                                        if( lbi.theData_ == val) {
                                                result = index;
                                                break;
                                        }
                                        ++index;
                                }
                                return result;
                        }
                        [MonoTODO]
                        public void Insert(int index, object item) {
                                //FIXME:
                        }
                        [MonoTODO]
                        public void Remove(object val) {
                                // FIXME: use some sort of Comparer ?
                                int pos = 0;
                                foreach(ListBoxItem lbi in items_) {
                                        if( lbi.theData_ == val) {
                                                RemoveAt(pos);
                                                break;
                                        }
                                        ++pos;
                                }
                        }
                        [MonoTODO]
                        public void RemoveAt(int index) {
                                if( index < 0 || index >= items_.Count) {
                                        //FIXME: set exception parameters
                                        throw new ArgumentOutOfRangeException();
                                }
                                items_.RemoveAt(index);
                                if( owner_.IsHandleCreated) {
                                        Win32.SendMessage( owner_.Handle, (int)ListBoxMessages.LB_DELETESTRING, index, 0); 
                                }
                                owner_.OnObjectCollectionChanged();
                        }
                        /// <summary>
                        /// IList Interface implmentation.
                        /// </summary>
                        bool IList.IsReadOnly{
                                get{
                                        // We allow addition, removeal, and editing of items after creation of the list.
                                        return false;
                                }
                        }
                        bool IList.IsFixedSize{
                                get{
                                        // We allow addition and removeal of items after creation of the list.
                                        return false;
                                }
                        }

#if A
                        //[MonoTODO]
                        object IList.this[int index]{
                                get{
                                        throw new NotImplementedException ();
                                }
                                set{
                                        throw new NotImplementedException ();
                                }
                        }
#endif
                
                        [MonoTODO]
                        void IList.Clear(){
                                //FIXME:
                        }
                
                        [MonoTODO]
                        int IList.Add( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        bool IList.Contains( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        int IList.IndexOf( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        void IList.Insert(int index, object value){
                                //FIXME:
                        }

                        [MonoTODO]
                        void IList.Remove( object value){
                                //FIXME:
                        }

                        [MonoTODO]
                        void IList.RemoveAt( int index){
                                //FIXME:
                        }
                        // End of IList interface
                        /// <summary>
                        /// ICollection Interface implmentation.
                        /// </summary>
                        int ICollection.Count{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        bool ICollection.IsSynchronized{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        object ICollection.SyncRoot{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        void ICollection.CopyTo(Array array, int index){
                                throw new NotImplementedException ();
                        }
                        // End Of ICollection
                }//end of SubClass

                // <summary>
                // </summary>

                public class SelectedIndexCollection :  IList, ICollection, IEnumerable {

                        ArrayList   collection_;
                        ListBox         owner_;
                        
                        //
                        //  --- Constructor
                        //
                        [MonoTODO]
                        public SelectedIndexCollection(ListBox owner) {
                                owner_ = owner;
                                collection_ = owner_.Items.CreateSelectedIndicesList();
                        }

                        //
                        //  --- Public Properties
                        //
                        [MonoTODO]
                        public int Count {
                                get {
                                        return collection_.Count;
                                }
                        }
                        [MonoTODO]
                        public bool IsReadOnly {
                                get {
                                        return true;
                                }
                        }
                        [MonoTODO]
                        public int this[int index] {
                                get {
                                        return (int)collection_[index];
                                }
                        }

                        //
                        //  --- Public Methods
                        //
                        [MonoTODO]
                        public bool Contains(int selectedIndex) {
                                return collection_.Contains(selectedIndex);
                        }
                        [MonoTODO]
                        public void CopyTo(Array dest, int index) {
                                collection_.CopyTo(dest, index);
                        }
                        [MonoTODO]
                        public override bool Equals(object obj) {
                                //FIXME:
                                return base.Equals(obj);
                        }
                        [MonoTODO]
                        public override int GetHashCode() {
                                //FIXME add our proprities
                                return base.GetHashCode();
                        }
                        [MonoTODO]
                        public IEnumerator GetEnumerator() {
                                return collection_.GetEnumerator();
                        }
                        /// <summary>
                        /// IList Interface implmentation.
                        /// </summary>
                        bool IList.IsReadOnly{
                                get{
                                        // We allow addition, removeal, and editing of items after creation of the list.
                                        return false;
                                }
                        }
                        bool IList.IsFixedSize{
                                get{
                                        // We allow addition and removeal of items after creation of the list.
                                        return false;
                                }
                        }

                        //[MonoTODO]
                        object IList.this[int index]{
                                get{
                                        throw new NotImplementedException ();
                                }
                                set{
                                        //FIXME:
                                }
                        }
                
                        [MonoTODO]
                        void IList.Clear(){
                                //FIXME:
                        }
                
                        [MonoTODO]
                        int IList.Add( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        bool IList.Contains( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        int IList.IndexOf( object value){
                                throw new NotImplementedException ();
                        }

                        [MonoTODO]
                        void IList.Insert(int index, object value){
                                //FIXME:
                        }

                        [MonoTODO]
                        void IList.Remove( object value){
                                //FIXME:
                        }

                        [MonoTODO]
                        void IList.RemoveAt( int index){
                                throw new NotImplementedException ();
                        }
                        // End of IList interface
                        /// <summary>
                        /// ICollection Interface implmentation.
                        /// </summary>
                        int ICollection.Count{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        bool ICollection.IsSynchronized{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        object ICollection.SyncRoot{
                                get{
                                        throw new NotImplementedException ();
                                }
                        }
                        void ICollection.CopyTo(Array array, int index){
                                throw new NotImplementedException ();
                        }
                        // End Of ICollection

                }//End of subclass

                

        }
}