mcs/class/System.Web/System.Web.UI.WebControls/TableCellCollection.cs

   1
   2 //
   3 // Permission is hereby granted, free of charge, to any person obtaining
   4 // a copy of this software and associated documentation files (the
   5 // "Software"), to deal in the Software without restriction, including
   6 // without limitation the rights to use, copy, modify, merge, publish,
   7 // distribute, sublicense, and/or sell copies of the Software, and to
   8 // permit persons to whom the Software is furnished to do so, subject to
   9 // the following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be
  12 // included in all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  15 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  17 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  18 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  19 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21 //
  22 /**
  23  * Namespace: System.Web.UI.WebControls
  24  * Class:     TableCellCollection
  25  *
  26  * Author:  Gaurav Vaish
  27  * Maintainer: gvaish@iitk.ac.in
  28  * Contact: <my_scripts2001@yahoo.com>, <gvaish@iitk.ac.in>
  29  * Implementation: yes
  30  * Status:  100%
  31  *
  32  * (C) Gaurav Vaish (2002)
  33  */
  34
  35 using System;
  36 using System.Collections;
  37 using System.Web;
  38 using System.Web.UI;
  39 using System.ComponentModel;
  40
  41 namespace System.Web.UI.WebControls
  42 {
  43         [Editor ("System.Web.UI.Design.WebControls.TableCellsCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
  44         public sealed class TableCellCollection: IList, ICollection, IEnumerable
  45         {
  46                 private TableRow owner;
  47
  48                 internal TableCellCollection(TableRow owner)
  49                 {
  50                         if(owner == null)
  51                         {
  52                                 throw new ArgumentNullException();
  53                         }
  54                         this.owner = owner;
  55                 }
  56
  57                 public int Count
  58                 {
  59                         get
  60                         {
  61                                 return owner.Controls.Count;
  62                         }
  63                 }
  64
  65                 public bool IsReadOnly
  66                 {
  67                         get
  68                         {
  69                                 return false;
  70                         }
  71                 }
  72
  73                 public bool IsSynchronized
  74                 {
  75                         get
  76                         {
  77                                 return false;
  78                         }
  79                 }
  80
  81                 public TableCell this[int index]
  82                 {
  83                         get
  84                         {
  85                                 return (TableCell)owner.Controls[index];
  86                         }
  87                 }
  88
  89                 public object SyncRoot
  90                 {
  91                         get
  92                         {
  93                                 return this;
  94                         }
  95                 }
  96
  97                 public int Add(TableCell cell)
  98                 {
  99                         AddAt(-1, cell);
 100                         return owner.Controls.Count - 1;
 101                 }
 102
 103                 public void AddAt(int index, TableCell cell)
 104                 {
 105                         owner.Controls.AddAt(index, cell);
 106                 }
 107
 108                 public void AddRange(TableCell[] cells)
 109                 {
 110                         foreach(TableCell cell in cells)
 111                         {
 112                                 Add(cell);
 113                         }
 114                 }
 115
 116                 public void Clear()
 117                 {
 118                         if(owner.HasControls())
 119                         {
 120                                 owner.Controls.Clear();
 121                         }
 122                 }
 123
 124                 public void CopyTo(Array array, int index)
 125                 {
 126                         foreach(object cell in this)
 127                         {
 128                                 array.SetValue(cell, index++);
 129                         }
 130                 }
 131
 132                 public int GetCellIndex(TableCell cell)
 133                 {
 134                         if(!owner.HasControls())
 135                         {
 136                                 return -1;
 137                         }
 138                         return owner.Controls.IndexOf(cell);
 139                 }
 140
 141                 public IEnumerator GetEnumerator()
 142                 {
 143                         return owner.Controls.GetEnumerator();
 144                 }
 145
 146                 public void Remove(TableCell cell)
 147                 {
 148                         owner.Controls.Remove(cell);
 149                 }
 150
 151                 public void RemoveAt(int index)
 152                 {
 153                         owner.Controls.RemoveAt(index);
 154                 }
 155
 156                 int IList.Add(object o)
 157                 {
 158                         return Add((TableCell)o);
 159                 }
 160
 161                 bool IList.Contains(object o)
 162                 {
 163                         return owner.Controls.Contains((TableCell)o);
 164                 }
 165
 166                 int IList.IndexOf(object o)
 167                 {
 168                         return owner.Controls.IndexOf((TableCell)o);
 169                 }
 170
 171                 void IList.Insert(int index, object o)
 172                 {
 173                         owner.Controls.AddAt(index, (TableCell)o);
 174                 }
 175
 176                 void IList.Remove(object o)
 177                 {
 178                         owner.Controls.Remove((TableCell)o);
 179                 }
 180
 181                 bool IList.IsFixedSize
 182                 {
 183                         get
 184                         {
 185                                 return false;
 186                         }
 187                 }
 188
 189                 object IList.this[int index]
 190                 {
 191                         get
 192                         {
 193                                 return this[index];
 194                         }
 195                         set
 196                         {
 197                                 RemoveAt(index);
 198                                 AddAt(index, (TableCell)value);
 199                         }
 200                 }
 201         }
 202 }