Move ShiftUI source code to ShiftOS

This'll be a lot easier to work on.

1 files changed, 912 insertions, 0 deletions

diff --git a/source/ShiftUI/Menu/MenuItem.cs b/source/ShiftUI/Menu/MenuItem.cs
new file mode 100644
index 0000000..a893106
--- /dev/null
+++ b/source/ShiftUI/Menu/MenuItem.cs
@@ -0,0 +1,912 @@
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// Copyright (c) 2004-2005 Novell, Inc.
+//
+// Authors:
+//	Jordi Mas i Hernandez, [email protected]
+//
+//
+
+// NOT COMPLETE
+
+using System.Collections;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Drawing;
+using System.Drawing.Text;
+using System;
+
+namespace ShiftUI
+{
+	[DefaultProperty("Text")]
+	[DefaultEvent("Click")]
+	[DesignTimeVisible(false)]
+	[ToolboxItem(false)]
+	public class MenuItem : Menu
+	{
+		internal bool separator;
+		internal bool break_;
+		internal bool bar_break;
+		private Shortcut shortcut;
+		private	string text;
+		private bool checked_;
+		private bool radiocheck;
+		private bool enabled;
+		private char mnemonic;
+		private bool showshortcut;
+		private int index;
+		private bool mdilist;
+		private Hashtable mdilist_items;
+		private Hashtable mdilist_forms;
+		private MdiClient mdicontainer;
+		private bool is_window_menu_item;
+		private bool defaut_item;
+		private bool visible;
+		private bool ownerdraw;
+		private int menuid;
+		private int mergeorder;
+		private int xtab;
+		private int menuheight;
+		private bool menubar;
+		private MenuMerge mergetype;
+		// UIA Framework Note: Used to obtain item bounds
+		internal Rectangle bounds;
+		
+		public MenuItem (): base (null)
+		{	
+			CommonConstructor (string.Empty);
+			shortcut = Shortcut.None;
+		}
+
+		public MenuItem (string text) : base (null)
+		{
+			CommonConstructor (text);
+			shortcut = Shortcut.None;
+		}
+
+		public MenuItem (string text, EventHandler onClick) : base (null)
+		{
+			CommonConstructor (text);
+			shortcut = Shortcut.None;
+			Click += onClick;
+		}
+
+		public MenuItem (string text, MenuItem[] items) : base (items)
+		{
+			CommonConstructor (text);
+			shortcut = Shortcut.None;
+		}
+
+		public MenuItem (string text, EventHandler onClick, Shortcut shortcut) : base (null)
+		{
+			CommonConstructor (text);
+			Click += onClick;
+			this.shortcut = shortcut;
+		}
+
+		public MenuItem (MenuMerge mergeType, int mergeOrder, Shortcut shortcut, string text,
+			EventHandler onClick, EventHandler onPopup,  EventHandler onSelect,  MenuItem[] items)
+			: base (items)
+		{
+			CommonConstructor (text);
+			this.shortcut = shortcut;
+			mergeorder = mergeOrder;
+			mergetype = mergeType;
+
+			Click += onClick;
+			Popup += onPopup;
+			Select += onSelect;
+		}
+
+		private void CommonConstructor (string text)
+		{
+			defaut_item = false;
+			separator = false;
+			break_ = false;
+			bar_break = false;
+			checked_ = false;
+			radiocheck = false;
+			enabled = true;
+			showshortcut = true;
+			visible = true;
+			ownerdraw = false;
+			menubar = false;
+			menuheight = 0;
+			xtab = 0;
+			index = -1;
+			mnemonic = '\0';
+			menuid = -1;
+			mergeorder = 0;
+			mergetype = MenuMerge.Add;
+			Text = text;	// Text can change separator status
+		}
+
+		#region Events
+		static object ClickEvent = new object ();
+		static object DrawItemEvent = new object ();
+		static object MeasureItemEvent = new object ();
+		static object PopupEvent = new object ();
+		static object SelectEvent = new object ();
+
+		public event EventHandler Click {
+			add { Events.AddHandler (ClickEvent, value); }
+			remove { Events.RemoveHandler (ClickEvent, value); }
+		}
+
+		public event DrawItemEventHandler DrawItem {
+			add { Events.AddHandler (DrawItemEvent, value); }
+			remove { Events.RemoveHandler (DrawItemEvent, value); }
+		}
+
+		public event MeasureItemEventHandler MeasureItem {
+			add { Events.AddHandler (MeasureItemEvent, value); }
+			remove { Events.RemoveHandler (MeasureItemEvent, value); }
+		}
+
+		public event EventHandler Popup {
+			add { Events.AddHandler (PopupEvent, value); }
+			remove { Events.RemoveHandler (PopupEvent, value); }
+		}
+
+		public event EventHandler Select {
+			add { Events.AddHandler (SelectEvent, value); }
+			remove { Events.RemoveHandler (SelectEvent, value); }
+		}
+		
+		#region UIA Framework Events
+
+		static object UIACheckedChangedEvent = new object ();
+
+		internal event EventHandler UIACheckedChanged {
+			add { Events.AddHandler (UIACheckedChangedEvent, value); }
+			remove { Events.RemoveHandler (UIACheckedChangedEvent, value); }
+		}
+
+		internal void OnUIACheckedChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler) Events [UIACheckedChangedEvent];
+			if (eh != null)
+				eh (this, e);
+		}
+		
+		static object UIARadioCheckChangedEvent = new object ();
+
+		internal event EventHandler UIARadioCheckChanged {
+			add { Events.AddHandler (UIARadioCheckChangedEvent, value); }
+			remove { Events.RemoveHandler (UIARadioCheckChangedEvent, value); }
+		}
+
+		internal void OnUIARadioCheckChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler) Events [UIARadioCheckChangedEvent];
+			if (eh != null)
+				eh (this, e);
+		}
+		
+		static object UIAEnabledChangedEvent = new object ();
+
+		internal event EventHandler UIAEnabledChanged {
+			add { Events.AddHandler (UIAEnabledChangedEvent, value); }
+			remove { Events.RemoveHandler (UIAEnabledChangedEvent, value); }
+		}
+
+		internal void OnUIAEnabledChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler) Events [UIAEnabledChangedEvent];
+			if (eh != null)
+				eh (this, e);
+		}
+		
+		static object UIATextChangedEvent = new object ();
+
+		internal event EventHandler UIATextChanged {
+			add { Events.AddHandler (UIATextChangedEvent, value); }
+			remove { Events.RemoveHandler (UIATextChangedEvent, value); }
+		}
+
+		internal void OnUIATextChanged (EventArgs e)
+		{
+			EventHandler eh = (EventHandler) Events [UIATextChangedEvent];
+			if (eh != null)
+				eh (this, e);
+		}
+
+		#endregion
+		#endregion // Events
+
+		#region Public Properties
+
+		[Browsable(false)]
+		[DefaultValue(false)]
+		public bool BarBreak {
+			get { return break_; }
+			set { break_ = value; }
+		}
+
+		[Browsable(false)]
+		[DefaultValue(false)]
+		public bool Break {
+			get { return bar_break; }
+			set { bar_break = value; }
+		}
+
+		[DefaultValue(false)]
+		public bool Checked {
+			get { return checked_; }
+			set {
+				if (checked_ == value)
+					return;
+				
+				checked_ = value;
+
+				// UIA Framework Event: Checked Changed
+				OnUIACheckedChanged (EventArgs.Empty);
+			}
+		}
+
+		[DefaultValue(false)]
+		public bool DefaultItem {
+			get { return defaut_item; }
+			set { defaut_item = value; }
+		}
+
+		[DefaultValue(true)]
+		[Localizable(true)]
+		public bool Enabled {
+			get { return enabled; }
+			set {
+				if (enabled == value)
+					return;
+					
+				enabled = value;
+
+				// UIA Framework Event: Enabled Changed
+				OnUIAEnabledChanged (EventArgs.Empty);
+
+				Invalidate ();
+			}
+		}
+
+		[Browsable(false)]
+		public int Index {
+			get { return index; }
+			set { 
+				if (Parent != null && Parent.MenuItems != null && (value < 0 || value >= Parent.MenuItems.Count))
+					throw new ArgumentException ("'" + value + "' is not a valid value for 'value'");
+				index = value; 
+			}
+		}
+
+		[Browsable(false)]
+		public override bool IsParent {
+			get { return IsPopup; }
+		}
+
+		[DefaultValue(false)]
+		public bool MdiList {
+			get { return mdilist; }
+			set {
+				if (mdilist == value)
+					return;
+				mdilist = value;
+
+				if (mdilist || mdilist_items == null)
+					return;
+
+				foreach (MenuItem item in mdilist_items.Keys)
+					MenuItems.Remove (item);
+				mdilist_items.Clear ();
+				mdilist_items = null;
+			}
+		}
+
+		protected int MenuID {
+			get { return menuid; }
+		}
+
+		[DefaultValue(0)]
+		public int MergeOrder {
+			get { return mergeorder; }
+			set { mergeorder = value; }
+		}
+
+		[DefaultValue(MenuMerge.Add)]
+		public MenuMerge MergeType {
+			get { return mergetype;	}
+			set {
+				if (!Enum.IsDefined (typeof (MenuMerge), value))
+					throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for MenuMerge", value));
+
+				mergetype = value;
+			}
+		}
+
+		[Browsable(false)]
+		public char Mnemonic {
+			get { return mnemonic; }
+		}
+
+		[DefaultValue(false)]
+		public bool OwnerDraw {
+			get { return ownerdraw; }
+			set { ownerdraw = value; }
+		}
+
+		[Browsable(false)]
+		public Menu Parent {
+			get { return parent_menu;}
+		}
+
+		[DefaultValue(false)]
+		public bool RadioCheck {
+			get { return radiocheck; }
+			set {
+				if (radiocheck == value)
+					return;
+				
+				radiocheck = value;
+
+				// UIA Framework Event: Checked Changed
+				OnUIARadioCheckChanged (EventArgs.Empty);
+			}
+		}
+
+		[DefaultValue(Shortcut.None)]
+		[Localizable(true)]
+		public Shortcut Shortcut {
+			get { return shortcut;}
+			set {
+				if (!Enum.IsDefined (typeof (Shortcut), value))
+					throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for Shortcut", value));
+
+				shortcut = value;
+				UpdateMenuItem ();
+			}
+		}
+
+		[DefaultValue(true)]
+		[Localizable(true)]
+		public bool ShowShortcut {
+			get { return showshortcut;}
+			set { showshortcut = value; }
+		}
+
+		[Localizable(true)]
+		public string Text {
+			get { return text; }
+			set {
+				text = value;
+
+				if (text == "-")
+					separator = true;
+				else
+					separator = false;
+
+				// UIA Framework Event: Text Changed
+				OnUIATextChanged (EventArgs.Empty);
+
+				ProcessMnemonic ();
+				Invalidate ();
+			}
+		}
+
+		[DefaultValue(true)]
+		[Localizable(true)]
+		public bool Visible {
+			get { return visible;}
+			set { 
+				if (value == visible)
+					return;
+
+				visible = value;
+
+				if (menu_items != null) {
+					foreach (MenuItem mi in menu_items)
+						mi.Visible = value;
+				}
+
+				if (parent_menu != null)
+					parent_menu.OnMenuChanged (EventArgs.Empty);
+			}
+		}
+
+		#endregion Public Properties
+
+		#region Private Properties
+
+		internal new int Height {
+			get { return bounds.Height; }
+			set { bounds.Height = value; }
+		}
+
+		internal bool IsPopup {
+			get {
+				if (menu_items.Count > 0)
+					return true;
+				else
+					return false;
+			}
+		}
+		
+		internal bool MeasureEventDefined {
+			get { 
+				if (ownerdraw == true && Events [MeasureItemEvent] != null) {
+					return true;
+				} else {
+					return false;
+				}
+			}
+		}
+		
+		internal bool MenuBar {
+			get { return menubar; }
+			set { menubar = value; }
+		}
+		
+		internal int MenuHeight {
+			get { return menuheight; }
+			set { menuheight = value; }
+		}	
+
+		bool selected;
+		internal bool Selected {
+			get { return selected; }
+			set { selected = value; }
+		}
+
+		internal bool Separator {
+			get { return separator; }
+			set { separator = value; }
+		}
+		
+		internal DrawItemState Status {
+			get {
+				DrawItemState status = DrawItemState.None;
+				MenuTracker tracker = Parent.Tracker;
+				if (Selected)
+					status |= (tracker.active || tracker.Navigating ? DrawItemState.Selected : DrawItemState.HotLight);
+				if (!Enabled)
+					status |= DrawItemState.Grayed | DrawItemState.Disabled;
+				if (Checked)
+					status |= DrawItemState.Checked;
+				if (!tracker.Navigating)
+					status |= DrawItemState.NoAccelerator;
+				return status;
+			}
+		}
+		
+		internal bool VisibleItems {
+			get { 
+				if (menu_items != null) {
+					foreach (MenuItem mi in menu_items)
+						if (mi.Visible)
+							return true;
+				}
+				return false;
+			}
+		}
+
+		internal new int Width {
+			get { return bounds.Width; }
+			set { bounds.Width = value; }
+		}
+
+		internal new int X {
+			get { return bounds.X; }
+			set { bounds.X = value; }
+		}
+
+		internal int XTab {
+			get { return xtab; }
+			set { xtab = value; }
+		}
+
+		internal new int Y {
+			get { return bounds.Y; }
+			set { bounds.Y = value; }
+		}
+
+		#endregion Private Properties
+
+		#region Public Methods
+
+		public virtual MenuItem CloneMenu ()
+		{
+			MenuItem item = new MenuItem ();
+			item.CloneMenu (this);
+			return item;
+		}
+
+		protected void CloneMenu (MenuItem itemSrc)
+		{
+			base.CloneMenu (itemSrc); // Copy subitems
+
+			// Window list
+			MdiList = itemSrc.MdiList;
+			is_window_menu_item = itemSrc.is_window_menu_item;
+			// Remove items corresponding to window menu items, and add new items
+			// (Otherwise window menu items would show up twice, since the PopulateWindowMenu doesn't
+			// now them)
+			bool populated = false;
+			for (int i = MenuItems.Count - 1; i >= 0; i--) {
+				if (MenuItems [i].is_window_menu_item) {
+					MenuItems.RemoveAt (i);
+					populated = true;
+				}
+			}
+			if (populated)
+				PopulateWindowMenu ();
+
+			// Properties
+			BarBreak = itemSrc.BarBreak;
+			Break = itemSrc.Break;
+			Checked = itemSrc.Checked;
+			DefaultItem = itemSrc.DefaultItem;
+			Enabled = itemSrc.Enabled;			
+			MergeOrder = itemSrc.MergeOrder;
+			MergeType = itemSrc.MergeType;
+			OwnerDraw = itemSrc.OwnerDraw;
+			//Parent = menuitem.Parent;
+			RadioCheck = itemSrc.RadioCheck;
+			Shortcut = itemSrc.Shortcut;
+			ShowShortcut = itemSrc.ShowShortcut;
+			Text = itemSrc.Text;
+			Visible = itemSrc.Visible;
+			Name = itemSrc.Name;
+			Tag = itemSrc.Tag;
+
+			// Events
+			Events[ClickEvent] = itemSrc.Events[ClickEvent];
+			Events[DrawItemEvent] = itemSrc.Events[DrawItemEvent];
+			Events[MeasureItemEvent] = itemSrc.Events[MeasureItemEvent];
+			Events[PopupEvent] = itemSrc.Events[PopupEvent];
+			Events[SelectEvent] = itemSrc.Events[SelectEvent];
+		}
+
+		protected override void Dispose (bool disposing)
+		{
+			if (disposing && parent_menu != null)
+				parent_menu.MenuItems.Remove (this);
+				
+			base.Dispose (disposing);			
+		}
+
+		// This really clones the item
+		public virtual MenuItem MergeMenu ()
+		{
+			MenuItem item = new MenuItem ();
+			item.CloneMenu (this);
+			return item;
+		}
+
+		public void MergeMenu (MenuItem itemSrc)
+		{
+			base.MergeMenu (itemSrc);
+		}
+
+		protected virtual void OnClick (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [ClickEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnDrawItem (DrawItemEventArgs e)
+		{
+			DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+
+		protected virtual void OnInitMenuPopup (EventArgs e)
+		{
+			OnPopup (e);
+		}
+
+		protected virtual void OnMeasureItem (MeasureItemEventArgs e)
+		{
+			if (!OwnerDraw)
+				return;
+
+			MeasureItemEventHandler eh = (MeasureItemEventHandler)(Events [MeasureItemEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnPopup (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [PopupEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		protected virtual void OnSelect (EventArgs e)
+		{
+			EventHandler eh = (EventHandler)(Events [SelectEvent]);
+			if (eh != null)
+				eh (this, e);
+		}
+
+		public void PerformClick ()
+		{
+			OnClick (EventArgs.Empty);
+		}
+
+		public virtual void PerformSelect ()
+		{
+			OnSelect (EventArgs.Empty);
+		}
+
+		public override string ToString ()
+		{
+			return base.ToString () + ", Items.Count: " + MenuItems.Count + ", Text: " + text;
+		}
+
+		#endregion Public Methods
+
+		#region Private Methods
+
+		internal virtual void Invalidate ()
+		{
+			if ((Parent == null) || !(Parent is MainMenu) || (Parent.Wnd == null))
+				return;
+				
+			Form form = Parent.Wnd.FindForm ();
+			if ((form == null) || (!form.IsHandleCreated))
+				return;
+			
+			XplatUI.RequestNCRecalc (form.Handle);
+		}
+
+		internal void PerformPopup ()
+		{
+			OnPopup (EventArgs.Empty);
+		}
+
+		internal void PerformDrawItem (DrawItemEventArgs e)
+		{
+			PopulateWindowMenu ();
+			if (OwnerDraw)
+				OnDrawItem (e);
+			else
+				ThemeEngine.Current.DrawMenuItem (this, e);
+		}
+		
+		private void PopulateWindowMenu ()
+		{
+			if (mdilist) {
+				if (mdilist_items == null) {
+					mdilist_items = new Hashtable ();
+					mdilist_forms = new Hashtable ();
+				}
+				
+				do {
+					MainMenu main = GetMainMenu ();
+					if (main == null || main.GetForm () == null)
+						break;
+
+					Form form = main.GetForm ();
+					mdicontainer = form.MdiContainer;
+					if (mdicontainer == null)
+						break;
+
+					
+					// Remove closed forms
+					MenuItem[] items = new MenuItem[mdilist_items.Count];
+					mdilist_items.Keys.CopyTo (items, 0);
+					foreach (MenuItem item in items) {
+						Form mdichild = (Form) mdilist_items [item];
+						if (!mdicontainer.mdi_child_list.Contains(mdichild)) {
+							mdilist_items.Remove (item);
+							mdilist_forms.Remove (mdichild);
+							MenuItems.Remove (item);
+						}
+					}
+					
+					// Add new forms and update state for existing forms.
+					for (int i = 0; i < mdicontainer.mdi_child_list.Count; i++) {
+						Form mdichild = (Form)mdicontainer.mdi_child_list[i];
+						MenuItem item;
+						if (mdilist_forms.Contains (mdichild)) {
+							item = (MenuItem) mdilist_forms [mdichild];
+						} else {
+							item = new MenuItem ();
+							item.is_window_menu_item = true;
+							item.Click += new EventHandler (MdiWindowClickHandler);
+							mdilist_items [item] = mdichild;
+							mdilist_forms [mdichild] = item;
+							MenuItems.AddNoEvents (item);
+						}
+						item.Visible = mdichild.Visible;
+						item.Text = "&" + (i + 1).ToString () + " " + mdichild.Text;
+						item.Checked = form.ActiveMdiChild == mdichild;
+					}
+				} while (false);
+			} else {
+				// Remove all forms
+				if (mdilist_items != null) {
+					foreach (MenuItem item in mdilist_items.Values) {
+						MenuItems.Remove (item);
+					}
+					
+					mdilist_forms.Clear ();
+					mdilist_items.Clear ();
+				}
+			}
+		}
+		
+		internal void PerformMeasureItem (MeasureItemEventArgs e)
+		{
+			OnMeasureItem (e);
+		}
+
+		private void ProcessMnemonic ()
+		{
+			if (text == null || text.Length < 2) {
+				mnemonic = '\0';
+				return;
+			}
+
+			bool bPrevAmp = false;
+			for (int i = 0; i < text.Length -1 ; i++) {
+				if (text[i] == '&') {
+					if (bPrevAmp == false &&  (text[i+1] != '&')) {
+						mnemonic = Char.ToUpper (text[i+1]);
+						return;
+					}
+
+					bPrevAmp = true;
+				}
+				else
+					bPrevAmp = false;
+			}
+
+			mnemonic = '\0';
+		}
+
+		private string GetShortCutTextCtrl () { return "Ctrl"; }
+		private string GetShortCutTextAlt () { return "Alt"; }
+		private string GetShortCutTextShift () { return "Shift"; }		
+
+		internal string GetShortCutText ()
+		{
+			/* Ctrl+A - Ctrl+Z */
+			if (Shortcut >= Shortcut.CtrlA && Shortcut <= Shortcut.CtrlZ)
+				return GetShortCutTextCtrl () + "+" + (char)((int) 'A' + (int)(Shortcut - Shortcut.CtrlA));
+
+			/* Alt+0 - Alt+9 */
+			if (Shortcut >= Shortcut.Alt0 && Shortcut <= Shortcut.Alt9)
+				return GetShortCutTextAlt () + "+" + (char)((int) '0' + (int)(Shortcut - Shortcut.Alt0));
+
+			/* Alt+F1 - Alt+F2 */
+			if (Shortcut >= Shortcut.AltF1 && Shortcut <= Shortcut.AltF9)
+				return GetShortCutTextAlt () + "+F" + (char)((int) '1' + (int)(Shortcut - Shortcut.AltF1));
+
+			/* Ctrl+0 - Ctrl+9 */
+			if (Shortcut >= Shortcut.Ctrl0 && Shortcut <= Shortcut.Ctrl9)
+				return GetShortCutTextCtrl () + "+" + (char)((int) '0' + (int)(Shortcut - Shortcut.Ctrl0));
+							
+			/* Ctrl+F0 - Ctrl+F9 */
+			if (Shortcut >= Shortcut.CtrlF1 && Shortcut <= Shortcut.CtrlF9)
+				return GetShortCutTextCtrl () + "+F" + (char)((int) '1' + (int)(Shortcut - Shortcut.CtrlF1));
+				
+			/* Ctrl+Shift+0 - Ctrl+Shift+9 */
+			if (Shortcut >= Shortcut.CtrlShift0 && Shortcut <= Shortcut.CtrlShift9)
+				return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+" + (char)((int) '0' + (int)(Shortcut - Shortcut.CtrlShift0));
+				
+			/* Ctrl+Shift+A - Ctrl+Shift+Z */
+			if (Shortcut >= Shortcut.CtrlShiftA && Shortcut <= Shortcut.CtrlShiftZ)
+				return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+" + (char)((int) 'A' + (int)(Shortcut - Shortcut.CtrlShiftA));
+
+			/* Ctrl+Shift+F1 - Ctrl+Shift+F9 */
+			if (Shortcut >= Shortcut.CtrlShiftF1 && Shortcut <= Shortcut.CtrlShiftF9)
+				return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+F" + (char)((int) '1' + (int)(Shortcut - Shortcut.CtrlShiftF1));
+				
+			/* F1 - F9 */
+			if (Shortcut >= Shortcut.F1 && Shortcut <= Shortcut.F9)
+				return "F" + (char)((int) '1' + (int)(Shortcut - Shortcut.F1));
+				
+			/* Shift+F1 - Shift+F9 */
+			if (Shortcut >= Shortcut.ShiftF1 && Shortcut <= Shortcut.ShiftF9)
+				return GetShortCutTextShift () + "+F" + (char)((int) '1' + (int)(Shortcut - Shortcut.ShiftF1));
+			
+			/* Special cases */
+			switch (Shortcut) {
+				case Shortcut.AltBksp:
+					return "AltBksp";
+				case Shortcut.AltF10:
+					return GetShortCutTextAlt () + "+F10";
+				case Shortcut.AltF11:
+					return GetShortCutTextAlt () + "+F11";
+				case Shortcut.AltF12:
+					return GetShortCutTextAlt () + "+F12";
+				case Shortcut.CtrlDel:		
+					return GetShortCutTextCtrl () + "+Del";
+				case Shortcut.CtrlF10:
+					return GetShortCutTextCtrl () + "+F10";
+				case Shortcut.CtrlF11:
+					return GetShortCutTextCtrl () + "+F11";
+				case Shortcut.CtrlF12:
+					return GetShortCutTextCtrl () + "+F12";
+				case Shortcut.CtrlIns:
+					return GetShortCutTextCtrl () + "+Ins";
+				case Shortcut.CtrlShiftF10:
+					return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+F10";
+				case Shortcut.CtrlShiftF11:
+					return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+F11";
+				case Shortcut.CtrlShiftF12:
+					return GetShortCutTextCtrl () + "+" + GetShortCutTextShift () + "+F12";
+				case Shortcut.Del:
+					return "Del";
+				case Shortcut.F10:
+					return "F10";	
+				case Shortcut.F11:
+					return "F11";	
+				case Shortcut.F12:
+					return "F12";	
+				case Shortcut.Ins:
+					return "Ins";	
+				case Shortcut.None:
+					return "None";	
+				case Shortcut.ShiftDel:
+					return GetShortCutTextShift () + "+Del";
+				case Shortcut.ShiftF10:
+					return GetShortCutTextShift () + "+F10";
+				case Shortcut.ShiftF11:
+					return GetShortCutTextShift () + "+F11";
+				case Shortcut.ShiftF12:
+					return GetShortCutTextShift () + "+F12";				
+				case Shortcut.ShiftIns:
+					return GetShortCutTextShift () + "+Ins";
+				default:
+					break;
+				}
+				
+			return "";
+		}
+
+		private void MdiWindowClickHandler (object sender, EventArgs e)
+		{
+			Form mdichild = (Form) mdilist_items [sender];
+
+			// people could add weird items to the Window menu
+			// so we can't assume its just us
+			if (mdichild == null)
+				return;
+
+			mdicontainer.ActivateChild (mdichild);
+		}
+
+		private void UpdateMenuItem ()
+		{
+			if ((parent_menu == null) || (parent_menu.Tracker == null))
+				return;
+
+			parent_menu.Tracker.RemoveShortcuts (this);
+			parent_menu.Tracker.AddShortcuts (this);
+		}
+
+		#endregion Private Methods
+
+	}
+}
+
+