mcs/class/Managed.Windows.Forms/System.Windows.Forms/MenuItem.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2004-2005 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Jordi Mas i Hernandez, jordi@ximian.com
  24 //
  25 //
  26
  27 // NOT COMPLETE
  28
  29 using System.Collections;
  30 using System.ComponentModel;
  31 using System.ComponentModel.Design;
  32 using System.Drawing;
  33 using System.Drawing.Text;
  34
  35 namespace System.Windows.Forms
  36 {
  37         [DefaultProperty("Text")]
  38         [DefaultEvent("Click")]
  39         [DesignTimeVisible(false)]
  40         [ToolboxItem(false)]
  41         public class MenuItem : Menu
  42         {
  43                 internal bool separator;
  44                 internal bool break_;
  45                 internal bool bar_break;
  46                 private Shortcut shortcut;
  47                 private string text;
  48                 private bool checked_;
  49                 private bool radiocheck;
  50                 private bool enabled;
  51                 private char mnemonic;
  52                 private bool showshortcut;
  53                 private int index;
  54                 private bool mdilist;
  55                 private Hashtable mdilist_items;
  56                 private Hashtable mdilist_forms;
  57                 private MdiClient mdicontainer;
  58                 private bool is_window_menu_item;
  59                 private bool defaut_item;
  60                 private bool visible;
  61                 private bool ownerdraw;
  62                 private int menuid;
  63                 private int mergeorder;
  64                 private int xtab;
  65                 private int menuheight;
  66                 private bool menubar;
  67                 private MenuMerge mergetype;
  68                 // UIA Framework Note: Used to obtain item bounds
  69                 internal Rectangle bounds;
  70
  71                 public MenuItem (): base (null)
  72                 {
  73                         CommonConstructor (string.Empty);
  74                         shortcut = Shortcut.None;
  75                 }
  76
  77                 public MenuItem (string text) : base (null)
  78                 {
  79                         CommonConstructor (text);
  80                         shortcut = Shortcut.None;
  81                 }
  82
  83                 public MenuItem (string text, EventHandler onClick) : base (null)
  84                 {
  85                         CommonConstructor (text);
  86                         shortcut = Shortcut.None;
  87                         Click += onClick;
  88                 }
  89
  90                 public MenuItem (string text, MenuItem[] items) : base (items)
  91                 {
  92                         CommonConstructor (text);
  93                         shortcut = Shortcut.None;
  94                 }
  95
  96                 public MenuItem (string text, EventHandler onClick, Shortcut shortcut) : base (null)
  97                 {
  98                         CommonConstructor (text);
  99                         Click += onClick;
 100                         this.shortcut = shortcut;
 101                 }
 102
 103                 public MenuItem (MenuMerge mergeType, int mergeOrder, Shortcut shortcut, string text,
 104                         EventHandler onClick, EventHandler onPopup,  EventHandler onSelect,  MenuItem[] items)
 105                         : base (items)
 106                 {
 107                         CommonConstructor (text);
 108                         this.shortcut = shortcut;
 109                         mergeorder = mergeOrder;
 110                         mergetype = mergeType;
 111
 112                         Click += onClick;
 113                         Popup += onPopup;
 114                         Select += onSelect;
 115                 }
 116
 117                 private void CommonConstructor (string text)
 118                 {
 119                         defaut_item = false;
 120                         separator = false;
 121                         break_ = false;
 122                         bar_break = false;
 123                         checked_ = false;
 124                         radiocheck = false;
 125                         enabled = true;
 126                         showshortcut = true;
 127                         visible = true;
 128                         ownerdraw = false;
 129                         menubar = false;
 130                         menuheight = 0;
 131                         xtab = 0;
 132                         index = -1;
 133                         mnemonic = '\0';
 134                         menuid = -1;
 135                         mergeorder = 0;
 136                         mergetype = MenuMerge.Add;
 137                         Text = text;    // Text can change separator status
 138                 }
 139
 140                 #region Events
 141                 static object ClickEvent = new object ();
 142                 static object DrawItemEvent = new object ();
 143                 static object MeasureItemEvent = new object ();
 144                 static object PopupEvent = new object ();
 145                 static object SelectEvent = new object ();
 146
 147                 public event EventHandler Click {
 148                         add { Events.AddHandler (ClickEvent, value); }
 149                         remove { Events.RemoveHandler (ClickEvent, value); }
 150                 }
 151
 152                 public event DrawItemEventHandler DrawItem {
 153                         add { Events.AddHandler (DrawItemEvent, value); }
 154                         remove { Events.RemoveHandler (DrawItemEvent, value); }
 155                 }
 156
 157                 public event MeasureItemEventHandler MeasureItem {
 158                         add { Events.AddHandler (MeasureItemEvent, value); }
 159                         remove { Events.RemoveHandler (MeasureItemEvent, value); }
 160                 }
 161
 162                 public event EventHandler Popup {
 163                         add { Events.AddHandler (PopupEvent, value); }
 164                         remove { Events.RemoveHandler (PopupEvent, value); }
 165                 }
 166
 167                 public event EventHandler Select {
 168                         add { Events.AddHandler (SelectEvent, value); }
 169                         remove { Events.RemoveHandler (SelectEvent, value); }
 170                 }
 171
 172                 #region UIA Framework Events
 173 #if NET_2_0
 174                 static object UIACheckedChangedEvent = new object ();
 175
 176                 internal event EventHandler UIACheckedChanged {
 177                         add { Events.AddHandler (UIACheckedChangedEvent, value); }
 178                         remove { Events.RemoveHandler (UIACheckedChangedEvent, value); }
 179                 }
 180
 181                 internal void OnUIACheckedChanged (EventArgs e)
 182                 {
 183                         EventHandler eh = (EventHandler) Events [UIACheckedChangedEvent];
 184                         if (eh != null)
 185                                 eh (this, e);
 186                 }
 187
 188                 static object UIARadioCheckChangedEvent = new object ();
 189
 190                 internal event EventHandler UIARadioCheckChanged {
 191                         add { Events.AddHandler (UIARadioCheckChangedEvent, value); }
 192                         remove { Events.RemoveHandler (UIARadioCheckChangedEvent, value); }
 193                 }
 194
 195                 internal void OnUIARadioCheckChanged (EventArgs e)
 196                 {
 197                         EventHandler eh = (EventHandler) Events [UIARadioCheckChangedEvent];
 198                         if (eh != null)
 199                                 eh (this, e);
 200                 }
 201
 202                 static object UIAEnabledChangedEvent = new object ();
 203
 204                 internal event EventHandler UIAEnabledChanged {
 205                         add { Events.AddHandler (UIAEnabledChangedEvent, value); }
 206                         remove { Events.RemoveHandler (UIAEnabledChangedEvent, value); }
 207                 }
 208
 209                 internal void OnUIAEnabledChanged (EventArgs e)
 210                 {
 211                         EventHandler eh = (EventHandler) Events [UIAEnabledChangedEvent];
 212                         if (eh != null)
 213                                 eh (this, e);
 214                 }
 215
 216                 static object UIATextChangedEvent = new object ();
 217
 218                 internal event EventHandler UIATextChanged {
 219                         add { Events.AddHandler (UIATextChangedEvent, value); }
 220                         remove { Events.RemoveHandler (UIATextChangedEvent, value); }
 221                 }
 222
 223                 internal void OnUIATextChanged (EventArgs e)
 224                 {
 225                         EventHandler eh = (EventHandler) Events [UIATextChangedEvent];
 226                         if (eh != null)
 227                                 eh (this, e);
 228                 }
 229 #endif
 230                 #endregion
 231                 #endregion // Events
 232
 233                 #region Public Properties
 234
 235                 [Browsable(false)]
 236                 [DefaultValue(false)]
 237                 public bool BarBreak {
 238                         get { return break_; }
 239                         set { break_ = value; }
 240                 }
 241
 242                 [Browsable(false)]
 243                 [DefaultValue(false)]
 244                 public bool Break {
 245                         get { return bar_break; }
 246                         set { bar_break = value; }
 247                 }
 248
 249                 [DefaultValue(false)]
 250                 public bool Checked {
 251                         get { return checked_; }
 252                         set {
 253                                 if (checked_ == value)
 254                                         return;
 255
 256                                 checked_ = value;
 257 #if NET_2_0
 258                                 // UIA Framework Event: Checked Changed
 259                                 OnUIACheckedChanged (EventArgs.Empty);
 260 #endif
 261                         }
 262                 }
 263
 264                 [DefaultValue(false)]
 265                 public bool DefaultItem {
 266                         get { return defaut_item; }
 267                         set { defaut_item = value; }
 268                 }
 269
 270                 [DefaultValue(true)]
 271                 [Localizable(true)]
 272                 public bool Enabled {
 273                         get { return enabled; }
 274                         set {
 275                                 if (enabled == value)
 276                                         return;
 277
 278                                 enabled = value;
 279 #if NET_2_0
 280                                 // UIA Framework Event: Enabled Changed
 281                                 OnUIAEnabledChanged (EventArgs.Empty);
 282 #endif
 283                                 Invalidate ();
 284                         }
 285                 }
 286
 287                 [Browsable(false)]
 288                 public int Index {
 289                         get { return index; }
 290                         set {
 291                                 if (Parent != null && Parent.MenuItems != null && (value < 0 || value >= Parent.MenuItems.Count))
 292                                         throw new ArgumentException ("'" + value + "' is not a valid value for 'value'");
 293                                 index = value;
 294                         }
 295                 }
 296
 297                 [Browsable(false)]
 298                 public override bool IsParent {
 299                         get { return IsPopup; }
 300                 }
 301
 302                 [DefaultValue(false)]
 303                 public bool MdiList {
 304                         get { return mdilist; }
 305                         set {
 306                                 if (mdilist == value)
 307                                         return;
 308                                 mdilist = value;
 309
 310                                 if (mdilist || mdilist_items == null)
 311                                         return;
 312
 313                                 foreach (MenuItem item in mdilist_items.Keys)
 314                                         MenuItems.Remove (item);
 315                                 mdilist_items.Clear ();
 316                                 mdilist_items = null;
 317                         }
 318                 }
 319
 320                 protected int MenuID {
 321                         get { return menuid; }
 322                 }
 323
 324                 [DefaultValue(0)]
 325                 public int MergeOrder {
 326                         get { return mergeorder; }
 327                         set { mergeorder = value; }
 328                 }
 329
 330                 [DefaultValue(MenuMerge.Add)]
 331                 public MenuMerge MergeType {
 332                         get { return mergetype; }
 333                         set {
 334                                 if (!Enum.IsDefined (typeof (MenuMerge), value))
 335                                         throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for MenuMerge", value));
 336
 337                                 mergetype = value;
 338                         }
 339                 }
 340
 341                 [Browsable(false)]
 342                 public char Mnemonic {
 343                         get { return mnemonic; }
 344                 }
 345
 346                 [DefaultValue(false)]
 347                 public bool OwnerDraw {
 348                         get { return ownerdraw; }
 349                         set { ownerdraw = value; }
 350                 }
 351
 352                 [Browsable(false)]
 353                 public Menu Parent {
 354                         get { return parent_menu;}
 355                 }
 356
 357                 [DefaultValue(false)]
 358                 public bool RadioCheck {
 359                         get { return radiocheck; }
 360                         set {
 361                                 if (radiocheck == value)
 362                                         return;
 363
 364                                 radiocheck = value;
 365 #if NET_2_0
 366                                 // UIA Framework Event: Checked Changed
 367                                 OnUIARadioCheckChanged (EventArgs.Empty);
 368 #endif
 369                         }
 370                 }
 371
 372                 [DefaultValue(Shortcut.None)]
 373                 [Localizable(true)]
 374                 public Shortcut Shortcut {
 375                         get { return shortcut;}
 376                         set {
 377                                 if (!Enum.IsDefined (typeof (Shortcut), value))
 378                                         throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for Shortcut", value));
 379
 380                                 shortcut = value;
 381                                 UpdateMenuItem ();
 382                         }
 383                 }
 384
 385                 [DefaultValue(true)]
 386                 [Localizable(true)]
 387                 public bool ShowShortcut {
 388                         get { return showshortcut;}
 389                         set { showshortcut = value; }
 390                 }
 391
 392                 [Localizable(true)]
 393                 public string Text {
 394                         get { return text; }
 395                         set {
 396                                 text = value;
 397
 398                                 if (text == "-")
 399                                         separator = true;
 400                                 else
 401                                         separator = false;
 402 #if NET_2_0
 403                                 // UIA Framework Event: Text Changed
 404                                 OnUIATextChanged (EventArgs.Empty);
 405 #endif
 406
 407                                 ProcessMnemonic ();
 408                                 Invalidate ();
 409                         }
 410                 }
 411
 412                 [DefaultValue(true)]
 413                 [Localizable(true)]
 414                 public bool Visible {
 415                         get { return visible;}
 416                         set {
 417                                 if (value == visible)
 418                                         return;
 419
 420                                 visible = value;
 421
 422                                 if (menu_items != null) {
 423                                         foreach (MenuItem mi in menu_items)
 424                                                 mi.Visible = value;
 425                                 }
 426
 427                                 if (parent_menu != null)
 428                                         parent_menu.OnMenuChanged (EventArgs.Empty);
 429                         }
 430                 }
 431
 432                 #endregion Public Properties
 433
 434                 #region Private Properties
 435
 436                 internal new int Height {
 437                         get { return bounds.Height; }
 438                         set { bounds.Height = value; }
 439                 }
 440
 441                 internal bool IsPopup {
 442                         get {
 443                                 if (menu_items.Count > 0)
 444                                         return true;
 445                                 else
 446                                         return false;
 447                         }
 448                 }
 449
 450                 internal bool MeasureEventDefined {
 451                         get {
 452                                 if (ownerdraw == true && Events [MeasureItemEvent] != null) {
 453                                         return true;
 454                                 } else {
 455                                         return false;
 456                                 }
 457                         }
 458                 }
 459
 460                 internal bool MenuBar {
 461                         get { return menubar; }
 462                         set { menubar = value; }
 463                 }
 464
 465                 internal int MenuHeight {
 466                         get { return menuheight; }
 467                         set { menuheight = value; }
 468                 }
 469
 470                 bool selected;
 471                 internal bool Selected {
 472                         get { return selected; }
 473                         set { selected = value; }
 474                 }
 475
 476                 internal bool Separator {
 477                         get { return separator; }
 478                         set { separator = value; }
 479                 }
 480
 481                 internal DrawItemState Status {
 482                         get {
 483                                 DrawItemState status = DrawItemState.None;
 484                                 MenuTracker tracker = Parent.Tracker;
 485                                 if (Selected)
 486                                         status |= (tracker.active || tracker.Navigating ? DrawItemState.Selected : DrawItemState.HotLight);
 487                                 if (!Enabled)
 488                                         status |= DrawItemState.Grayed | DrawItemState.Disabled;
 489                                 if (Checked)
 490                                         status |= DrawItemState.Checked;
 491                                 if (!tracker.Navigating)
 492                                         status |= DrawItemState.NoAccelerator;
 493                                 return status;
 494                         }
 495                 }
 496
 497                 internal bool VisibleItems {
 498                         get {
 499                                 if (menu_items != null) {
 500                                         foreach (MenuItem mi in menu_items)
 501                                                 if (mi.Visible)
 502                                                         return true;
 503                                 }
 504                                 return false;
 505                         }
 506                 }
 507
 508                 internal new int Width {
 509                         get { return bounds.Width; }
 510                         set { bounds.Width = value; }
 511                 }
 512
 513                 internal new int X {
 514                         get { return bounds.X; }
 515                         set { bounds.X = value; }
 516                 }
 517
 518                 internal int XTab {
 519                         get { return xtab; }
 520                         set { xtab = value; }
 521                 }
 522
 523                 internal new int Y {
 524                         get { return bounds.Y; }
 525                         set { bounds.Y = value; }
 526                 }
 527
 528                 #endregion Private Properties
 529
 530                 #region Public Methods
 531
 532                 public virtual MenuItem CloneMenu ()
 533                 {
 534                         MenuItem item = new MenuItem ();
 535                         item.CloneMenu (this);
 536                         return item;
 537                 }
 538
 539                 protected void CloneMenu (MenuItem itemSrc)
 540                 {
 541                         base.CloneMenu (itemSrc); // Copy subitems
 542
 543                         // Window list
 544                         MdiList = itemSrc.MdiList;
 545                         is_window_menu_item = itemSrc.is_window_menu_item;
 546                         // Remove items corresponding to window menu items, and add new items
 547                         // (Otherwise window menu items would show up twice, since the PopulateWindowMenu doesn't
 548                         // now them)
 549                         bool populated = false;
 550                         for (int i = MenuItems.Count - 1; i >= 0; i--) {
 551                                 if (MenuItems [i].is_window_menu_item) {
 552                                         MenuItems.RemoveAt (i);
 553                                         populated = true;
 554                                 }
 555                         }
 556                         if (populated)
 557                                 PopulateWindowMenu ();
 558
 559                         // Properties
 560                         BarBreak = itemSrc.BarBreak;
 561                         Break = itemSrc.Break;
 562                         Checked = itemSrc.Checked;
 563                         DefaultItem = itemSrc.DefaultItem;
 564                         Enabled = itemSrc.Enabled;
 565                         MergeOrder = itemSrc.MergeOrder;
 566                         MergeType = itemSrc.MergeType;
 567                         OwnerDraw = itemSrc.OwnerDraw;
 568                         //Parent = menuitem.Parent;
 569                         RadioCheck = itemSrc.RadioCheck;
 570                         Shortcut = itemSrc.Shortcut;
 571                         ShowShortcut = itemSrc.ShowShortcut;
 572                         Text = itemSrc.Text;
 573                         Visible = itemSrc.Visible;
 574
 575 #if NET_2_0
 576                         Name = itemSrc.Name;
 577                         Tag = itemSrc.Tag;
 578 #endif
 579                         // Events
 580                         Events[ClickEvent] = itemSrc.Events[ClickEvent];
 581                         Events[DrawItemEvent] = itemSrc.Events[DrawItemEvent];
 582                         Events[MeasureItemEvent] = itemSrc.Events[MeasureItemEvent];
 583                         Events[PopupEvent] = itemSrc.Events[PopupEvent];
 584                         Events[SelectEvent] = itemSrc.Events[SelectEvent];
 585                 }
 586
 587                 protected override void Dispose (bool disposing)
 588                 {
 589                         if (disposing && parent_menu != null)
 590                                 parent_menu.MenuItems.Remove (this);
 591
 592                         base.Dispose (disposing);
 593                 }
 594
 595                 // This really clones the item
 596                 public virtual MenuItem MergeMenu ()
 597                 {
 598                         MenuItem item = new MenuItem ();
 599                         item.CloneMenu (this);
 600                         return item;
 601                 }
 602
 603                 public void MergeMenu (MenuItem itemSrc)
 604                 {
 605                         base.MergeMenu (itemSrc);
 606                 }
 607
 608                 protected virtual void OnClick (EventArgs e)
 609                 {
 610                         EventHandler eh = (EventHandler)(Events [ClickEvent]);
 611                         if (eh != null)
 612                                 eh (this, e);
 613                 }
 614
 615                 protected virtual void OnDrawItem (DrawItemEventArgs e)
 616                 {
 617                         DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
 618                         if (eh != null)
 619                                 eh (this, e);
 620                 }
 621
 622
 623                 protected virtual void OnInitMenuPopup (EventArgs e)
 624                 {
 625                         OnPopup (e);
 626                 }
 627
 628                 protected virtual void OnMeasureItem (MeasureItemEventArgs e)
 629                 {
 630                         if (!OwnerDraw)
 631                                 return;
 632
 633                         MeasureItemEventHandler eh = (MeasureItemEventHandler)(Events [MeasureItemEvent]);
 634                         if (eh != null)
 635                                 eh (this, e);
 636                 }
 637
 638                 protected virtual void OnPopup (EventArgs e)
 639                 {
 640                         EventHandler eh = (EventHandler)(Events [PopupEvent]);
 641                         if (eh != null)
 642                                 eh (this, e);
 643                 }
 644
 645                 protected virtual void OnSelect (EventArgs e)
 646                 {
 647                         EventHandler eh = (EventHandler)(Events [SelectEvent]);
 648                         if (eh != null)
 649                                 eh (this, e);
 650                 }
 651
 652                 public void PerformClick ()
 653                 {
 654                         OnClick (EventArgs.Empty);
 655                 }
 656
 657                 public virtual void PerformSelect ()
 658                 {
 659                         OnSelect (EventArgs.Empty);
 660                 }
 661
 662                 public override string ToString ()
 663                 {
 664                         return base.ToString () + ", Items.Count: " + MenuItems.Count + ", Text: " + text;
 665                 }
 666
 667                 #endregion Public Methods
 668
 669                 #region Private Methods
 670
 671                 internal virtual void Invalidate ()
 672                 {
 673                         if ((Parent == null) || !(Parent is MainMenu) || (Parent.Wnd == null))
 674                                 return;
 675
 676                         Form form = Parent.Wnd.FindForm ();
 677                         if ((form == null) || (!form.IsHandleCreated))
 678                                 return;
 679
 680                         XplatUI.RequestNCRecalc (form.Handle);
 681                 }
 682
 683                 internal void PerformPopup ()
 684                 {
 685                         OnPopup (EventArgs.Empty);
 686                 }
 687
 688                 internal void PerformDrawItem (DrawItemEventArgs e)
 689                 {
 690                         PopulateWindowMenu ();
 691                         if (OwnerDraw)
 692                                 OnDrawItem (e);
 693                         else
 694                                 ThemeEngine.Current.DrawMenuItem (this, e);
 695                 }
 696
 697                 private void PopulateWindowMenu ()
 698                 {
 699                         if (mdilist) {
 700                                 if (mdilist_items == null) {
 701                                         mdilist_items = new Hashtable ();
 702                                         mdilist_forms = new Hashtable ();
 703                                 }
 704
 705                                 do {
 706                                         MainMenu main = GetMainMenu ();
 707                                         if (main == null || main.GetForm () == null)
 708                                                 break;
 709
 710                                         Form form = main.GetForm ();
 711                                         mdicontainer = form.MdiContainer;
 712                                         if (mdicontainer == null)
 713                                                 break;
 714
 715
 716                                         // Remove closed forms
 717                                         MenuItem[] items = new MenuItem[mdilist_items.Count];
 718                                         mdilist_items.Keys.CopyTo (items, 0);
 719                                         foreach (MenuItem item in items) {
 720                                                 Form mdichild = (Form) mdilist_items [item];
 721                                                 if (!mdicontainer.mdi_child_list.Contains(mdichild)) {
 722                                                         mdilist_items.Remove (item);
 723                                                         mdilist_forms.Remove (mdichild);
 724                                                         MenuItems.Remove (item);
 725                                                 }
 726                                         }
 727
 728                                         // Add new forms and update state for existing forms.
 729                                         for (int i = 0; i < mdicontainer.mdi_child_list.Count; i++) {
 730                                                 Form mdichild = (Form)mdicontainer.mdi_child_list[i];
 731                                                 MenuItem item;
 732                                                 if (mdilist_forms.Contains (mdichild)) {
 733                                                         item = (MenuItem) mdilist_forms [mdichild];
 734                                                 } else {
 735                                                         item = new MenuItem ();
 736                                                         item.is_window_menu_item = true;
 737                                                         item.Click += new EventHandler (MdiWindowClickHandler);
 738                                                         mdilist_items [item] = mdichild;
 739                                                         mdilist_forms [mdichild] = item;
 740                                                         MenuItems.AddNoEvents (item);
 741                                                 }
 742                                                 item.Visible = mdichild.Visible;
 743                                                 item.Text = "&" + (i + 1).ToString () + " " + mdichild.Text;
 744                                                 item.Checked = form.ActiveMdiChild == mdichild;
 745                                         }
 746                                 } while (false);
 747                         } else {
 748                                 // Remove all forms
 749                                 if (mdilist_items != null) {
 750                                         foreach (MenuItem item in mdilist_items.Values) {
 751                                                 MenuItems.Remove (item);
 752                                         }
 753
 754                                         mdilist_forms.Clear ();
 755                                         mdilist_items.Clear ();
 756                                 }
 757                         }
 758                 }
 759
 760                 internal void PerformMeasureItem (MeasureItemEventArgs e)
 761                 {
 762                         OnMeasureItem (e);
 763                 }
 764
 765                 private void ProcessMnemonic ()
 766                 {
 767                         if (text == null || text.Length < 2) {
 768                                 mnemonic = '\0';
 769                                 return;
 770                         }
 771
 772                         bool bPrevAmp = false;
 773                         for (int i = 0; i < text.Length -1 ; i++) {
 774                                 if (text[i] == '&') {
 775                                         if (bPrevAmp == false &&  (text[i+1] != '&')) {
 776                                                 mnemonic = Char.ToUpper (text[i+1]);
 777                                                 return;
 778                                         }
 779
 780                                         bPrevAmp = true;
 781                                 }
 782                                 else
 783                                         bPrevAmp = false;
 784                         }
 785
 786                         mnemonic = '\0';
 787                 }
 788
 789                 private string GetShortCutTextCtrl () { return "Ctrl"; }
 790                 private string GetShortCutTextAlt () { return "Alt"; }
 791                 private string GetShortCutTextShift () { return "Shift"; }
 792
 793                 internal string GetShortCutText ()
 794                 {
 795                         /* Ctrl+A - Ctrl+Z */
 796                         if (Shortcut >= Shortcut.CtrlA && Shortcut <= Shortcut.CtrlZ)
 797                                 return GetShortCutTextCtrl () + "+" + (char)((int) 'A' + (int)(Shortcut - Shortcut.CtrlA));
 798
 799                         /* Alt+0 - Alt+9 */
 800                         if (Shortcut >= Shortcut.Alt0 && Shortcut <= Shortcut.Alt9)
 801                                 return GetShortCutTextAlt () + "+" + (char)((int) '0' + (int)(Shortcut - Shortcut.Alt0));
 802
 803                         /* Alt+F1 - Alt+F2 */
 804                         if (Shortcut >= Shortcut.AltF1 && Shortcut <= Shortcut.AltF9)
 805                                 return GetShortCutTextAlt () + "+F" + (char)((int) '1' + (int)(Shortcut - Shortcut.AltF1));
 806
 807                         /* Ctrl+0 - Ctrl+9 */
 808                         if (Shortcut >= Shortcut.Ctrl0 && Shortcut <= Shortcut.Ctrl9)
 809                                 return GetShortCutTextCtrl () + "+" + (char)((int) '0' + (int)(Shortcut - Shortcut.Ctrl0));
 810
 811                         /* Ctrl+F0 - Ctrl+F9 */
 812                         if (Shortcut >= Shortcut.CtrlF1 && Shortcut <= Shortcut.CtrlF9)
 813                                 return GetShortCutTextCtrl () + "+F" + (char)((int) '1' + (int)(Shortcut - Shortcut.CtrlF1));
 814
 815                         /* Ctrl+Shift+0 - Ctrl+Shift+9 */
 816                         if (Shortcut >= Shortcut.CtrlShift0 && Shortcut <= Shortcut.CtrlShift9)
 817                                 return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+" + (char)((int) '0' + (int)(Shortcut - Shortcut.CtrlShift0));
 818
 819                         /* Ctrl+Shift+A - Ctrl+Shift+Z */
 820                         if (Shortcut >= Shortcut.CtrlShiftA && Shortcut <= Shortcut.CtrlShiftZ)
 821                                 return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+" + (char)((int) 'A' + (int)(Shortcut - Shortcut.CtrlShiftA));
 822
 823                         /* Ctrl+Shift+F1 - Ctrl+Shift+F9 */
 824                         if (Shortcut >= Shortcut.CtrlShiftF1 && Shortcut <= Shortcut.CtrlShiftF9)
 825                                 return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+F" + (char)((int) '1' + (int)(Shortcut - Shortcut.CtrlShiftF1));
 826
 827                         /* F1 - F9 */
 828                         if (Shortcut >= Shortcut.F1 && Shortcut <= Shortcut.F9)
 829                                 return "F" + (char)((int) '1' + (int)(Shortcut - Shortcut.F1));
 830
 831                         /* Shift+F1 - Shift+F9 */
 832                         if (Shortcut >= Shortcut.ShiftF1 && Shortcut <= Shortcut.ShiftF9)
 833                                 return GetShortCutTextShift () + "+F" + (char)((int) '1' + (int)(Shortcut - Shortcut.ShiftF1));
 834
 835                         /* Special cases */
 836                         switch (Shortcut) {
 837                                 case Shortcut.AltBksp:
 838                                         return "AltBksp";
 839                                 case Shortcut.AltF10:
 840                                         return GetShortCutTextAlt () + "+F10";
 841                                 case Shortcut.AltF11:
 842                                         return GetShortCutTextAlt () + "+F11";
 843                                 case Shortcut.AltF12:
 844                                         return GetShortCutTextAlt () + "+F12";
 845                                 case Shortcut.CtrlDel:
 846                                         return GetShortCutTextCtrl () + "+Del";
 847                                 case Shortcut.CtrlF10:
 848                                         return GetShortCutTextCtrl () + "+F10";
 849                                 case Shortcut.CtrlF11:
 850                                         return GetShortCutTextCtrl () + "+F11";
 851                                 case Shortcut.CtrlF12:
 852                                         return GetShortCutTextCtrl () + "+F12";
 853                                 case Shortcut.CtrlIns:
 854                                         return GetShortCutTextCtrl () + "+Ins";
 855                                 case Shortcut.CtrlShiftF10:
 856                                         return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+F10";
 857                                 case Shortcut.CtrlShiftF11:
 858                                         return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+F11";
 859                                 case Shortcut.CtrlShiftF12:
 860                                         return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+F12";
 861                                 case Shortcut.Del:
 862                                         return "Del";
 863                                 case Shortcut.F10:
 864                                         return "F10";
 865                                 case Shortcut.F11:
 866                                         return "F11";
 867                                 case Shortcut.F12:
 868                                         return "F12";
 869                                 case Shortcut.Ins:
 870                                         return "Ins";
 871                                 case Shortcut.None:
 872                                         return "None";
 873                                 case Shortcut.ShiftDel:
 874                                         return GetShortCutTextShift () + "+Del";
 875                                 case Shortcut.ShiftF10:
 876                                         return GetShortCutTextShift () + "+F10";
 877                                 case Shortcut.ShiftF11:
 878                                         return GetShortCutTextShift () + "+F11";
 879                                 case Shortcut.ShiftF12:
 880                                         return GetShortCutTextShift () + "+F12";
 881                                 case Shortcut.ShiftIns:
 882                                         return GetShortCutTextShift () + "+Ins";
 883                                 default:
 884                                         break;
 885                                 }
 886
 887                         return "";
 888                 }
 889
 890                 private void MdiWindowClickHandler (object sender, EventArgs e)
 891                 {
 892                         Form mdichild = (Form) mdilist_items [sender];
 893
 894                         // people could add weird items to the Window menu
 895                         // so we can't assume its just us
 896                         if (mdichild == null)
 897                                 return;
 898
 899                         mdicontainer.ActivateChild (mdichild);
 900                 }
 901
 902                 private void UpdateMenuItem ()
 903                 {
 904                         if ((parent_menu == null) || (parent_menu.Tracker == null))
 905                                 return;
 906
 907                         parent_menu.Tracker.RemoveShortcuts (this);
 908                         parent_menu.Tracker.AddShortcuts (this);
 909                 }
 910
 911                 #endregion Private Methods
 912
 913         }
 914 }
 915
 916