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

   1 //
   2 // System.Windows.Forms.Menu
   3 //
   4 //      Author:
   5 //              Alberto Fernandez       (infjaf00@yahoo.es)
   6 //
   7
   8 using System;
   9 using System.ComponentModel;
  10 using System.Collections;
  11
  12 using Gtk;
  13
  14 namespace System.Windows.Forms{
  15
  16         public abstract class Menu : Component{
  17
  18                 private  MenuItemCollection _items;
  19
  20                 static Menu (){
  21                         Gtk.Application.Init();
  22                 }
  23                 protected Menu (System.Windows.Forms.MenuItem[] items) {
  24                         _items = new MenuItemCollection(this);
  25                         if (items != null){
  26                                 foreach (System.Windows.Forms.MenuItem m in items)
  27                                         MenuItems.Add (m);
  28                         }
  29                 }
  30
  31                 // ?
  32                 // Public properties not to be used
  33                 // Don't use
  34                 //public const int FindHandle=0;
  35                 // Don't use.
  36                 //public const int FindShortcut=0;
  37
  38
  39                 [MonoTODO]
  40                 public virtual IntPtr Handle {
  41                         get {return IntPtr.Zero;}
  42                 }
  43                 public virtual bool IsParent{
  44                         get{ return (MenuItems.Count != 0); }
  45                 }
  46                 [MonoTODO]
  47                 public virtual System.Windows.Forms.MenuItem MdiListItem {
  48                         get{ return null; }
  49                 }
  50                 public virtual System.Windows.Forms.Menu.MenuItemCollection MenuItems {
  51                         get { return _items; }
  52                 }
  53
  54                 [MonoTODO]
  55                 protected virtual void CloneMenu (System.Windows.Forms.Menu menuSrc){
  56                 }
  57
  58                 [MonoTODO]
  59                 protected override void Dispose (bool disposing){
  60                         base.Dispose (disposing);
  61                 }
  62
  63                 // Don't use
  64                 [MonoTODO]
  65                 public virtual System.Windows.Forms.MenuItem FindMenuItem (int type, IntPtr value){
  66                         return null;
  67                 }
  68                 // Don't use.
  69                 [MonoTODO]
  70                 protected virtual int FindMergePosition (int mergeOrder){
  71                         throw new NotImplementedException();
  72                 }
  73
  74                 public virtual ContextMenu GetContextMenu (){
  75                                 System.Windows.Forms.Menu menu = this;
  76                                 while((menu != null) && !(menu is ContextMenu)){
  77                                         if(menu is System.Windows.Forms.MenuItem){
  78                                                 menu = ((System.Windows.Forms.MenuItem)menu).Parent;
  79                                         }
  80                                         else{
  81                                                 return null;
  82                                         }
  83                                 }
  84                                 return (ContextMenu)menu;
  85                 }
  86                 public virtual MainMenu GetMainMenu(){
  87                         Menu menu = this;
  88                         while((menu != null) && !(menu is MainMenu)){
  89                                 if(menu is System.Windows.Forms.MenuItem){
  90                                         menu = ((System.Windows.Forms.MenuItem)menu).Parent;
  91                                 }
  92                                 else{
  93                                         return null;
  94                                 }
  95                         }
  96                         return (MainMenu)menu;
  97                 }
  98
  99                 [MonoTODO]
 100                 public virtual void MergeMenu (Menu menuSrc){
 101                         if (menuSrc == this){
 102                                 throw new Exception ();
 103                         }
 104
 105                 }
 106                 // Don't use
 107                 [MonoTODO]
 108                 protected internal virtual bool ProcessCmdKey (ref Message msg, Keys keyData){
 109                         throw new NotImplementedException();
 110                 }
 111                 [MonoTODO]
 112                 public override String ToString (){
 113                         return base.ToString() + ", Item.Count=" + _items.Count;
 114                 }
 115
 116
 117
 118                 internal virtual void OnNewMenuItemAdd (MenuItem item){
 119                 }
 120                 internal virtual void OnNewMenuItemAdd (int index, MenuItem item){
 121                 }
 122                 internal virtual void OnRemoveMenuItem (MenuItem item){
 123                 }
 124                 internal virtual void OnLastSubItemRemoved (){
 125                 }
 126
 127
 128                 internal Gtk.Widget widget;
 129                 internal virtual Gtk.Widget Widget{
 130                         get{
 131                                 if (widget == null){
 132                                         widget = CreateWidget();
 133                                 }
 134                                 return widget;
 135                         }
 136                 }
 137                 internal abstract Gtk.Widget CreateWidget();
 138
 139
 140
 141                 public class MenuItemCollection : IList, ICollection, IEnumerable {
 142                         private ArrayList               items_ = new ArrayList();
 143                         private Menu                    parentMenu_ = null;
 144                         //
 145                         // -- Constructor
 146                         //
 147
 148                         public MenuItemCollection (Menu m) {
 149                                 parentMenu_ = m;
 150                         }
 151                         //
 152                         // -- Public Methods
 153                         //
 154
 155                         public virtual int Add (MenuItem mi) {
 156                                 int result = -1;
 157                                 if( mi != null && parentMenu_ != null){
 158                                         parentMenu_.OnNewMenuItemAdd(mi);
 159                                         items_.Add(mi);
 160                                         result = items_.Count - 1;
 161                                         mi.Index = result;
 162                                         if (mi.Parent != null){
 163                                                 mi.Parent.MenuItems.Remove (mi);
 164                                         }
 165                                         mi.SetParent (parentMenu_);
 166                                 }
 167                                 return result;
 168                         }
 169
 170                         private MenuItem AddMenuItemCommon (MenuItem mi) {
 171                                 return ( -1 != Add (mi)) ? mi : null;
 172                         }
 173
 174                         public virtual MenuItem Add ( string s) {
 175                                 return AddMenuItemCommon( new MenuItem (s));
 176                         }
 177
 178                         public virtual int Add ( int i, MenuItem mi) {
 179                                 if( i > items_.Count){
 180                                         // FIXME: Set exception details
 181                                         throw new System.ArgumentException();
 182                                 }
 183                                 int result = -1;
 184                                 if( mi != null && parentMenu_ != null){
 185                                         parentMenu_.OnNewMenuItemAdd(i, mi);
 186                                         items_.Insert(i, mi);
 187                                         result = i;
 188                                         mi.Index=result;
 189                                         if (mi.Parent != null){
 190                                                 mi.Parent.MenuItems.Remove (mi);
 191                                         }
 192                                         mi.SetParent (parentMenu_);
 193                                 }
 194                                 return result;
 195                         }
 196
 197                         public virtual MenuItem Add (string s, EventHandler e) {
 198                                 return AddMenuItemCommon(new MenuItem ( s, e));
 199                         }
 200
 201                         public virtual MenuItem Add (string s, MenuItem[] items) {
 202                                 return AddMenuItemCommon(new MenuItem ( s, items));
 203                         }
 204
 205                         public virtual void AddRange(MenuItem[] items) {
 206                                 if( items != null) {
 207                                         foreach( MenuItem mi in items) {
 208                                                 Add(mi);
 209                                         }
 210                                 }
 211                         }
 212
 213                         private void DoClear() {
 214                                 if( parentMenu_ != null) {
 215                                         foreach( MenuItem mi in items_) {
 216                                                 parentMenu_.OnRemoveMenuItem( mi);
 217                                         }
 218                                 }
 219                                 items_.Clear();
 220                                 if( parentMenu_ != null) {
 221                                         parentMenu_.OnLastSubItemRemoved();
 222                                 }
 223                         }
 224
 225                         public virtual void Clear() {
 226                                 DoClear();
 227                         }
 228
 229                         public bool Contains(MenuItem m) {
 230                                 return items_.Contains(m);
 231                         }
 232
 233                         public void CopyTo(Array a, int i) {
 234                                 int targetIdx = i;
 235                                 foreach( MenuItem mi in items_) {
 236                                         MenuItem newMi = mi.CloneMenu();
 237                                         a.SetValue(newMi,targetIdx++);
 238                                 }
 239                         }
 240
 241                         //public override bool Equals(object o) {
 242                         //      return base.Equals(o);
 243                         //}
 244
 245                         [MonoTODO]
 246                         //public override int GetHashCode() {
 247                                 //FIXME add our proprities
 248                         //      return base.GetHashCode();
 249                         //}
 250
 251                         public IEnumerator GetEnumerator() {
 252                                 return items_.GetEnumerator();
 253                         }
 254
 255                         public int IndexOf(MenuItem m) {
 256                                 return items_.IndexOf(m);
 257                         }
 258
 259                         public virtual void Remove(MenuItem m) {
 260                                 if( m != null && parentMenu_ != null){
 261                                         if( Contains(m)){
 262                                                 parentMenu_.OnRemoveMenuItem(m);
 263                                                 items_.Remove(m);
 264                                                 if( items_.Count == 0){
 265                                                         parentMenu_.OnLastSubItemRemoved();
 266                                                 }
 267                                                 m.SetParent(null);
 268                                         }
 269                                 }
 270                         }
 271
 272                         public virtual void RemoveAt(int i) {
 273                                 Remove(items_[i] as MenuItem);
 274                         }
 275
 276                         public override string ToString() {
 277                                 return base.ToString();
 278                         }
 279
 280                         //
 281                         // -- Protected Methods
 282                         //
 283
 284                         ~MenuItemCollection() {
 285                                 Clear();
 286                         }
 287
 288
 289                         //
 290                         // -- Public Properties
 291                         //
 292
 293                         public int Count {
 294                                 get {return items_.Count;}
 295                         }
 296
 297                         /// <summary>
 298                         /// IList Interface implmentation.
 299                         /// </summary>
 300                         bool IList.IsReadOnly {
 301                                 get { return items_.IsReadOnly; }
 302                         }
 303
 304                         bool IList.IsFixedSize {
 305                                 get { return false;     }
 306                         }
 307
 308                         public MenuItem this[int index] {
 309                                 get { return items_[index] as MenuItem; }
 310                         }
 311
 312                         //[MonoTODO]
 313                         object IList.this[int index] {
 314                                 get { return items_[index];     }
 315                                 set {
 316                                         // FIXME: Set exception members
 317                                         throw new System.NotSupportedException();
 318                                 }
 319                         }
 320
 321                         [MonoTODO]
 322                         void IList.Clear() {
 323                                 DoClear();
 324                         }
 325
 326                         private MenuItem Object2MenuItem( object value) {
 327                                 MenuItem result = value as MenuItem;
 328                                 if( result == null) {
 329                                         // FIXME: Set exception parameters
 330                                         throw new System.ArgumentException();
 331                                 }
 332                                 return result;
 333                         }
 334
 335                         [MonoTODO]
 336                         int IList.Add( object value) {
 337                                 return Add( Object2MenuItem(value));
 338                         }
 339
 340                         [MonoTODO]
 341                         bool IList.Contains( object value) {
 342                                 return Contains(Object2MenuItem(value));
 343                         }
 344
 345                         [MonoTODO]
 346                         int IList.IndexOf( object value) {
 347                                 return IndexOf(Object2MenuItem(value));
 348                         }
 349
 350                         [MonoTODO]
 351                         void IList.Insert(int index, object value) {
 352                                 Add( index, Object2MenuItem(value));
 353                         }
 354
 355                         [MonoTODO]
 356                         void IList.Remove( object value) {
 357                                 Remove( Object2MenuItem(value));
 358                         }
 359
 360                         [MonoTODO]
 361                         void IList.RemoveAt( int index){
 362                                 RemoveAt(index);
 363                         }
 364                         // End of IList interface
 365
 366                         /// <summary>
 367                         /// ICollection Interface implmentation.
 368                         /// </summary>
 369                         int ICollection.Count {
 370                                 get { return Count;     }
 371                         }
 372                         bool ICollection.IsSynchronized {
 373                                 get { return items_.IsSynchronized; }
 374                         }
 375                         object ICollection.SyncRoot {
 376                                 get { return items_.SyncRoot; }
 377                         }
 378                         void ICollection.CopyTo(Array array, int index){
 379                                 CopyTo(array, index);
 380                         }
 381                         // End Of ICollection
 382                 }
 383         }
 384 }