/// <summary>*******************************************************************************************************
/// **************************** DO NOT DELETE THIS CODE ****************************
/// *********************************************************************************************** This
/// method refreshes the enabling of internal event menu entries. It is activated when the menu is
/// displayed.
///
/// NOTE: currently not used - we refresh all action menu entries when the action is enabled\disabled. But,
/// we may decide to use this method instead, due to performance issues. If we decide to use this, we need
/// to add the SWT.Show to the listeber.
///
/// </summary>
/// <param name="widget">-
/// on which show was received
/// </param>
/*
* private void menuShow (Widget widget) { Menu menu = null; MgMenu mgMenu = null; MenuEntryMenu
* menuEntryMenu = null; MenuEntry menuEntry = null; MgForm form = null;
*
* if (widget instanceof Menu) { menu = (Menu)widget; Object data = menu.getData(); int style =
* menu.getStyle(); MenuStyle menuStyle = (style == SWT.POP_UP ? MenuStyle.MENU_STYLE_CONTEXT :
* MenuStyle.MENU_STYLE_PULLDOWN);
*
* form = (MgForm)menu.getShell().getData(); if (data instanceof MgMenu) { mgMenu = (MgMenu) data;
* mgMenu.refreshInternalEventMenus(form); } else if (data instanceof MenuEntryMenu) { menuEntryMenu =
* (MenuEntryMenu)data; menuEntryMenu.refreshActionMenus(form, menuStyle); } } else if (widget instanceof
* MenuItem) { MenuItem menuItem = (MenuItem)widget; menuEntry = (MenuEntry)menuItem.getData(); } }
*/
/// <summary> This mdthod takes care of toolitem's prompt - we get the mouse move \ mouse exit event on the toolbar.
///
/// </summary>
/// <param name="event">-
/// the event which occured.
/// </param>
private void onItemEnterLeave(ToolStripItem menuItem, EventType type)
{
GuiMenuEntry guiMenuEntry = null;
GuiMgForm guiMgForm = null;
ControlsMap controlsMap = ControlsMap.getInstance();
MapData mapData = controlsMap.getMapData(menuItem);
MenuReference menuRef = mapData.getMenuReference();
guiMgForm = menuRef.GetMgForm();
if (type == EventType.MOUSE_ENTER)
{
guiMenuEntry = ((TagData)menuItem.Tag).guiMenuEntry;
// handle tooltip
if (menuItem is ToolStripButton)
{
String tooltipStrMLS = Events.Translate(guiMenuEntry.ToolTip);
if (tooltipStrMLS == null)
{
tooltipStrMLS = "";
}
menuItem.ToolTipText = tooltipStrMLS;
}
}
Events.OnMenuPrompt(guiMgForm, (GuiMenuEntry)guiMenuEntry);
}
/// <summary>
/// handle the context of a control
/// </summary>
/// <param name = "widget">:
/// is the widget of the control \ tab \ table
/// </param>
/// <param name = "ctrl">
/// </param>
private void handleContext(Control control, GuiMgControl guiMgControl, GuiMgForm guiMgForm)
{
ControlsMap controlsMap = ControlsMap.getInstance();
GuiMgMenu contextMenu = null;
ContextMenu menu = null;
ContextMenu prevMenu = (ContextMenu)control.ContextMenu;
if (guiMgControl != null)
{
contextMenu = Events.OnGetContextMenu(guiMgControl);
Form form = GuiUtilsBase.FindForm(control);
MapData mapData = controlsMap.getFormMapData(form);
guiMgForm = mapData.getForm();
}
else
{
contextMenu = Events.OnGetContextMenu(guiMgForm);
}
if (contextMenu != null)
{
MenuReference menuRefernce = contextMenu.getInstantiatedMenu(guiMgForm, MenuStyle.MENU_STYLE_CONTEXT);
menu = (ContextMenu)controlsMap.object2Widget(menuRefernce);
}
if (menu != prevMenu)
{
GuiUtilsBase.setContextMenu(control, menu);
}
}
/// <summary>
/// returns the form of the menu which was activated.
/// </summary>
/// <param> Object menuObj
/// </param>
/// <returns> The form which the menu belongs to.
/// </returns>
private GuiMgForm menuObjToForm(Object menuObj)
{
ControlsMap controlsMap = ControlsMap.getInstance();
MapData mapData = controlsMap.getMapData(menuObj);
MenuReference menuRef = mapData.getMenuReference();
GuiMgForm guiMgForm = menuRef.GetMgForm();
return(guiMgForm);
}
/// <summary> returns the form of the menu which was activated.
/// </summary>
/// <param> Object menuObj
/// </param>
/// <returns> The form which the menu belongs to.
/// </returns>
private Form menuObjToForm(Object menuObj)
{
Form form = null;
GuiMgForm guiMgForm;
ControlsMap controlsMap = ControlsMap.getInstance();
MapData mapData = controlsMap.getMapData(menuObj);
MenuReference menuRef = mapData.getMenuReference();
guiMgForm = menuRef.GetMgForm();
form = GuiUtils.FindForm((Control)controlsMap.object2Widget(guiMgForm));
return(form);
}
/// <summary> This method returns the current context menu. In case a context menu is not set on the object itself, we
/// get the parent's context menu
/// </summary>
internal ContextMenu getContextMenu()
{
ControlsMap controlsMap = ControlsMap.getInstance();
ContextMenu ret = base.ContextMenu;
if (ret == null)
{
GuiMgMenu contextMenu = Events.OnGetContextMenu(GuiMgControl);
if (contextMenu != null)
{
Form form = GuiUtils.FindForm(_tableControl);
MapData mapData = controlsMap.getFormMapData(form);
MenuReference menuRefernce = contextMenu.getInstantiatedMenu(mapData.getForm(), MenuStyle.MENU_STYLE_CONTEXT);
ret = (ContextMenu)controlsMap.object2Widget(menuRefernce);
}
}
return(ret);
}
/// <summary>
/// </summary>
/// <param name = "MenuRef">menu reference</param>
internal MapData(MenuReference MenuRef)
{
_menuRef = MenuRef;
}
/*
* (non-Javadoc)
* For ContextMenu : MENU_OPENING replaces the SWT's MenuDetect. Since there is no such handler on a control, we needed a way
* to block the system's menu and show nothing in case there was no context menu assigned by the user. We also need to decide on
* the correct context menu before it opens.
* We do that by assigning a new and empty context menu for each control that is created.
* When the user right clicks on a control, the empty context (or a real context) shoots a MENU_OPENING.
* In this point do a few things :
* 1. If this is the 1st opening event for that click, we need to decide if that is the correct menu to be opened.
* In case its the 2nd time, the 'ContextCanOpen' flag will be true, verifying that we don't need to check the menu.
* 2. To check the menu we have separate methods for table controls and other controls.
* each type will have its own 'handleContextMenu'.
* * In table, if the clicked cell is already in edit mode, then the control we'll get here will be already a regular edit box.
* 3. In case we have discovered that the correct menu to be showed is not the one that had sent us the 'OPENING' event,
* we will cancel its opening and insteed we will set the 'ContextCanOpen' to true and call the ContextMenuStrip.Show ourselves.
* That way the correct menu will be opened.
*/
internal override void handleEvent(EventType type, Object sender, EventArgs e)
{
MapData mapData;
GuiMgForm guiMgForm = null;
MenuReference menuRef = null;
ControlsMap controlsMap;
Manager.ContextIDGuard contextIDGuard = null;
mapData = ControlsMap.getInstance().getMapData(sender);
if (mapData != null)
{
menuRef = mapData.getMenuReference();
guiMgForm = menuRef.GetMgForm();
if (guiMgForm != null)
{
contextIDGuard = new Manager.ContextIDGuard(Manager.GetContextID(guiMgForm));
}
}
try
{
switch (type)
{
// Only ContexMenuStrip and ToolStripMenuItem can be opened. A MenuStrip is never opened, only its childs which are items.
// *** see also comment above.
case EventType.MENU_OPENING:
// only if the context itself is opening
// the purpose is to determine the correct menu to be opened on the control. (substitude to the SWT.MENU_DETECT).
if (sender is ContextMenuStrip && !((TagData)((ContextMenuStrip)sender).Tag).ContextCanOpen)
{
ContextMenuStrip contextMenu = (ContextMenuStrip)sender;
Control control = contextMenu.SourceControl;
GuiMgControl guiMgControl = null;
controlsMap = ControlsMap.getInstance();
if (control is Form)
{
// in case of form control, the real control is its panel
control = ((TagData)(control.Tag)).ClientPanel;
}
/*Defect 131535 :
* After 3.1 the MDIClient is covered with a Panel with FitToMDI.
* In the defect scenario when user presses the right click on online form and keeping the right click pressed drags the cursor to MDI form and then leaves the button
* then, somehow we get the SourceControl of the context menu as MDIClient.
* But the MDIClient is not saved in ControlsMap anymore.
* In order to fix the problem whenever we get the SourceControl of context menu as MDIClient set it to MgPanel obtained from it's parent's (GuiForm) ClientPanel.*/
if (control is System.Windows.Forms.MdiClient)
{
GuiForm guiForm = (GuiForm)control.Parent;
control = ((TagData)guiForm.Tag).ClientPanel;
}
ContainerManager containerManager = ((TagData)(control.Tag)).ContainerManager;
if (containerManager is TableManager || containerManager is TreeManager || containerManager is BasicControlsManager)
{
// Use the mouse pos to determine in which row and column we are at.
// We cannot use the contextMenu.Left\Top, since its not always the point from which the cursor was opened.
// If the menu was opened via keyboard, we will not get here , since the control will be not table control but the cell control itself.
Point MousePos = Control.MousePosition;
// get the relative location on the menu within the container.
Point pt = control.PointToClient(new Point(MousePos.X, MousePos.Y));
mapData = containerManager.HitTest(pt, true, true);
if (mapData == null)
{
if (containerManager is TableManager)
{
GuiUtils.setTooltip(control, "");
}
else
{
if (control is Panel && ((TagData)(control.Tag)).ContainerTabControl != null)
{
// in case its the tab panel, the control will be the tab control
control = ((TagData)(control.Tag)).ContainerTabControl;
}
mapData = controlsMap.getMapData(control);
}
}
}
else
{
mapData = controlsMap.getMapData(control);
}
// Do not go in here if tableManager.handleContextMenu was executed.
if (mapData != null)
{
bool focusChanged = false;
guiMgControl = mapData.getControl();
bool onMultiMark = false;
if (containerManager == null && ((TagData)control.Tag).IsEditor)
{
Object obj = controlsMap.object2Widget(guiMgControl, mapData.getIdx());
if (obj is LogicalControl)
{
containerManager = ((LogicalControl)obj).ContainerManager;
}
}
if (containerManager is ItemsManager)
{
onMultiMark = ((ItemsManager)containerManager).IsItemMarked(mapData.getIdx());
}
focusChanged = Events.OnBeforeContextMenu(guiMgControl, mapData.getIdx(), onMultiMark);
//If the focus was changed, the control must have been saved as the focussing control.
//So, remove it from here.
if (focusChanged)
{
GuiUtils.removeFocusingControl(GuiUtils.FindForm(control));
}
GuiUtils.setTooltip(control, "");
}
// Cancel the opening of the context, as we will be handling it thr' event.
((CancelEventArgs)e).Cancel = true;
// Add Event to Open a Context Menu, So, that it should be opened after the event added by
// OnBeforeContextMenu event.
int line = mapData != null?mapData.getIdx() : 0;
// If right click in on table control and not any control attached to table control
if (control is TableControl && guiMgControl == null)
{
guiMgControl = controlsMap.getMapData(control).getControl();
}
// Invoke the event to open a context menu.
Events.OnOpenContextMenu(guiMgControl, mapData != null ? mapData.getForm() : null,
contextMenu.Left, contextMenu.Top, line);
return;
}
else
{
mapData = ControlsMap.getInstance().getMapData(sender);
if (mapData == null)
{
break;
}
menuRef = mapData.getMenuReference();
guiMgForm = menuRef.GetMgForm();
if (sender is MgToolStripMenuItem)
{
// This change is to improve performance of pulldown menu. When we apply modality, (while opening a batch task).
// We just disable menu items on GuiMenuEntry. actual menu is diabled in .ent whe
foreach (ToolStripItem item in ((ToolStripMenuItem)sender).DropDownItems)
{
if (item is MgToolStripMenuItem)
{
TagData tagData1 = (TagData)((MgToolStripMenuItem)item).Tag;
GuiMenuEntry guiMenuEntry1 = tagData1.guiMenuEntry;
if (!(guiMenuEntry1 is MenuEntryEvent || guiMenuEntry1 is MenuEntryMenu))
{
if (guiMenuEntry1.getModalDisabled() && (item.Enabled == guiMenuEntry1.getModalDisabled()))
{
item.Enabled = false;
}
else if (!item.Enabled && (guiMenuEntry1.getEnabled() == true))
{
item.Enabled = guiMenuEntry1.getEnabled();
}
}
}
}
// Create windowMenu items for MgToolStripMenuItem (Only sub-menus can define window menu)
TagData tagData = (TagData)((MgToolStripMenuItem)sender).Tag;
Events.InitWindowListMenuItems(guiMgForm, tagData.guiMenuEntry, tagData.MenuStyle);
}
}
// we get here in 3 cases :
// 1. ContextCanOpen is true. i.e. we have a confirmation to open. we are already in the recursive call.
// 2. We are in the original opening, but this is the correct menu.
// 3. This is a ToolStripMenuItem (i.e. not the context menu itself.
//when opening a menu (pulldown or context), check if paste action
//should be enabled/disabled.
//Don't check for dummy, no need. also, if u try : getLastFocusedControl will throw exception since dummy don't have mapData.
// Dummy is only relevant in context menu (not in drop down).
if (!(sender is ContextMenuStrip && ((ContextMenuStrip)sender).Name == "Dummy"))
{
//Call to checkPasteEnable() was introduced for QCR# 241365 in Java RC.
//This code is added for following situation:
//If there are 3 fields a, b, c. Field C has modifiable = No.
//If contex menu of fields a and b show paste as enabled, then the modifiable=no field will also show paste enabled...
//and it shouldn't.
//When we are on 3rd field, tab to another window and get back (to loose and regain focus)
//now, the paste is disabled on c as it should...but tab to the other fields, now the paste is disabled for them as well.
//to make paste enabled for Modifiable fields, this call is required here.
GuiMgControl guiMgControl = getLastFocusedControl(sender);
GuiUtils.checkPasteEnable(guiMgControl, true);
}
return;
// Select event can happen ONLY on MenuItem, not on Menu. (see addHandler).
case EventType.MENU_ITEM_SELECTED:
onSelection(sender);
break;
case EventType.MOUSE_ENTER:
onItemEnterLeave((ToolStripItem)sender, type);
break;
case EventType.MOUSE_LEAVE:
onItemEnterLeave((ToolStripItem)sender, type);
break;
case EventType.CLOSED:
if (sender is ContextMenuStrip)
{
ToolStrip menu = (ToolStrip)sender;
if (((ContextMenuStrip)sender).Name == "Dummy")
{
break;
}
//Current context menu will be disposed , So, create the dummy context menu for control.
Control control = ((TagData)menu.Tag).MouseDownOnControl;
GuiUtils.setContextMenu(control, null);
//Dispose context Menu.
GuiMgMenu mgMenu = ((TagData)menu.Tag).GuiMgMenu;
Events.OnContextMenuClose(menuRef.GetMgForm(), mgMenu);
}
break;
case EventType.DISPOSED:
controlsMap = ControlsMap.getInstance();
GuiMenuEntry guiMenuEntry = null;
if (sender is ContextMenuStrip && ((ContextMenuStrip)sender).Name == "Dummy")
{
break;
}
mapData = controlsMap.getMapData(sender);
if (mapData == null)
{
break;
}
menuRef = mapData.getMenuReference();
guiMgForm = menuRef.GetMgForm();
if (guiMgForm != null)
{
if (sender is ToolStripItem)
{
ToolStripItem menuItem = (ToolStripItem)sender;
MenuStyle menuStyle = ((TagData)menuItem.Tag).MenuStyle;
guiMenuEntry = ((TagData)menuItem.Tag).guiMenuEntry;
guiMenuEntry.removeMenuIsInstantiated(guiMgForm, menuStyle);
//if (menuEntry is MenuEntryMenu)
// menuEntry.removeInstantiatedMenuItems(mgForm, menuStyle);
if ((guiMenuEntry.ImageFile != null) && menuItem.Image != null)
{
menuItem.Image.Dispose();
}
menuItem.Tag = null;
}
else if (sender is ToolStrip)
{
ToolStrip menu = (ToolStrip)sender;
MenuStyle menuStyle = ((TagData)menu.Tag).MenuStyle;
if (((TagData)menu.Tag).GuiMgMenu != null)
{
GuiMgMenu mgMenu = ((TagData)menu.Tag).GuiMgMenu;
mgMenu.removeInstantiatedMenu(guiMgForm, menuStyle);
}
//else if (((TagData)menu.Tag).menuEntry != null)
//{
// MenuEntry mgMenu = ((TagData)menu.Tag).menuEntry;
// menuEntry.removeInstantiatedMenuItems(mgForm, menuStyle);
//}
menu.Tag = null;
}
}
if (menuRef != null)
{
Object fromMap = controlsMap.object2Widget(menuRef);
if (fromMap != null)
{
controlsMap.remove(menuRef);
}
}
break;
case EventType.KEY_DOWN:
{
if (((KeyEventArgs)e).KeyCode == Keys.F1)
{
ToolStrip menu = (ToolStrip)sender;
foreach (ToolStripItem menuItem in menu.Items)
{
if (menuItem.CanSelect && menuItem.Selected)
{
guiMenuEntry = ((TagData)menuItem.Tag).guiMenuEntry;
if (guiMenuEntry.Help > 0)
{
if (menu.IsDropDown)
{
// Defect Id 115414: If help is opened then menu needs to be closed. After closing the menu focus should not be on the menu.
// Same like when menu is clicked.ToolStripDropDownCloseReason.ItemClicked option closes the menu and
// focus does not remains on the menu.
((ToolStripDropDownMenu)menu).Close(ToolStripDropDownCloseReason.ItemClicked);
}
Events.OnHelpInVokedOnMenu(guiMenuEntry, ((TagData)menuItem.Tag).MapData.getMenuReference().GetMgForm());
break;
}
}
}
}
else
{
if (MnemonicHelper.HandleMnemonicForHebrew((ToolStrip)sender, (char)((KeyEventArgs)e).KeyCode))
{
((KeyEventArgs)e).Handled = true;
}
}
}
break;
default:
System.Console.Out.WriteLine(type.ToString());
break;
}
}
finally
{
if (contextIDGuard != null)
{
contextIDGuard.Dispose();
}
}
}
/// <summary> handle the context of a control
///
/// </summary>
/// <param name="widget">:
/// is the widget of the control \ tab \ table
/// </param>
/// <param name="ctrl">
/// </param>
public void handleContext(Control control, GuiMgControl guiMgControl, GuiMgForm guiMgForm)
{
ControlsMap controlsMap = ControlsMap.getInstance();
GuiMgMenu contextMenu = null;
ContextMenuStrip menu = null;
ContextMenuStrip prevMenu = control.ContextMenuStrip;
GuiMgForm controlsForm = guiMgForm;
if (guiMgControl != null)
{
// save the form that holds the control.
if (guiMgControl.isSubform())
{
controlsForm = guiMgForm;
}
else
{
controlsForm = guiMgControl.GuiMgForm;
}
contextMenu = Events.OnGetContextMenu(guiMgControl);
Form form = GuiUtils.FindForm(control);
MapData mapData = controlsMap.getFormMapData(form);
guiMgForm = mapData.getForm();
}
else
{
contextMenu = Events.OnGetContextMenu(guiMgForm);
}
if (contextMenu != null)
{
MenuReference menuRefernce = contextMenu.getInstantiatedMenu(guiMgForm, MenuStyle.MENU_STYLE_CONTEXT);
menu = (ContextMenuStrip)controlsMap.object2Widget(menuRefernce);
}
// Fix bug#:927653, problem #2, when set context menu to the control need to refresh the event on the context menu
// because on MgForm :instatiatedMenus is one per form per style (the style is the key) and it keeps only the menu
// created for the last child of the form.
// Qcr #909188 : Use the controlsForm to refresh menus action and not the 'form' which might be topmost.
// The reason is that the form sent to OnRefreshMenuActions has to point to the task that holds the
// control because it holds the relevant 'Action manager'. An action enabled for the control , might be disabled
// in the top most form's task and be wrongly disabled in the context menu.
if (controlsForm != null)
{
Events.OnRefreshMenuActions(contextMenu, controlsForm);
}
if (menu != prevMenu)
{
GuiUtils.setContextMenu(control, menu);
//Save the control on which context menu is invoked. This is required later for creating dummy context menu.
if (menu != null)
{
((TagData)menu.Tag).MouseDownOnControl = control;
}
}
}
internal override void handleEvent(EventType type, Object sender, EventArgs e)
{
MapData mapData;
GuiMgForm guiMgForm = null;
ControlsMap controlsMap;
switch (type)
{
case EventType.MENU_OPENING:
// only if the context itself is opening
// the purpose is to determine the correct menu to be opened on the control. (substitude to the SWT.MENU_DETECT).
if (sender is ContextMenu && !((TagData)((ContextMenu)sender).Tag).ContextCanOpen)
{
ContextMenu contextMenu = (ContextMenu)sender;
Control control = contextMenu.SourceControl;
controlsMap = ControlsMap.getInstance();
if (control is Form)
{
// in case of form control, the real control is its panel
control = ((TagData)(control.Tag)).ClientPanel;
}
else if (control is Panel && ((TagData)(control.Tag)).ContainerTabControl != null)
{
// in case its the tab panel, the control will be the tab control
control = ((TagData)(control.Tag)).ContainerTabControl;
}
ContainerManager containerManager = ((TagData)(control.Tag)).ContainerManager;
if (containerManager is TableManager || containerManager is BasicControlsManager)
{
// Use the mouse pos to determine in which row and column we are at.
// We cannot use the contextMenu.Left\Top, since its not always the point from which the cursor was opened.
// If the menu was opened via keyboard, we will not get here , since the control will be not table control but the cell control itself.
Point MousePos = Control.MousePosition;
// get the relative location on the menu within the container.
Point pt = control.PointToClient(new Point(MousePos.X, MousePos.Y));
mapData = containerManager.HitTest(pt, true, true);
if (mapData == null)
{
if (containerManager is TableManager)
{
// The menu is on a column or the table header.
((TableManager)containerManager).handleContextMenu(control, pt);
}
else
{
mapData = controlsMap.getMapData(control);
}
}
}
else
{
mapData = controlsMap.getMapData(control);
}
// Do not go in here if tableManager.handleContextMenu was executed.
if (mapData != null)
{
bool focusChanged = false;
GuiMgControl guiMgControl = mapData.getControl();
bool onMultiMark = false;
if (containerManager is ItemsManager)
{
onMultiMark = ((ItemsManager)containerManager).IsItemMarked(mapData.getIdx());
}
focusChanged = Events.OnBeforeContextMenu(guiMgControl, mapData.getIdx(), onMultiMark);
//If the focus was changed, the control must have been saved as the focussing control.
//So, remove it from here.
if (focusChanged)
{
GuiUtilsBase.removeFocusingControl(GuiUtilsBase.FindForm(control));
}
// set the correct context menu on the control
handleContext(control, guiMgControl, mapData.getForm());
}
// if the context has changed, it means we need to cancel the opening of the context we are in,
// and we should open another context that is already on the control.
// set its ContextCanOpen to true . open it, and then set it to false.
// if menu was not changed (even if the 'ContextCanOpen' is false) then we will continue with the opening.
// There is no need for recursive call in that case.
if (control.ContextMenu != null && control.ContextMenu != contextMenu)
{
((TagData)(((ContextMenu)control.ContextMenu).Tag)).ContextCanOpen = true;
// show the new context in the same coordinates as the opening one.
Point MousePos = Control.MousePosition;
Point pt = control.PointToClient(new Point(MousePos.X, MousePos.Y));
control.ContextMenu.Show(control, pt);
((TagData)(((ContextMenu)control.ContextMenu).Tag)).ContextCanOpen = false;
return;
}
}
return;
case EventType.MENU_ITEM_SELECTED:
onSelection(sender);
break;
case EventType.DISPOSED:
controlsMap = ControlsMap.getInstance();
MenuReference menuRef = null;
GuiMenuEntry guiMenuEntry = null;
if (sender is ContextMenu && ((ContextMenu)sender).Name == "Dummy")
{
break;
}
mapData = controlsMap.getMapData(sender);
if (mapData == null)
{
break;
}
menuRef = mapData.getMenuReference();
guiMgForm = menuRef.GetMgForm();
if (guiMgForm == null)
{
break;
}
if (sender is MenuItem)
{
MenuItem menuItem = (MenuItem)sender;
MenuStyle menuStyle = ((TagData)menuItem.Tag).MenuStyle;
guiMenuEntry = ((TagData)menuItem.Tag).guiMenuEntry;
guiMenuEntry.removeMenuIsInstantiated(guiMgForm, menuStyle);
//if (menuEntry is MenuEntryMenu)
// menuEntry.removeInstantiatedMenuItems(mgForm, menuStyle);
}
if (menuRef != null)
{
Object fromMap = controlsMap.object2Widget(menuRef);
if (fromMap != null)
{
controlsMap.remove(menuRef);
}
}
break;
default:
Console.Out.WriteLine(type.ToString());
break;
}
}