mcs/class/System.Windows.Forms/Gtk/ListBox.cs

   1 //
   2 //                      System.Windows.Forms.ListBox
   3 //
   4 //                      Authors:
   5 //                              Joel Basson             (jstrike@mweb.co.za)
   6 //                              Alberto Fernandez       (infjaf00@yahoo.es)
   7 //
   8 //
   9
  10 using System.ComponentModel;
  11 using System;
  12 using System.Collections;
  13 using System.Drawing;
  14 using Gtk;
  15 using GtkSharp;
  16 using GLib;
  17
  18
  19
  20
  21
  22 namespace System.Windows.Forms
  23 {
  24         public class ListBox : ListControl
  25         {
  26                 private ListBox.ObjectCollection items;
  27                 private ListBox.SelectedIndexCollection selectedIndices;
  28                 private ListBox.SelectedObjectCollection selectedItems;
  29                 private bool sorted;
  30
  31
  32                 public const int DefaultItemHeight = 13;
  33                 public const int NoMatches = -1;
  34
  35                 [MonoTODO]
  36                 public ListBox () : base ()
  37                 {
  38                         items = new ListBox.ObjectCollection (this);
  39                         selectedIndices = new ListBox.SelectedIndexCollection (this);
  40                         selectedItems = new ListBox.SelectedObjectCollection (this);
  41                 }
  42
  43
  44                 [MonoTODO]
  45                 public override Color BackColor {
  46                         get { throw new NotImplementedException(); }
  47                         set { }
  48                 }
  49                 [MonoTODO]
  50                 public override System.Drawing.Image BackgroundImage {
  51                         get { throw new NotImplementedException (); }
  52                         set {  }
  53                 }
  54                 [MonoTODO]
  55                 // Don't use ?
  56                 public BorderStyle BorderStyle {
  57                         get { throw new NotImplementedException (); }
  58                         set {  }
  59                 }
  60                 [MonoTODO]
  61                 // Default is 0
  62                 public int ColumnWidth {
  63                         get{ throw new NotImplementedException (); }
  64                         set {
  65                                 if (value < 0)
  66                                         throw new ArgumentException ("ColumnWidth must be equal or greather than 0");
  67                                 if (value == 0){
  68                                         // Default value ??
  69                                 }
  70                                 else {
  71                                 }
  72                         }
  73                 }
  74                 [MonoTODO]
  75                 protected override CreateParams CreateParams {
  76                         get { throw new NotImplementedException (); }
  77                 }
  78                 protected override Size DefaultSize {
  79                         get { return new Size (120,96); }
  80                 }
  81                 [MonoTODO]
  82                 // Default = DrawMode.Normal
  83                 public virtual DrawMode DrawMode {
  84                         get { return DrawMode.Normal; }
  85                         set {
  86                                 if (! Enum.IsDefined (typeof (DrawMode), value))
  87                                         throw new InvalidEnumArgumentException  ("");
  88                                 throw new NotImplementedException();
  89                         }
  90                 }
  91                 [MonoTODO]
  92                 public override Color ForeColor {
  93                         get { throw new NotImplementedException (); }
  94                         set { }
  95                 }
  96                 [MonoTODO]
  97                 // Defaults to 0.
  98                 public int HorizontalExtent {
  99                         get { throw new NotImplementedException (); }
 100                         set { throw new NotImplementedException (); }
 101                 }
 102                 [MonoTODO]
 103                 public bool HorizontalScrollbar {
 104                         get { throw new NotImplementedException (); }
 105                         set {  }
 106                 }
 107                 [MonoTODO]
 108                 public bool IntegralHeight {
 109                         get { throw new NotImplementedException (); }
 110                         set {  }
 111                 }
 112                 [MonoTODO]
 113                 public virtual int ItemHeight {
 114                         get { throw new NotImplementedException (); }
 115                         set {  }
 116                 }
 117                 [MonoTODO]
 118                 public ListBox.ObjectCollection Items {
 119                         get { return items; }
 120                 }
 121                 [MonoTODO]
 122                 // Default false.
 123                 public bool MultiColumn {
 124                         get { return false; }
 125                         set { }
 126                 }
 127                 [MonoTODO]
 128                 public int PreferredHeight {
 129                         get { throw new NotImplementedException (); }
 130                 }
 131                 [MonoTODO]
 132                 public override RightToLeft RightToLeft {
 133                         get { throw new NotImplementedException (); }
 134                         set {  }
 135                 }
 136                 [MonoTODO]
 137                 public bool ScrollAlwaysVisible {
 138                         get { throw new NotImplementedException (); }
 139                         set {  }
 140                 }
 141                 [MonoTODO]
 142                 public override int SelectedIndex {
 143                         get { throw new NotImplementedException (); }
 144                         set { throw new NotImplementedException (); }
 145                 }
 146                 [MonoTODO]
 147                 public ListBox.SelectedIndexCollection SelectedIndices {
 148                         get { return selectedIndices; }
 149                 }
 150                 [MonoTODO]
 151                 public object SelectedItem {
 152                         get { throw new NotImplementedException (); }
 153                         set { throw new NotImplementedException (); }
 154                 }
 155                 [MonoTODO]
 156                 public ListBox.SelectedObjectCollection SelectedItems {
 157                         get { return selectedItems; }
 158                 }
 159                 [MonoTODO]
 160                 public virtual SelectionMode SelectionMode {
 161                         get { throw new NotImplementedException (); }
 162                         set { }
 163                 }
 164                 [MonoTODO]
 165                 public bool Sorted {
 166                         get { return sorted; }
 167                         set {
 168                                 if (value == true)
 169                                         this.Sort();
 170                                 sorted = value;
 171                         }
 172                 }
 173                 [MonoTODO]
 174                 public override string Text {
 175                         get { throw new NotImplementedException (); }
 176                         set { throw new NotImplementedException (); }
 177                 }
 178                 [MonoTODO]
 179                 public int TopIndex {
 180                         get { throw new NotImplementedException (); }
 181                         set { throw new NotImplementedException (); }
 182                 }
 183                 [MonoTODO]
 184                 public bool UseTabStops {
 185                         get { throw new NotImplementedException (); }
 186                         set { throw new NotImplementedException (); }
 187                 }
 188
 189                 // Don't use
 190                 [MonoTODO]
 191                 protected virtual void AddItemsCore(object[] value)
 192                 {
 193                 }
 194                 [MonoTODO]
 195                 public void BeginUpdate()
 196                 {
 197                 }
 198                 [MonoTODO]
 199                 public void ClearSelected()
 200                 {
 201                 }
 202                 [MonoTODO]
 203                 protected virtual ObjectCollection CreateItemCollection()
 204                 {
 205                         throw new NotImplementedException();
 206                 }
 207                 [MonoTODO]
 208                 public void EndUpdate()
 209                 {
 210                 }
 211                 [MonoTODO]
 212                 public int FindString (string s)
 213                 {
 214                         throw new NotImplementedException();
 215                 }
 216                 [MonoTODO]
 217                 public int FindString (string s, int startIndex)
 218                 {
 219                         throw new NotImplementedException();
 220                 }
 221                 [MonoTODO]
 222                 public int FindStringExact (string s)
 223                 {
 224                         throw new NotImplementedException ();
 225                 }
 226                 [MonoTODO]
 227                 public int FindStringExact (string s, int startIndex)
 228                 {
 229                         throw new NotImplementedException();
 230                 }
 231                 [MonoTODO]
 232                 public int GetItemHeight(int index)
 233                 {
 234                         throw new NotImplementedException ();
 235                 }
 236                 [MonoTODO]
 237                 public Rectangle GetItemRectangle(int index)
 238                 {
 239                         throw new NotImplementedException ();
 240                 }
 241                 [MonoTODO]
 242                 public bool GetSelected(int index)
 243                 {
 244                         throw new NotImplementedException ();
 245                 }
 246                 [MonoTODO]
 247                 public int IndexFromPoint(Point p)
 248                 {
 249                         throw new NotImplementedException ();
 250                 }
 251                 [MonoTODO]
 252                 public int IndexFromPoint(int x, int y)
 253                 {
 254                         throw new NotImplementedException ();
 255                 }
 256                 [MonoTODO]
 257                 protected override void OnChangeUICues(UICuesEventArgs e)
 258                 {
 259                         throw new NotImplementedException ();
 260                 }
 261                 [MonoTODO]
 262                 protected override void OnDataSourceChanged(EventArgs e)
 263                 {
 264                         throw new NotImplementedException ();
 265                 }
 266                 [MonoTODO]
 267                 protected override void OnDisplayMemberChanged(EventArgs e)
 268                 {
 269                 }
 270                 [MonoTODO]
 271                 protected virtual void OnDrawItem(DrawItemEventArgs e)
 272                 {
 273                 }
 274                 [MonoTODO]
 275                 protected override void OnFontChanged(EventArgs e)
 276                 {
 277                 }
 278                 [MonoTODO]
 279                 protected override void OnHandleCreated(EventArgs e)
 280                 {
 281                 }
 282                 [MonoTODO]
 283                 protected override void OnHandleDestroyed(EventArgs e)
 284                 {
 285                 }
 286                 [MonoTODO]
 287                 protected virtual void OnMeasureItem(MeasureItemEventArgs e)
 288                 {
 289                 }
 290                 [MonoTODO]
 291                 protected override void OnParentChanged(EventArgs e)
 292                 {
 293                 }
 294                 [MonoTODO]
 295                 protected override void OnResize(EventArgs e)
 296                 {
 297                 }
 298                 [MonoTODO]
 299                 protected override void OnSelectedIndexChanged(EventArgs e)
 300                 {
 301                 }
 302                 [MonoTODO]
 303                 protected override void OnSelectedValueChanged(EventArgs e)
 304                 {
 305                 }
 306                 [MonoTODO]
 307                 public override void Refresh()
 308                 {
 309                         ListStore store = new ListStore (typeof (string));
 310                         foreach (Object o in Items){
 311                                 Value value = new Value (o);
 312                                 TreeIter iter = store.Append();
 313                                 store.SetValue (iter, 0, value);
 314                         }
 315                         (Widget as Gtk.TreeView).Model = store;
 316                 }
 317                 [MonoTODO]
 318                 protected override void RefreshItem(int index)
 319                 {
 320                 }
 321                 [MonoTODO]
 322                 protected override void SetBoundsCore(int x,int y, int width, int height, BoundsSpecified specified)
 323                 {
 324                 }
 325                 [MonoTODO]
 326                 protected override void SetItemCore(int index, object value)
 327                 {
 328                 }
 329                 [MonoTODO]
 330                 protected override void SetItemsCore(IList value)
 331                 {
 332                 }
 333                 [MonoTODO]
 334                 public void SetSelected(int index, bool value)
 335                 {
 336                 }
 337                 [MonoTODO]
 338                 protected virtual void Sort()
 339                 {
 340                 }
 341                 [MonoTODO]
 342                 public override string ToString()
 343                 {
 344                         return base.ToString();
 345                 }
 346                 [MonoTODO]
 347                 protected virtual void WmReflectCommand(ref Message m)
 348                 {
 349                 }
 350                 [MonoTODO]
 351                 protected override void WndProc(ref Message m)
 352                 {
 353                 }
 354
 355                 public new event EventHandler BackgroundImageChanged;
 356                 public new event EventHandler Click;
 357                 public event DrawItemEventHandler DrawItem;
 358                 public event MeasureItemEventHandler MeasureItem;
 359                 public new event PaintEventHandler Paint;
 360                 public event EventHandler SelectedIndexChanged;
 361                 public new event EventHandler TextChanged;
 362
 363
 364
 365
 366
 367                 [MonoTODO]
 368                 public class ObjectCollection : IList, ICollection, IEnumerable
 369                 {
 370                         private ListBox owner;
 371                         private ArrayList list;
 372
 373                         public ObjectCollection(ListBox owner)
 374                         {
 375                                 this.owner = owner;
 376                                 this.list = new ArrayList();
 377                         }
 378                         public ObjectCollection(ListBox owner, object[] value) : this(owner)
 379                         {
 380                                 AddRange (value);
 381                         }
 382                         [MonoTODO]
 383                         public ObjectCollection(ListBox owner, ObjectCollection value) : this (owner)
 384                         {
 385                                 //TODO: Implement
 386                         }
 387                         [MonoTODO]
 388                         public virtual int Count {
 389                                 get { return list.Count; }
 390                         }
 391                         [MonoTODO]
 392                         public virtual bool IsReadOnly {
 393                                 get { return false; }
 394                         }
 395                         [MonoTODO]
 396                         public virtual object this[int index] {
 397                                 get { return list[index]; }
 398                                 set { throw new NotImplementedException(); }
 399                         }
 400                         // Net 1.1
 401                         bool ICollection.IsSynchronized {
 402                                 get { return list.IsSynchronized; }
 403                         }
 404                         // Net 1.1
 405                         object ICollection.SyncRoot {
 406                                 get { return list.SyncRoot; }
 407                         }
 408                         // Net 1.1
 409                         bool IList.IsFixedSize {
 410                                 get { return list.IsFixedSize; }
 411                         }
 412
 413                         [MonoTODO]
 414                         public int Add(object item)
 415                         {
 416                                 // FIXME: Implement sorted insert, if ListBox.Sorted == true,
 417                                 int ret = list.Add (item);
 418                                 owner.Refresh();
 419                                 return ret;
 420                         }
 421
 422                         /*public class ItemCollection {
 423
 424                         ListBox owner;
 425                         TreeIter iter = new TreeIter ();
 426
 427                         public ItemCollection (ListBox owner){
 428                                 this.owner = owner;
 429                                 owner.store = new ListStore (typeof (string));
 430                         }
 431
 432                         public void Add(String items){
 433
 434                                 Value value = new Value(items);
 435                                 iter = owner.store.Append ();
 436                                 owner.store.SetValue (iter, 0, value);
 437                                 owner.UpdateStore();
 438                         }
 439                 }*/
 440
 441                         [MonoTODO]
 442                         public void AddRange(object[] items)
 443                         {
 444                                 // FIXME: should stop Control refresh until added finished
 445                                 foreach (object o in items)
 446                                         this.Add (o);
 447                         }
 448
 449                         [MonoTODO]
 450                         public void AddRange(ListBox.ObjectCollection value)
 451                         {
 452                                 list.AddRange (value);
 453                         }
 454
 455                         [MonoTODO]
 456                         public virtual void Clear()
 457                         {
 458                                 list.Clear();
 459                         }
 460
 461                         public virtual bool Contains(object value)
 462                         {
 463                                 return list.Contains (value);
 464                         }
 465
 466                         public void CopyTo(object[] dest, int arrayIndex)
 467                         {
 468                                 list.CopyTo (dest, arrayIndex);
 469                         }
 470
 471                         public virtual IEnumerator GetEnumerator()
 472                         {
 473                                 return list.GetEnumerator();
 474                         }
 475
 476                         void ICollection.CopyTo( Array dest,  int index)
 477                         {
 478                                 list.CopyTo(dest, index);
 479                         }
 480
 481                         [MonoTODO]
 482                         int IList.Add( object item)
 483                         {
 484                                 return this.Add (item);
 485                         }
 486
 487                         public virtual int IndexOf(object value)
 488                         {
 489                                 return list.IndexOf(value);
 490                         }
 491
 492                         [MonoTODO]
 493                         public virtual void Insert( int index, object item)
 494                         {
 495                                 list.Insert (index, item);
 496                         }
 497
 498                         [MonoTODO]
 499                         public virtual void Remove(object value)
 500                         {
 501                                 list.Remove (value);
 502                         }
 503
 504                         [MonoTODO]
 505                         public virtual void RemoveAt(int index)
 506                         {
 507                                 list.RemoveAt (index);
 508                         }
 509
 510                 }
 511
 512                 public class SelectedIndexCollection : IList, ICollection,  IEnumerable
 513                 {
 514
 515                         private ListBox owner;
 516                         private ArrayList list;
 517                         public bool IsFixedSize {
 518                                 get { return false; }
 519                         }
 520
 521                         public bool IsSynchronized {
 522                                 get { return list.IsSynchronized; }
 523                         }
 524                         public object SyncRoot {
 525                                 get { return list.SyncRoot; }
 526                         }
 527
 528                         public SelectedIndexCollection(ListBox owner)
 529                         {
 530                                 this.owner = owner;
 531                                 list = new ArrayList ();
 532                         }
 533
 534                         public virtual int Count {
 535                                 get { return list.Count; }
 536                         }
 537                         public virtual bool IsReadOnly {
 538                                 get { return false; }
 539                         }
 540                         [MonoTODO]
 541                         public object this[int index] {
 542                                 get { return list[index]; }
 543                                 set { throw new NotImplementedException (); }
 544                         }
 545
 546                         [MonoTODO]
 547                         public bool Contains(int selectedIndex)
 548                         {
 549                                 throw new NotImplementedException ();
 550                         }
 551
 552                         [MonoTODO]
 553                         public virtual void CopyTo(Array dest, int index)
 554                         {
 555                                 list.CopyTo(dest, index);
 556                                 //throw new NotImplementedException ();
 557                         }
 558
 559                         [MonoTODO]
 560                         public virtual IEnumerator GetEnumerator()
 561                         {
 562                                 return list.GetEnumerator();
 563                                 //throw new NotImplementedException ();
 564                         }
 565
 566                         // don't use
 567                         [MonoTODO]
 568                         int IList.Add(object value)
 569                         {
 570                                 //list.Add (value);
 571                                 throw new NotImplementedException ();
 572                         }
 573
 574                         // don't use
 575                         [MonoTODO]
 576                         void IList.Clear()
 577                         {
 578                                 //throw new NotImplementedException ();
 579                         }
 580
 581                         [MonoTODO]
 582                         bool IList.Contains(object selectedIndex)
 583                         {
 584                                 throw new NotImplementedException ();
 585                         }
 586
 587                         int IList.IndexOf(object selectedIndex)
 588                         {
 589                                 return list.IndexOf (selectedIndex);
 590                         }
 591
 592                         [MonoTODO]
 593                         void IList.Insert(int index, object value)
 594                         {
 595                                 throw new NotImplementedException ();
 596                         }
 597
 598                         [MonoTODO]
 599                         void IList.Remove(object value)
 600                         {
 601                                 throw new NotImplementedException ();
 602                         }
 603
 604                         [MonoTODO]
 605                         void IList.RemoveAt(int index)
 606                         {
 607                                 throw new NotImplementedException ();
 608                         }
 609
 610                         [MonoTODO]
 611                         public int IndexOf(int selectedIndex)
 612                         {
 613                                 throw new NotImplementedException ();
 614                         }
 615
 616                 }
 617
 618
 619
 620                 public class SelectedObjectCollection : IList, ICollection, IEnumerable
 621                 {
 622
 623
 624                         private ListBox owner;
 625                         private ArrayList list;
 626
 627                         public bool IsFixedSize {
 628                                 get { return false; }
 629                         }
 630
 631                         public bool IsSynchronized {
 632                                 get { return list.IsSynchronized; }
 633                         }
 634                         public object SyncRoot {
 635                                 get { return list.SyncRoot; }
 636                         }
 637
 638                         public SelectedObjectCollection(ListBox owner)
 639                         {
 640                                 this.owner = owner;
 641                                 list = new ArrayList();
 642                         }
 643
 644                         public virtual int Count {
 645                                 get { return list.Count; }
 646                         }
 647
 648                         public virtual bool IsReadOnly {
 649                                 get { return list.IsReadOnly; }
 650                         }
 651                         [MonoTODO]
 652                         public virtual object this[int index] {
 653                                 get { return list[index]; }
 654                                 set { throw new NotImplementedException (); }
 655                         }
 656
 657                         public virtual bool Contains(object selectedObject)
 658                         {
 659                                 return list.Contains (selectedObject);
 660                         }
 661
 662                         public virtual void CopyTo(Array dest,  int index)
 663                         {
 664                                 list.CopyTo(dest, index);
 665                         }
 666
 667                         public virtual IEnumerator GetEnumerator()
 668                         {
 669                                 return list.GetEnumerator();
 670                         }
 671
 672                         [MonoTODO]
 673                         int IList.Add(object value)
 674                         {
 675                                 throw new NotImplementedException ();
 676                         }
 677
 678                         // don't use
 679                         [MonoTODO]
 680                         void IList.Clear()
 681                         {
 682                                 throw new NotImplementedException ();
 683                         }
 684
 685                         // don't use
 686                         [MonoTODO]
 687                         void IList.Insert(int index, object value)
 688                         {
 689                                 throw new NotImplementedException ();
 690                         }
 691
 692                         // don't use
 693                         [MonoTODO]
 694                         void IList.Remove(object value)
 695                         {
 696                                 throw new NotImplementedException ();
 697                         }
 698
 699                         // don't use
 700                         [MonoTODO]
 701                         void IList.RemoveAt(int index)
 702                         {
 703                                 throw new NotImplementedException ();
 704                         }
 705
 706                         [MonoTODO]
 707                         public virtual int IndexOf(object selectedObject)
 708                         {
 709                                 throw new NotImplementedException ();
 710                         }
 711
 712                 }
 713
 714                 internal override Gtk.Widget CreateWidget () {
 715
 716                         ListStore store = new ListStore (typeof (string));
 717                         TreeView tv = new TreeView (store);
 718                         tv.HeadersVisible = false;
 719                         tv.HeadersClickable = false;
 720                         tv.EnableSearch = false;
 721                         TreeViewColumn NameCol = new TreeViewColumn ();
 722                         CellRenderer NameRenderer = new CellRendererText ();
 723                         NameCol.Title = "Name";
 724                         NameCol.PackStart (NameRenderer, true);
 725                         NameCol.AddAttribute (NameRenderer, "text", 0);
 726                         tv.AppendColumn (NameCol);
 727                         tv.Model = store;
 728                         return tv;
 729                 }
 730         }
 731 }
 732
 733                 //ListStore store = null;
 734                 //TreeIter iter = new TreeIter ();
 735
 736                 //public ItemCollection Items;
 737                 //ListStore store = new ListStore ((int)TypeFundamentals.TypeString);
 738
 739                 /*public class ItemCollection {
 740
 741                         ListBox owner;
 742                         TreeIter iter = new TreeIter ();
 743
 744                         public ItemCollection (ListBox owner){
 745
 746                                 this.owner = owner;
 747                                 owner.store = new ListStore (typeof (string));
 748
 749                         }
 750
 751                         public void Add(String items){
 752
 753                                 Value value = new Value(items);
 754                                 iter = owner.store.Append ();
 755                                 owner.store.SetValue (iter, 0, value);
 756                                 owner.UpdateStore();
 757                         }
 758                 }*/