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

   1 //
   2 //              System.Windows.Forms.TabControl
   3 //
   4 //              Author:
   5 //                      Alberto Fernandez               (infjaf00@yahoo.es)
   6 //
   7
   8
   9 using System;
  10 using System.Drawing;
  11 using System.Collections;
  12 using System.ComponentModel;
  13
  14 namespace System.Windows.Forms{
  15
  16         public class TabControl : Control {
  17                 [MonoTODO]
  18                 public TabControl(){
  19                 }
  20
  21                 //InvalidEnumArgumentException
  22                 // Pred = top
  23                 [MonoTODO]
  24                 public TabAlignment Alignment {
  25                         get { throw new NotImplementedException(); }
  26                         set { throw new NotImplementedException(); }
  27                 }
  28                 [MonoTODO]
  29                 public TabAppearance Appearance {
  30                         get { throw new NotImplementedException(); }
  31                         set { throw new NotImplementedException(); }
  32                 }
  33                 [MonoTODO]
  34                 public override Color BackColor {
  35                         get { throw new NotImplementedException(); }
  36                         set { throw new NotImplementedException(); }
  37                 }
  38                 [MonoTODO]
  39                 public override Image BackgroundImage {
  40                         get { throw new NotImplementedException(); }
  41                         set { throw new NotImplementedException(); }
  42                 }
  43                 [MonoTODO]
  44                 protected override CreateParams CreateParams {
  45                         get { throw new NotImplementedException(); }
  46                 }
  47                 [MonoTODO]
  48                 protected override Size DefaultSize {
  49                         get { return new Size (200,100); }
  50                 }
  51                 [MonoTODO]
  52                 public override Rectangle DisplayRectangle {
  53                         get { throw new NotImplementedException(); }
  54                 }
  55                 [MonoTODO]
  56                 public TabDrawMode DrawMode {
  57                         get { throw new NotImplementedException(); }
  58                         set { throw new NotImplementedException(); }
  59                 }
  60                 [MonoTODO]
  61                 public override Color ForeColor {
  62                         get { throw new NotImplementedException(); }
  63                         set { throw new NotImplementedException(); }
  64                 }
  65                 [MonoTODO]
  66                 public bool HotTrack {
  67                         get { throw new NotImplementedException(); }
  68                         set { throw new NotImplementedException(); }
  69                 }
  70                 [MonoTODO]
  71                 public ImageList ImageList {
  72                         get { throw new NotImplementedException(); }
  73                         set { throw new NotImplementedException(); }
  74                 }
  75                 [MonoTODO]
  76                 public Size ItemSize {
  77                         get { throw new NotImplementedException(); }
  78                         set { throw new NotImplementedException(); }
  79                 }
  80                 [MonoTODO]
  81                 public bool Multiline {
  82                         get { throw new NotImplementedException(); }
  83                         set { throw new NotImplementedException(); }
  84                 }
  85                 [MonoTODO]
  86                 public Point Padding {
  87                         get { throw new NotImplementedException(); }
  88                         set { throw new NotImplementedException(); }
  89                 }
  90                 [MonoTODO]
  91                 public int RowCount {
  92                         get { throw new NotImplementedException(); }
  93                 }
  94                 [MonoTODO]
  95                 public int SelectedIndex {
  96                         get { throw new NotImplementedException(); }
  97                         set { throw new NotImplementedException(); }
  98                 }
  99                 [MonoTODO]
 100                 public TabPage SelectedTab {
 101                         get { throw new NotImplementedException(); }
 102                         set { throw new NotImplementedException(); }
 103                 }
 104                 [MonoTODO]
 105                 public bool ShowToolTips {
 106                         get { throw new NotImplementedException(); }
 107                         set { throw new NotImplementedException(); }
 108                 }
 109                 [MonoTODO]
 110                 public TabSizeMode SizeMode {
 111                         get { throw new NotImplementedException(); }
 112                         set { throw new NotImplementedException(); }
 113                 }
 114                 [MonoTODO]
 115                 public int TabCount {
 116                         get { throw new NotImplementedException(); }
 117                 }
 118                 [MonoTODO]
 119                 public TabControl.TabPageCollection TabPages {
 120                         get { throw new NotImplementedException(); }
 121                 }
 122                 [MonoTODO]
 123                 public override string Text {
 124                         get { throw new NotImplementedException(); }
 125                         set { throw new NotImplementedException(); }
 126                 }
 127                 [MonoTODO]
 128                 protected override Control.ControlCollection CreateControlsInstance(){
 129                         return new TabControl.ControlCollection(this);
 130                 }
 131                 [MonoTODO]
 132                 protected override void CreateHandle(){
 133                         throw new NotImplementedException();
 134                 }
 135                 [MonoTODO]
 136                 protected override void Dispose(bool disposing){
 137                         throw new NotImplementedException();
 138                 }
 139
 140                 // No usar
 141                 public Control GetControl(int index){
 142                         throw new NotImplementedException();
 143                 }
 144                 protected virtual object[] GetItems(){
 145                         throw new NotImplementedException();
 146                 }
 147                 protected virtual object[] GetItems(Type baseType){
 148                         throw new NotImplementedException();
 149                 }
 150
 151                 [MonoTODO]
 152                 public Rectangle GetTabRect(int index){
 153                         throw new NotImplementedException();
 154                 }
 155
 156                 // No usar
 157                 protected string GetToolTipText(object item){
 158                         throw new NotImplementedException();
 159                 }
 160
 161                 [MonoTODO]
 162                 protected override bool IsInputKey(Keys keyData){
 163                         throw new NotImplementedException();
 164                 }
 165                 [MonoTODO]
 166                 protected virtual void OnDrawItem(DrawItemEventArgs e){
 167                         throw new NotImplementedException();
 168                 }
 169                 [MonoTODO]
 170                 protected override void OnFontChanged(EventArgs e){
 171                         throw new NotImplementedException();
 172                 }
 173                 [MonoTODO]
 174                 protected override void OnHandleCreated(EventArgs e){
 175                         throw new NotImplementedException();
 176                 }
 177                 [MonoTODO]
 178                 protected override void OnHandleDestroyed(EventArgs e){
 179                         throw new NotImplementedException();
 180                 }
 181                 [MonoTODO]
 182                 protected override void OnKeyDown(KeyEventArgs ke){
 183                         throw new NotImplementedException();
 184                 }
 185                 [MonoTODO]
 186                 protected override void OnResize(EventArgs e){
 187                         throw new NotImplementedException();
 188                 }
 189                 [MonoTODO]
 190                 protected virtual void OnSelectedIndexChanged(EventArgs e){
 191                         throw new NotImplementedException();
 192                 }
 193                 [MonoTODO]
 194                 protected override void OnStyleChanged(EventArgs e){
 195                         throw new NotImplementedException();
 196                 }
 197                 [MonoTODO]
 198                 protected override bool ProcessKeyPreview(ref Message m){
 199                         throw new NotImplementedException();
 200                 }
 201                 [MonoTODO]
 202                 protected void RemoveAll(){
 203                         throw new NotImplementedException();
 204                 }
 205
 206                 public override string ToString(){
 207                         return "System.Windows.Forms.TabContro, TabPages.Count: " +
 208                                 this.TabPages.Count;
 209                         //System.Windows.Forms.TabControl, TabPages.Count: 0
 210                 }
 211
 212                 // No usar
 213                 protected void UpdateTabSelection( bool uiselected){
 214                         throw new NotImplementedException();
 215                 }
 216
 217                 [MonoTODO]
 218                 protected override void WndProc(ref Message m){
 219                         throw new NotImplementedException();
 220                 }
 221
 222
 223                 public new event EventHandler BackColorChanged;
 224                 public new event EventHandler BackgroundImageChanged;
 225                 public event DrawItemEventHandler DrawItem;
 226                 public new event EventHandler ForeColorChanged;
 227                 public new event PaintEventHandler Paint;
 228                 public event EventHandler SelectedIndexChanged;
 229                 public new event EventHandler TextChanged;
 230
 231
 232                 public new class ControlCollection : Control.ControlCollection {
 233
 234                         public ControlCollection ( TabControl owner ): base( owner ){ }
 235
 236                         public override void Add( Control c ) {
 237                                 //if ( !( c is TabPage ) ) {
 238                                 //      throw new ArgumentException();
 239                                 //}
 240                                 //base.Add(c);
 241                                 //if ( owner.IsHandleCreated )
 242                                 //      ((TabControl) owner).addPage ( c, Count - 1);
 243                         }
 244
 245                         public override void Clear () {
 246                                 //base.Clear ( );
 247                                 //if ( owner.IsHandleCreated )
 248                                 //      ((TabControl) owner).removeAllTabs ( );
 249                         }
 250
 251                         public override void Remove ( Control value ) {
 252                                 //int index = IndexOf ( value );
 253                                 //base.Remove ( value );
 254                                 //if ( index != -1 && owner.IsHandleCreated )
 255                                 //      ((TabControl) owner).removeTab ( value, index );
 256                         }
 257                 }
 258
 259
 260                 public class TabPageCollection : IList, ICollection, IEnumerable {
 261                         TabControl owner;
 262                         Control.ControlCollection collection;
 263
 264                         public TabPageCollection( TabControl owner ) {
 265                                 this.owner = owner;
 266                                 collection = owner.Controls;
 267                         }
 268
 269                         public int Count {
 270                                 get { return collection.Count; }
 271                         }
 272
 273                         public bool IsReadOnly {
 274                                 get {   return collection.IsReadOnly; }
 275                         }
 276
 277                         [MonoTODO]
 278                         public virtual TabPage this[int index] {
 279                                 get {   return collection[ index ] as TabPage; }
 280                                 set {
 281                                         //( (IList)collection )[ index ] = value;
 282                                         //owner.update ( );
 283                                 }
 284                         }
 285
 286                         public void Add(TabPage value) {
 287                                 collection.Add ( value );
 288                         }
 289
 290                         public void AddRange( TabPage[] pages ) {
 291                                 collection.AddRange ( pages );
 292                         }
 293
 294                         public virtual void Clear() {
 295                                 collection.Clear ( );
 296                         }
 297
 298                         public bool Contains( TabPage page ) {
 299                                 return collection.Contains ( page );
 300                         }
 301
 302                         public IEnumerator GetEnumerator() {
 303                                 return collection.GetEnumerator ( );
 304                         }
 305
 306                         public int IndexOf( TabPage page ) {
 307                                 return collection.IndexOf ( page );
 308                         }
 309
 310                         public void Remove( TabPage value ) {
 311                                 collection.Remove ( value );
 312                         }
 313
 314                         public void RemoveAt(int index) {
 315                                 collection.RemoveAt ( index );
 316                         }
 317
 318                         /// <summary>
 319                         /// IList Interface implmentation.
 320                         /// </summary>
 321                         bool IList.IsReadOnly{
 322                                 get{    return this.IsReadOnly; }
 323                         }
 324
 325                         bool IList.IsFixedSize{
 326                                 get{    return (( IList )collection).IsFixedSize; }
 327                         }
 328
 329                         object IList.this[int index]{
 330                                 get{    return collection [ index ]; }
 331                                 set{
 332                                         //if ( ! (value is TabPage) )
 333                                         //      throw new ArgumentException ( );
 334                                         //this[ index ] = (TabPage) value;
 335                                         //owner.update ( );
 336                                 }
 337                         }
 338
 339                         void IList.Clear(){
 340                                 this.Clear ( );
 341                         }
 342
 343                         [MonoTODO]
 344                         int IList.Add( object value ) {
 345                                 TabPage page = value as TabPage;
 346                                 if ( page == null )
 347                                         throw new ArgumentException ( );
 348                                 this.Add ( page );
 349                                 return this.IndexOf ( page );
 350                         }
 351
 352                         [MonoTODO]
 353                         bool IList.Contains( object value ){
 354                                 return this.Contains ( value as TabPage );
 355                         }
 356
 357                         [MonoTODO]
 358                         int IList.IndexOf( object value ){
 359                                 return this.IndexOf ( value as TabPage );
 360                         }
 361
 362                         [MonoTODO]
 363                         void IList.Insert(int index, object value){
 364                                 //if ( ! (value is TabPage) )
 365                                 //      throw new ArgumentException ( );
 366
 367                                 //(( IList )collection).Insert ( index, value );
 368                                 //owner.update ( );
 369                         }
 370
 371                         void IList.Remove( object value ){
 372                                 this.Remove ( value as TabPage );
 373                         }
 374
 375                         void IList.RemoveAt( int index){
 376                                 this.RemoveAt ( index );
 377                         }
 378                         // End of IList interface
 379
 380                         /// <summary>
 381                         /// ICollection Interface implmentation.
 382                         /// </summary>
 383                         int ICollection.Count{
 384                                 get{ return this.Count; }
 385                         }
 386
 387                         bool ICollection.IsSynchronized{
 388                                 get{ return ( (ICollection) collection).IsSynchronized; }
 389                         }
 390
 391                         object ICollection.SyncRoot{
 392                                 get{ return ( (ICollection) collection).SyncRoot; }
 393                         }
 394
 395                         void ICollection.CopyTo(Array array, int index){
 396                                 ( (ICollection) collection ).CopyTo ( array, index );
 397                         }
 398                         // End Of ICollection
 399                 }
 400
 401                 /*
 402                 [MonoTODO]
 403                 public class TabControl.ControlCollection :  Control.ControlCollection {
 404                         public TabControl.ControlCollection(TabControl owner);
 405
 406                         public override void Add(Control value);
 407                         public override void Remove(Control value);
 408
 409                 }*/
 410                 /*
 411                 [MonoTODO]
 412                 public class TabControl.TabPageCollection : IList, ICollection,  IEnumerable{
 413
 414                         public TabControl.TabPageCollection(TabControl owner);
 415                         public virtual int Count {get;}
 416                         public virtual bool IsReadOnly {get;}
 417                         public virtual TabPage this[int index] {get; set;}
 418                         int ICollection.Count {get;}
 419                         bool ICollection.IsSynchronized {get;}
 420                         object ICollection.SyncRoot {get;}
 421                         bool IList.IsFixedSize {get;}
 422                         bool IList.IsReadOnly {get;}
 423                         object IList.this[ int index] {get; set;}
 424
 425                         public void Add( TabPage value);
 426                         public void AddRange( TabPage[] pages);
 427                         public virtual void Clear();
 428                         public bool Contains( TabPage page);
 429                         public virtual IEnumerator GetEnumerator();
 430                         void ICollection.CopyTo(Array dest, int index);
 431                         int IList.Add( object value);
 432                         bool IList.Contains(object page);
 433                         int IList.IndexOf( object page);
 434                         void IList.Insert(int index, object value);
 435                         void IList.Remove( object value);
 436                         public int IndexOf( TabPage page);
 437                         public void Remove( TabPage value);
 438                         public virtual void RemoveAt(int index);
 439
 440
 441                 }*/
 442
 443         }
 444
 445 }