/// <summary> /// get the recompute attributes /// </summary> private Task fillAttributes(XmlParser parser) { int endContext = parser.getXMLdata().IndexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()); int Index = parser.getXMLdata().IndexOf(XMLConstants.MG_TAG_RECOMPUTE, parser.getCurrIndex()) + XMLConstants.MG_TAG_RECOMPUTE.Length; Task task = null; List <string> tokensVector = XmlParser.getTokens(parser.getXMLdata().Substring(Index, endContext - Index), "\""); for (int j = 0; j < tokensVector.Count; j += 2) { string attribute = (tokensVector[j]); string valueStr = (tokensVector[j + 1]); if (attribute.Equals(XMLConstants.MG_ATTR_TASKID)) { task = (Task)MGDataCollection.Instance.GetTaskByID(valueStr); } else { Logger.Instance.WriteExceptionToLog(string.Format("Unrecognized attribute: '{0}'", attribute)); } } parser.setCurrIndex(parser.getXMLdata().IndexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1); //start of <fld ...> return(task); }
/// <summary> /// if the current task and its parent are from different components then /// set the task to the main program of the component of the current task. /// otherwise, set the task to be the parent of the current task /// </summary> private void getParentOrCompMainPrg() { int ctlIdx = _task.getCtlIdx(); Task parent; _prevTask = _task; // Retrieve the task's calling-parent. We need the task who invoked the current task // rather than the task's triggering parent. // The Path Parent is the parent of that task as if the server had done build path. It is more logical to search using the trigger task tree // but since the online/server does not use the trigger tree, we decided not to use it here as well. // If the path parent is from a different comp, it means that between curr task and parent there should be a comp main prog. parent = _task.PathParentTask; if (parent == null) { _task = null; return; } // check if the parent task is from another component if (ctlIdx != parent.getCtlIdx()) { // replace the parent task to search with the comp main program. later on, the main prog will be replaced with // the real PathParentTask. _rtEvt.setMainPrgCreator(_task); _task = (Task)MGDataCollection.Instance.GetMainProgByCtlIdx(ctlIdx); } else { _rtEvt.setMainPrgCreator(null); _task = parent; } }
/// <summary> /// get menu path /// </summary> /// <param name="task"> /// <returns>string</returns> internal static string GetMenuPath(Task task) { Task mainProg = MGDataCollection.Instance.GetMainProgByCtlIdx((task).getCtlIdx()); Task currTsk = ClientManager.Instance.EventsManager.getCurrTask() ?? (Task)task.GetContextTask(); // fixed bug#919779, the MenuUid is save on the parent. // MenuUid is saved on the parent. bacouse we don't have menu on the current form. int menuUid = currTsk.MenuUid; while (menuUid == 0 && currTsk != null) { currTsk = currTsk.getParent(); if (currTsk != null) { menuUid = currTsk.MenuUid; } } //as we doing for online: if it is not program that was called, then get the last click menu id from the top most form. if (menuUid == 0) { currTsk = ClientManager.Instance.EventsManager.getCurrTask() ?? (Task)task.GetContextTask(); menuUid = currTsk.getTopMostForm().LastClickedMenuUid; } string menuPath = Manager.MenuManager.GetMenuPath(mainProg, menuUid); return(menuPath); }
/// <summary> /// This constructor creates a matching event object for the passed menuEntryEvent /// </summary> /// <param name = "menuEntryEvent">event menu entry for which we create this event</param> /// <param name = "currentTask">current task from which the menu entry was activated</param> /// <param name = "control"></param> internal RunTimeEvent(MenuEntryEvent menuEntryEvent, Task currentTask, MgControl control, int ctlIdx) : base(menuEntryEvent, ctlIdx) { _task = currentTask; _taskTag = currentTask.getTaskTag(); Control = control; }
/// <summary> /// CTOR - creates a new run time event by copying the member variables of a given /// event and the member variables of a given run time event /// </summary> /// <param name = "evt">a reference to the event to be used </param> /// <param name = "rtEvt">a reference to the run time event to be used </param> internal RunTimeEvent(Event evt, RunTimeEvent rtEvt) : base(evt) { _taskTag = rtEvt._taskTag; _task = rtEvt._task; Control = rtEvt.Control; _eventFld = rtEvt._eventFld; _mgdId = rtEvt._mgdId; _displayLine = rtEvt._displayLine; _reversibleExit = rtEvt._reversibleExit; _argList = rtEvt._argList; _immediate = rtEvt._immediate; _mprgCreator = rtEvt._mprgCreator; _priority = rtEvt._priority; _guiTriggeredEvent = rtEvt._guiTriggeredEvent; _isIdleTimer = rtEvt._isIdleTimer; _val = rtEvt._val; _selectionStart = rtEvt._selectionStart; _selectionEnd = rtEvt._selectionEnd; _controlsList = rtEvt._controlsList; _direction = rtEvt._direction; _dotNetObject = rtEvt._dotNetObject; DotNetArgs = rtEvt.DotNetArgs; LastFocusedVal = rtEvt.LastFocusedVal; _imeParam = rtEvt._imeParam; }
/// <summary> /// /// </summary> /// <param name="tsk"></param> internal DvCache(Task tsk) { _task = tsk; _cacheTable = new Hashtable(100, 0.7F); _deletedList = new List <long>(); _cacheSize = 0; }
/// <summary> /// To parse input string and fill inner data : Vector props /// </summary> internal void fillData(DataView dataView, Task task) { XmlParser parser = ClientManager.Instance.RuntimeCtx.Parser; while (initInnerObjects(parser, parser.getNextTag(), dataView, task)) { } }
/// <summary> /// This method is activated when a program menu was selected. It performs the needed operations in order to /// translate the selected program menu into the matching operation /// </summary> /// <param name="contextID">active/target context (irelevant for RC)</param> /// <param name="menuEntryProgram">the selected menu \ bar menuEntryProgram object</param> /// <param name="activeForm"></param> /// <param name="ActivatedFromMDIFrame"></param> /// <returns></returns> internal static void onProgramMenuSelection(Int64 contextID, MenuEntryProgram menuEntryProgram, MgForm activeForm, bool ActivatedFromMDIFrame) { Task menuTask = getLastFocusedTask(activeForm); ClientManager.Instance.RuntimeCtx.LastClickedMenuUid = menuEntryProgram.menuUid(); RunTimeEvent programMenuEvt = new RunTimeEvent(menuEntryProgram, menuTask, ActivatedFromMDIFrame); ClientManager.Instance.EventsManager.addToTail(programMenuEvt); }
/// <summary> /// CTOR /// </summary> /// <param name = "taskref">reference to task</param> /// <param name = "guiTriggeredEvent"></param> internal RunTimeEvent(Task taskref, bool guiTriggeredEvent) : this(taskref) { _guiTriggeredEvent = guiTriggeredEvent; if (guiTriggeredEvent) { //Events that are triggered by GUI level, must be executed after all //other events, thus they have low priority; _priority = Priority.LOW; } }
/// <summary> /// set the task /// </summary> /// <param name = "aTask">- reference to a task</param> internal void setTask(Task taskRef) { _task = taskRef; if (_task != null) { _taskTag = _task.getTaskTag(); } else { _taskTag = null; } }
/// <summary> /// Check if this event is blocked by the currently active window. If the /// current window is modal, and the event defined in one of its ancestors, /// the event should not be executed. /// </summary> /// <param name = "activeWindowData">The MGData object describing the currently active window.</param> /// <returns> /// The method returns true if the currently active window is modal is a /// descendant of the event's task. Otherwise it returns false. /// </returns> internal bool isBlockedByModalWindow(MGData activeWindowData) { if (activeWindowData.IsModal) { // Check that the event's task is an ancestor of the active window's task. Task eventTask = getTask(); Task baseTask = activeWindowData.getTask(0); if (eventTask != baseTask && baseTask.isDescendentOf(eventTask)) { return(true); } } return(false); }
/// <summary> /// /// </summary> /// <param name="contextID">active/target context (irelevant for RC)</param> /// <param name="osCommandMenuEntry"></param> /// <param name="lastFocusedCtrlTask"> ///the task of the last focused control. This is required because even if there is no ///last focused control, then also we have task and hence expression/function will be executed properly. ///Previously task was obtained from the control and when there was no control,task could not be obtained. /// </param> /// <returns></returns> internal static void onOSMenuSelection(Int64 contextID, MenuEntryOSCommand osCommandMenuEntry, MgForm activeForm) { Task lastFocusedCtrlTask = getLastFocusedTask(activeForm); RunTimeEvent osMenuEvent = new RunTimeEvent(osCommandMenuEntry, lastFocusedCtrlTask); if (osCommandMenuEntry.Wait) { ClientManager.Instance.EventsManager.handleEvent(osMenuEvent, false); } else { ClientManager.Instance.EventsManager.addToTail(osMenuEvent); } }
/// <summary> /// Create an Event for the passed program menu entry /// </summary> /// <param name = "menuEntryProgram">the selected program menu entry</param> /// <param name = "currentTask">the task from which the menu was activated</param> /// <param name = "activatedFromMDIFrame"></param> internal RunTimeEvent(MenuEntryProgram menuEntryProgram, Task currentTask, bool activatedFromMDIFrame) : base(ConstInterface.EVENT_TYPE_MENU_PROGRAM) { PrgFlow = menuEntryProgram.Flow; PublicName = menuEntryProgram.PublicName; PrgDescription = menuEntryProgram.Description; CopyGlobalParams = menuEntryProgram.CopyGlobalParameters; MainProgVars = menuEntryProgram.MainProgVars; ActivatedFromMDIFrame = activatedFromMDIFrame; _task = currentTask; _menuUid = menuEntryProgram.menuUid(); _menuComp = menuEntryProgram.getParentMgMenu().CtlIdx; }
/// <summary> /// /// </summary> internal void fillData() { XmlParser parser = ClientManager.Instance.RuntimeCtx.Parser; Task task = fillAttributes(parser); if (task != null) { Logger.Instance.WriteDevToLog("goes to refill recompute"); fillData((DataView)task.DataView, task); } else { throw new ApplicationException("in RecomputeTable.fillData() invalid task id: "); //+ valueStr); } }
/// <summary> /// The menu texts needs to be refreshed due to a change in the language. /// </summary> private void RefreshMenusText() { int ctlIdx = 0; Task mainProg = (Task)MGDataCollection.Instance.GetMainProgByCtlIdx(ctlIdx); while (mainProg != null) { ApplicationMenus menus = Manager.MenuManager.getApplicationMenus(mainProg); // call refreshMenuesTextMls for each application menu of components, starting with the main. if (menus != null) { menus.refreshMenuesTextMls(); } ctlIdx = mainProg.getCtlIdx(); mainProg = (Task)mainProg.getMGData().getNextMainProg(ctlIdx); } }
/// <summary> Add Open Context Menu event on right click on form.</summary> /// <param name = "guiMgControl">control </param> /// <param name = "guiMgForm">code of internal event </param> /// <param name = "left">code of internal event </param> /// <param name = "top">code of internal event </param> /// <param name = "line">code of internal event </param> public void AddOpenContextMenuEvent(GuiMgControl guiMgControl, GuiMgForm guiMgForm, int left, int top, int line) { MgControl ctrl = null; Task task = null; if (guiMgControl != null) { if (guiMgControl is MgControl) { ctrl = (MgControl)guiMgControl; if (ctrl.Type == MgControlType.CTRL_TYPE_SUBFORM) { task = (Task)ctrl.GetSubformMgForm().getTask(); } else { task = (Task)((MgControlBase)guiMgControl).getForm().getTask(); } } } else { task = (Task)((MgFormBase)guiMgForm).getTask(); } // Prepare event for MG_ACT_CONTEXT_MENU to open context menu. var rtEvt = new RunTimeEvent(task); rtEvt.setInternal(InternalInterface.MG_ACT_CONTEXT_MENU); rtEvt.setCtrl(ctrl); //Prepare an argument list for left and top co-ordinate. var argsList = new GuiExpressionEvaluator.ExpVal[3]; argsList[0] = new GuiExpressionEvaluator.ExpVal(StorageAttribute.ALPHA, false, left.ToString()); argsList[1] = new GuiExpressionEvaluator.ExpVal(StorageAttribute.ALPHA, false, top.ToString()); argsList[2] = new GuiExpressionEvaluator.ExpVal(StorageAttribute.ALPHA, false, line.ToString()); var args = new ArgumentsList(argsList); rtEvt.setArgList(args); ClientManager.Instance.EventsManager.addToTail(rtEvt); }
/// <summary> /// init the position to start a new chain of search /// </summary> internal void init(RunTimeEvent rtEvent) { _rtEvt = rtEvent; _task = _rtEvt.getTask(); if (_task.isMainProg()) { //phase = PHASE_CONTROL_NON_SPECIFIC; _prevTask = _rtEvt.getMainPrgCreator(); if (_prevTask != null && _prevTask.isMainProg()) { _prevTask = null; } } if (rtEvent.getType() == ConstInterface.EVENT_TYPE_USER_FUNC) { _phase = PHASE_CONTROL_NON_SPECIFIC; } else { if (rtEvent.getType() == ConstInterface.EVENT_TYPE_USER_FUNC) { _phase = PHASE_CONTROL_NON_SPECIFIC; } else { _phase = PHASE_CONTROL_SPECIFIC; } } _orgTask = _task; _orgPrevTask = _prevTask; _handlersTab = _task.getHandlersTab(); if (_handlersTab == null) { goUpTaskChain(); } _handlerIdx = -1; }
/// <summary> /// This method is activated when an Event menu was selected. It performs the needed operations in order to /// translate the selected event menu into the matching operation /// </summary> /// <param name = "menuEntryEvent">the selected menu \ bar menuEntryEvent object</param> /// <param name = "activeForm">last active Form</param> /// <param name = "ctlIdx">the index of the ctl which the menu is attached to in toolkit</param> internal static void onEventMenuSelection(MenuEntryEvent menuEntryEvent, MgForm activeForm, int ctlIdx) { MgControl lastFocusedControl = getLastFocusedControl(activeForm); Task task = getLastFocusedTask(activeForm); RunTimeEvent aRtEvt = new RunTimeEvent(menuEntryEvent, task, lastFocusedControl, ctlIdx); aRtEvt.setPublicName(); aRtEvt.setMainPrgCreator(null); // build the argument list from the mainProgVars List <String> mainProgVars = menuEntryEvent.MainProgVars; if (mainProgVars != null && mainProgVars.Count > 0) { ArgumentsList argList = new ArgumentsList(); argList.fillListByMainProgVars(mainProgVars, task.getCtlIdx()); aRtEvt.setArgList(argList); aRtEvt.setTask(null); } ClientManager.Instance.EventsManager.addToTail(aRtEvt); }
/// <summary> /// CTOR /// </summary> /// <param name = "taskRef">reference to task</param> /// <param name = "ctrlRef">reference to control</param> internal RunTimeEvent(Task taskRef, MgControl ctrlRef) : this(ctrlRef != null ? (Task)ctrlRef.getForm().getTask() : taskRef) { Control = ctrlRef; }
/// <summary> /// Create an Event for the passed os menu entry /// </summary> /// <param name = "osCommand">the selected os command menu entry</param> /// <param name = "currentTask">the task from which the menu was activated</param> internal RunTimeEvent(MenuEntryOSCommand osCommand, Task currentTask) : base(osCommand) { _task = currentTask; }
/// <summary> /// get the next task in the tasks chain and returns false if no task was found. /// this function changes the phase variable accordingly /// </summary> private bool goUpTaskChain() { MGData mgd = _task.getMGData(); int ctlIdx = _task.getCtlIdx(); //handlers for events for .NET object must be in the same task (not including control) if (_rtEvt.DotNetObject != null) { if (_phase != PHASE_CONTROL_NON_SPECIFIC) //QCR #940545, check only the same tasks { _phase++; //go to the next phase return(true); } else { return(false); } } switch (_phase) { /*case PHASE_CONTROL_SPECIFIC: * phase = PHASE_CONTROL_NON_SPECIFIC; * break;*/ case PHASE_CONTROL_SPECIFIC: case PHASE_CONTROL_NON_SPECIFIC: // non specific handlers are searched till we hit our main program (inclusive) // afterwards we switch to global phase. if (!_task.isMainProg()) { getParentOrCompMainPrg(); break; } else { // internal, internal, system and user events may cross component bounderies if ((_rtEvt.getType() == ConstInterface.EVENT_TYPE_PUBLIC || _rtEvt.getType() == ConstInterface.EVENT_TYPE_INTERNAL || _rtEvt.getType() == ConstInterface.EVENT_TYPE_SYSTEM || _rtEvt.getType() == ConstInterface.EVENT_TYPE_USER) && ctlIdx != 0) { // load the RT parent of the previous task. If no prevtask exists then we are // simply running on the main progs list (for example, when a main prg catches // a timer event, no prevtask exists. if (_prevTask == null) { _task = (Task)mgd.getNextMainProg(ctlIdx); if (_task == null && ctlIdx != 0) { _task = MGDataCollection.Instance.GetMainProgByCtlIdx(ClientManager.Instance.EventsManager.getCompMainPrgTab().getCtlIdx(0)); } } else { // the component main program that was set in getParentOrCompMainPrg, is now replaced back to the path parent. _task = _prevTask.PathParentTask; _prevTask = null; } _rtEvt.setMainPrgCreator(null); //moving out of a main program to another task break; } // here we scan the main progs according to the load sequence (first to last). if (_phase == PHASE_CONTROL_SPECIFIC) { // specific search is over. start the non specific search from // the first task. _phase = PHASE_GLOBAL_SPECIFIC; } else { // here we scan the main progs according to the load sequence (first to last). _phase = PHASE_GLOBAL; } _task = MGDataCollection.Instance.GetMainProgByCtlIdx(ClientManager.Instance.EventsManager.getCompMainPrgTab().getCtlIdx(0)); _rtEvt.setMainPrgCreator(_task); if (_task == null) { return(false); } break; } case PHASE_GLOBAL_SPECIFIC: case PHASE_GLOBAL: _task = (Task)mgd.getNextMainProg(ctlIdx); if (_task == null) { if (_phase == PHASE_GLOBAL) { return(false); } // PHASE_GLOBAL_SPECIFIC else { // specific search is over. start the non specific search from // the first task. _phase = PHASE_CONTROL_NON_SPECIFIC; _task = _orgTask; _prevTask = _orgPrevTask; break; } } break; default: Logger.Instance.WriteExceptionToLog("in EventHandlerPosition.goUpTaskChain() invalid phase: " + _phase); break; } if (_task == null) { return(false); } _handlersTab = _task.getHandlersTab(); if (_handlersTab == null) { return(goUpTaskChain()); } _handlerIdx = -1; return(true); }
/// <summary> /// a helper method that does some common initialization for some of the constructors /// </summary> private void init(Task taskRef) { _task = taskRef ?? MGDataCollection.Instance.getCurrMGData().getFirstTask(); _taskTag = _task == null ? "" : _task.getTaskTag(); _mprgCreator = null; }
/// <summary> /// set the reference to the task which is "responsible" for a main program to become active. /// For example: if task A calls task B and B's ctlIdx is different than A's, then B's main /// program will be inserted into the task hirarchy thus B is "responsible" for the main prg. /// </summary> /// <param name = "src">the "responsible" task.</param> internal void setMainPrgCreator(Task src) { _mprgCreator = src; }
/// <summary> /// CTOR /// </summary> /// <param name = "taskRef">a reference to the task</param> internal RunTimeEvent(Task taskRef) : base() { init(taskRef); }
/// <summary> /// Fill Recompute Object, gives its reference to Field and reference of Field to him /// </summary> private bool initInnerObjects(XmlParser parser, String nameOfFound, DataView dataView, Task task) { if (nameOfFound == null) { return(false); } if (nameOfFound.Equals(XMLConstants.MG_TAG_RECOMPUTE)) { parser.setCurrIndex(parser.getXMLdata().IndexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1); } //satrt of <fld ...> else if (nameOfFound.Equals(XMLConstants.MG_TAG_FLD)) { Recompute recompute = new Recompute(); recompute.fillData(dataView, task); //get reference to DataView, to make linked ref. : Recompute<-Field //taskReference for Recompute.props=> ControlTable.Control.task } else if (nameOfFound.Equals('/' + XMLConstants.MG_TAG_RECOMPUTE)) { parser.setCurrIndex2EndOfTag(); return(false); } else { Logger.Instance.WriteExceptionToLog( "There is no such tag in <recompute>, add case to RecomputeTable.initInnerObjects for " + nameOfFound); return(false); } return(true); }