912 lines
22 KiB
C#
912 lines
22 KiB
C#
// 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, jordi@ximian.com
|
|
//
|
|
//
|
|
|
|
// NOT COMPLETE
|
|
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Drawing;
|
|
using System.Drawing.Text;
|
|
|
|
namespace System.Windows.Forms
|
|
{
|
|
[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
|
|
|
|
}
|
|
}
|
|
|
|
|