/// <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);
}
}
protected bool _realIncludesFirst; // this is includeFirst that was sent from
// the server includefirst member may be updated here, because of listview limitations
/// <summary>
/// ctor
/// </summary>
/// <param name="tableControl"></param>
/// <param name="mgControl"></param>
/// <param name="children"></param>
/// <param name="columnsCount"></param>
/// <param name="style"></param>
internal TableManagerUnlimitedItems(TableControl tableControl, GuiMgControl mgControl, List <GuiMgControl> children,
int columnsCount, int style)
: base(tableControl, mgControl, children, columnsCount, style)
{
_realIncludesFirst = _includesFirst = false;
_includesLast = false;
}
/// <summary>
/// process "collapse" event
/// </summary>
///<param name = "guiMgCtrl">the control</param>
internal void processExpand(GuiMgControl guiMgCtrl, int line)
{
var mgControl = (MgControl)guiMgCtrl;
ClientManager.Instance.EventsManager.addGuiTriggeredEvent(mgControl, line,
InternalInterface.MG_ACT_TREE_EXPAND, false);
}
/// <summary>process "collapse" event</summary>
///<param name = "guiMgCtrl">the control</param>
internal void processCollapse(GuiMgControl guiMgCtrl, int line)
{
var mgControl = (MgControl)guiMgCtrl;
ClientManager.Instance.EventsManager.addGuiTriggeredEvent(mgControl, line,
InternalInterface.MG_ACT_TREE_COLLAPSE, false);
}
/// <summary>edit tree node</summary>
///<param name = "guiMgCtrl"></param>
/// <param name = "line"></param>
internal void processEditNodeExit(GuiMgControl guiMgCtrl, int line)
{
var mgControl = (MgControl)guiMgCtrl;
ClientManager.Instance.EventsManager.addGuiTriggeredEvent(mgControl, line,
InternalInterface.MG_ACT_TREE_RENAME_RT_EXIT, false);
}
/// <summary>
/// Perform actions required when a dragged object is dropped (mouse released).
/// Put actions : ACT_CTRL_HIT or ACT_HIT and MG_ACT_BEGIN_DROP.
/// </summary>
/// <param name="guiMgForm"></param>
/// <param name="guiMgCtrl"></param>
/// <param name="line"></param>
protected virtual void processBeginDrop(GuiMgForm guiMgForm, GuiMgControl guiMgCtrl, int line)
{
MgControlBase mgControl = (MgControlBase)guiMgCtrl;
MgFormBase mgForm = (guiMgForm == null) ? mgControl.getForm() : (MgFormBase)guiMgForm;
bool isCtrlHit = (mgControl != null) ? true : false; // Drop occurs on a control or a form?
if (isCtrlHit)
{
Manager.EventsManager.addGuiTriggeredEvent(mgControl, InternalInterface.MG_ACT_CTRL_HIT, line);
if (mgControl.isSubform())
{
Manager.EventsManager.addGuiTriggeredEvent(mgControl.GetSubformMgForm().getTask(), InternalInterface.MG_ACT_BEGIN_DROP);
}
else
{
Manager.EventsManager.addGuiTriggeredEvent(mgControl, InternalInterface.MG_ACT_BEGIN_DROP, line);
}
}
else
{ // If Drop occurs on FORM.
Manager.EventsManager.addGuiTriggeredEvent(mgForm.getTask(), InternalInterface.MG_ACT_HIT);
Manager.EventsManager.addGuiTriggeredEvent(mgForm.getTask(), InternalInterface.MG_ACT_BEGIN_DROP);
}
}
/// <summary>
/// Handles external event recieved via WM_UNDO
/// </summary>
/// <param name="guiMgCtrl">ctrl to which this message is received</param>
private void OnUndo(GuiMgControl guiMgCtrl)
{
var rtEvt = new RunTimeEvent((MgControl)guiMgCtrl, ((MgControl)guiMgCtrl).getDisplayLine(false), true);
rtEvt.setInternal(InternalInterface.MG_ACT_EDT_UNDO);
ClientManager.Instance.EventsManager.addToTail(rtEvt);
}
/// <summary>
/// creates controland coordinator according to the type
/// </summary>
/// <param name = "commandType"></param>
/// <param name = "mgControl"></param>
/// <param name = "containerControl"></param>
/// <returns></returns>
internal static LogicalControl createControl(CommandType commandType, GuiMgControl guiMgControl,
Control containerControl, int mgRow, int mgColumn)
{
LogicalControl lg = createControl(commandType, guiMgControl, containerControl);
lg._mgRow = mgRow;
lg._mgColumn = mgColumn;
ContainerManager containerManager = GuiUtilsBase.getContainerManager(containerControl);
if (containerManager is TableManager)
{
TableCoordinator tableCoordinator = new TableCoordinator((TableManager)containerManager, lg, mgColumn);
lg._coordinator = tableCoordinator;
lg._editorProvider = tableCoordinator;
}
else if (containerManager is BasicControlsManager)
{
EditorSupportingCoordinator editorSupportingCoordinator = new EditorSupportingCoordinator(lg);
lg._coordinator = editorSupportingCoordinator;
lg._editorProvider = editorSupportingCoordinator;
}
else // tree
{
Debug.Assert(false);
}
return(lg);
}
/// <summary>
/// Function for getting the property value from control.
/// </summary>
/// <param name="propInfo"></param>
/// <param name="guiMgControl"></param>
/// <param name="index"></param>
/// <returns>property value</returns>
internal static Object GetPropertyValue(PropertyInfo propInfo, GuiMgControl guiMgControl, object[] index)
{
//get the dot net control
Control dotNetControl = (Control)ControlsMap.getInstance().object2Widget(guiMgControl);
return(GetPropertyValue(propInfo, dotNetControl, index));
}
/// <summary>Create Control from logical control</summary>
/// <returns></returns>
internal Control toControl(GuiMgControl guiMgControl, CommandType commandType)
{
Control control = (Control)GuiUtils.createSimpleControlForEditor(commandType, mainControl, guiMgControl);
((TagData)control.Tag).IsEditor = true;
return(control);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="tableControl"></param>
/// <param name="mgControl"></param>
/// <param name="children"></param>
/// <param name="columnsCount"></param>
/// <param name="style"></param>
internal TableManagerLimitedItems(TableControl tableControl, GuiMgControl mgControl, List <GuiMgControl> children,
int columnsCount, int style)
: base(tableControl, mgControl, children, columnsCount, style)
{
// must be inited to zero. If font of table not refreshed intitally, rollback this change.
_rowsInPage = 0;
}
/// <summary> according to shell return the last control that was in focus
/// it can be on subform \ sub sub form....
/// </summary>
/// <param name="shell">
/// </param>
/// <returns>
/// </returns>
private GuiMgControl getLastFocusedControl(Object menuObj)
{
Form form = menuObjToForm(menuObj);
ControlsMap controlsMap = ControlsMap.getInstance();
GuiMgControl guiMgControl = null;
if (form.IsMdiContainer)
{
Form activeMDIChild = GuiUtils.GetActiveMDIChild(form);
if (activeMDIChild != null)
{
form = activeMDIChild;
}
}
if (form.ActiveControl != null)
{
MapData mapData = controlsMap.getMapData(form.ActiveControl);
if (mapData != null)
{
guiMgControl = mapData.getControl();
}
}
return(guiMgControl);
}
/// <summary>this is an entry point for all objects handlers</summary>
/// <param name="objectHashCode"> hash code of the object</param>
/// <param name="eventName"> event name</param>
/// <param name="parameters">event parameters</param>
/// <returns></returns>
public static void handleDotNetEvent(int objectHashCode, String eventName, Object[] parameters)
{
Object invokedObject = DNManager.getInstance().DNObjectEventsCollection.getObject(objectHashCode);
GuiMgControl mgControl = null;
bool raiseRuntimeEvent = true;
Manager.ContextIDGuard contextIDGuard = null;
// If Object is a control and it is 'our' control (not created dynamically, decided by .Tag)
if (invokedObject is Control && ((Control)invokedObject).Tag != null)
{
ControlsMap controlsMap = ControlsMap.getInstance();
MapData mapData = controlsMap.getControlMapData((Control)invokedObject);
if (mapData == null)
{
return;
}
mgControl = mapData.getControl();
contextIDGuard = new Manager.ContextIDGuard(Manager.GetContextID(mgControl));
//first execute default magic handling of event
EventType type = DNControlEvents.getStandardEvent(eventName);
if (type != EventType.NONE && parameters.Length == 2)
{
DefaultHandler.getInstance().handleEvent(type, invokedObject, (EventArgs)parameters[1]);
}
if (eventName == "KeyDown") //QCR #736734 KeyDown is handled from Filter.cs on WM_KEYDOWN - do not duplicate the event
{
raiseRuntimeEvent = false;
}
else if (eventName == "Disposed")
{
// a Disposed event for a control can't be handled as a runtime-event after the task/form are closed
raiseRuntimeEvent = false;
}
else
{
// raise .NET runtime event only if hooked from the application (i.e. have a handler in the task)
List <String> applicationHookedDNeventsNames = ((TagData)((Control)invokedObject).Tag).ApplicationHookedDNeventsNames;
if (applicationHookedDNeventsNames == null || !applicationHookedDNeventsNames.Contains(eventName))
{
raiseRuntimeEvent = false;
}
}
}
// raise .NET event
if (raiseRuntimeEvent)
{
Events.OnDotNetEvent(invokedObject, mgControl, eventName, parameters);
}
if (contextIDGuard != null)
{
contextIDGuard.Dispose();
}
}
/// <summary>process "focus" event</summary>
/// <param name = "value">the value of the control</param>
/// <param name = "line">the line of multiline control</param>
/// <returns> TRUE if Magic internal rules allow us to perform the focus.
/// sometimes, Magic forces us to return to the original control thus FALSE will be returned.
/// </returns>
internal void processFocus(GuiMgControl guiMgCtrl, int line, bool isProduceClick, bool onMultiMark)
{
var mgControl = (MgControl)guiMgCtrl;
ClientManager.Instance.EventsManager.addGuiTriggeredEvent(mgControl, line,
InternalInterface.MG_ACT_CTRL_FOCUS,
isProduceClick);
}
/// <summary>Enable/Disable cut/copy</summary>
/// <param name = "guiMgCtrl"></param>
/// <param name = "enable"></param>
internal void processEnableCutCopy(GuiMgControl guiMgCtrl, bool enable)
{
var mgControl = (MgControl)guiMgCtrl;
var actCutCopy = new[] { InternalInterface.MG_ACT_CUT, InternalInterface.MG_ACT_CLIP_COPY };
processEnableActs(guiMgCtrl, actCutCopy, enable);
Manager.MenuManager.refreshMenuActionForTask(mgControl.getForm().getTask());
}
internal LgText(GuiMgControl guiMgControl, Control containerControl)
: base(guiMgControl, containerControl)
{
ShowBorder = true;
ImeMode = -1;
WordWrap = HorizontalScrollBar == MultilineHorizontalScrollBar.WordWrap;
ContentAlignment = ContentAlignment.TopLeft;
}
internal LgButton(GuiMgControl guiMgControl, Control containerControl) :
base(guiMgControl, containerControl)
{
ContentAlignment = ContentAlignment.MiddleCenter;
//Fixed bug #:242632 set the default color of the button(only when the user don't have color define (color=0))
BgColor = SystemColors.Control;
FgColor = SystemColors.WindowText;
}
/// <summary> </summary>
internal void setImageList(String imageFileName)
{
//Form imageList : not need to Dispose the bacause it is from the ImageListCashe.
//For image : dispose is need because it is new image according to the size of the control.
if (GuiMgControl.IsImageButton())
{
_imageList = GuiUtils.getImageListItemForButtonControl(imageFileName, PBImagesNumber);
}
}
/// <summary>send wide action to the control</summary>
/// <param name = "guiMgCtrl"></param>
internal void processWide(GuiMgControl guiMgCtrl)
{
var mgControl = (MgControl)guiMgCtrl;
if (mgControl != null && !mgControl.isWideControl() && !mgControl.getForm().wideIsOpen())
{
processWide(mgControl);
}
}
/// <summary>
/// This method will register handlers for DataView Control.
/// </summary>
/// <param name="mgCtrl"></param>
/// <param name="dataTable"></param>
public void AddHandler(GuiMgControl mgCtrl, DataTable dataTable)
{
Object obj = ControlsMap.getInstance().object2Widget(mgCtrl);
Control ctrl = (Control)obj;
dataTable.ColumnChanged += ColumnChangedHandler;
//get BindingManagerBase object and registering handler for it
BindingManagerBase dm = ctrl.BindingContext[dataTable];
dm.CurrentChanged += CurrentChangedHandler;
}
/// <summary>Put ACT_CTRL_FOCUS, ACT_CTRL_HIT and MG_ACT_BEGIN_DROP to Runtime thread.</summary>
protected override void processBeginDrop(GuiMgForm guiMgForm, GuiMgControl guiMgCtrl, int line)
{
MgControl mgControl = (MgControl)guiMgCtrl;
if (mgControl != null && (mgControl.Type == MgControlType.CTRL_TYPE_TEXT || mgControl.Type == MgControlType.CTRL_TYPE_TREE))
{
ClientManager.Instance.EventsManager.addGuiTriggeredEvent(mgControl, line, InternalInterface.MG_ACT_CTRL_FOCUS, false);
}
base.processBeginDrop(guiMgForm, guiMgCtrl, line);
}
/// <summary>triggered by gui. enable/disable a given act list.</summary>
/// <param name = "guiMgCtrl"></param>
/// <param name = "actList"></param>
/// <param name = "enable"></param>
internal void processEnableActs(GuiMgControl guiMgCtrl, int[] actList, bool enable)
{
var mgControl = (MgControl)guiMgCtrl;
var rtEvt = new RunTimeEvent(mgControl, true);
rtEvt.setInternal(enable
? InternalInterface.MG_ACT_ENABLE_EVENTS
: InternalInterface.MG_ACT_DISABLE_EVENTS);
rtEvt.setActEnableList(actList);
ClientManager.Instance.EventsManager.addToTail(rtEvt);
}
/// <summary>process Resize of the page, for table controls only</summary>
/// <param name = "guiMgCtrl"></param>
/// <param name = "newRowsInPage"></param>
internal void processTableResize(GuiMgControl guiMgCtrl, int newRowsInPage)
{
var mgControl = (MgControl)guiMgCtrl;
if (mgControl != null)
{
var rtEvt = new RunTimeEvent(mgControl, newRowsInPage, true);
rtEvt.setInternal(InternalInterface.MG_ACT_RESIZE);
ClientManager.Instance.EventsManager.addToTail(rtEvt);
}
}
/// <summary>Enable/Disable paste.</summary>
/// <param name = "guiMgCtrl"></param>
/// <param name = "enable"></param>
internal void processEnablePaste(GuiMgControl guiMgCtrl, bool enable)
{
var mgControl = (MgControl)guiMgCtrl;
if (mgControl != null && mgControl.isTextOrTreeEdit() && mgControl.isModifiable())
{
var actPaste = new[] { InternalInterface.MG_ACT_CLIP_PASTE };
processEnableActs(guiMgCtrl, actPaste, enable);
Manager.MenuManager.refreshMenuActionForTask(mgControl.getForm().getTask());
}
}
/// <summary>
/// Handle column filter click event
/// </summary>
/// <param name="columnCtrl"></param>
/// <param name="columnHeader"></param>
/// <param name="index"></param>
/// <param name="x"></param>
/// <param name="y"></param>
private void ProcessColumnFilter(GuiMgControl columnCtrl, String columnHeader, int x, int y, int width, int height)
{
MgControlBase mgColumnControl = (MgControlBase)columnCtrl;
//values that sent to the event, sent in display %. We want that it will be always in 100%.
Object mapObject = ((MgFormBase)mgColumnControl.GuiMgForm).getMapObject();
float resolution = ((float)Commands.getResolution(mapObject).x / 96);
x = ((int)(x / resolution));
y = ((int)(y / resolution));
width = ((int)(width / resolution));
height = ((int)(height / resolution));
Manager.EventsManager.AddColumnFilterEvent(mgColumnControl, columnHeader, x, y, width, height);
}
/// <summary></summary>
/// <param name = "guiMgForm"></param>
/// <param name = "guiMgCtrl"></param>
/// <param name = "modifier"></param>
/// <param name = "keyCode"></param>
/// <param name = "start"></param>
/// <param name = "end"></param>
/// <param name = "text"></param>
/// <param name = "im"></param>
/// <param name = "isActChar"></param>
/// <param name = "suggestedValue"></param>
/// <param name = "dotNetArgs"></param>
/// <param name = "comboIsDropDown"></param>
/// <param name="handled">boolean variable event is handled or not.</param>
/// <returns> true only if we have handled the KeyDown event (otherwise the CLR should handle). If true magic will handle else CLR will handle.</returns>
protected override bool processKeyDown(GuiMgForm guiMgForm, GuiMgControl guiMgCtrl, Modifiers modifier,
int keyCode,
int start, int end,
String text, ImeParam im, bool isActChar, String suggestedValue,
bool comboIsDropDown, bool handled)
{
// time of last user action for IDLE function
ClientManager.Instance.LastActionTime = Misc.getSystemMilliseconds();
// DOWN or UP invoked on a SELECT/RADIO control
return(base.processKeyDown(guiMgForm, guiMgCtrl, modifier, keyCode,
start, end, text, im, isActChar, suggestedValue, comboIsDropDown, handled));
}
/// <summary>
/// If current control becomes invisible/disabled/non parkable, then put MG_ACT_TBL_NXTFLD into queue.
/// </summary>
/// <param name="ctrl">control whose property is changed.</param>
internal void OnNonParkableLastParkedCtrl(GuiMgControl ctrl)
{
MgControlBase mgControl = (MgControlBase)ctrl;
//If task is already in exiting edit state, do not add MG_ACT_TBL_NXTFLD. (Defect 67647)
if (ClientManager.Instance.EventsManager.getForceExit() != ForceExit.Editing)
{
RunTimeEvent rtEvt = new RunTimeEvent((MgControl)mgControl, mgControl.getDisplayLine(false), false);
rtEvt.setInternal(InternalInterface.MG_ACT_TBL_NXTFLD);
ClientManager.Instance.EventsManager.addToTail(rtEvt);
}
}
internal TreeManager(TreeView treeControl, GuiMgControl mgTreeControl)
: base(treeControl)
{
Debug.Assert(Misc.IsGuiThread());
_treeControl = treeControl;
_mgTreeControl = mgTreeControl;
_rowsInPage = -1;
_tmpEditor = createEditor();
treeControl.LabelEdit = true;
treeControl.HideSelection = false;
treeControl.ShowLines = true;
treeControl.ShowPlusMinus = true;
treeControl.ShowRootLines = true;
}
/// <summary>process table reorder event</summary>
///<param name = "guiMgCtrl"> table control</param>
/// <param name = "tabOrderList">list of table children ordered by automatic tab order</param>
internal void processTableReorder(GuiMgControl guiMgCtrl, List <GuiMgControl> guiTabOrderList)
{
var mgControl = (MgControl)guiMgCtrl;
var tabOrderList = new List <MgControlBase>();
foreach (GuiMgControl guiCtrl in guiTabOrderList)
{
tabOrderList.Add((MgControl)guiCtrl);
}
ClientManager.Instance.EventsManager.addGuiTriggeredEvent(mgControl, InternalInterface.MG_ACT_TBL_REORDER,
tabOrderList);
}
/// <summary>process set data for row</summary>
///<param name = "guiMgCtrl">table control</param>
/// <param name = "sendAll">if true , always send all records</param>
internal void processGetRowsData(GuiMgControl guiMgCtrl, int desiredTopIndex, bool sendAll,
LastFocusedVal lastFocusedVal)
{
var mgControl = (MgControl)guiMgCtrl;
if (mgControl != null && mgControl.Type == MgControlType.CTRL_TYPE_TABLE)
{
var rtEvt = new RunTimeEvent(mgControl, desiredTopIndex, true);
rtEvt.setInternal(InternalInterface.MG_ACT_ROW_DATA_CURR_PAGE);
rtEvt.setSendAll(sendAll);
rtEvt.LastFocusedVal = lastFocusedVal;
ClientManager.Instance.EventsManager.addToTail(rtEvt);
}
}
