Exemple #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="res"></param>
        public override void Execute(rt.IResultValue res)
        {
            MGDataCollection mgDataTab = MGDataCollection.Instance;

            Task task = (Task)mgDataTab.GetTaskByID(TaskTag);

            Debug.Assert(task.IsSubForm);

            // Fixed Defect#:77149
            // if we in rollback command and we get clientRefresh command from server ,
            // first we need to rollback the local transaction and then we need to do refresh to the view .
            // the refresh to the view will be handled in rollback command
            if (ClientIsInRollbackCommand)
            {
                return;
            }

            if (task.AfterFirstRecordPrefix && !task.InEndTask)
            {
                // QCR #284789. When the subform execute it's recompute, we do not needed to execute it's view refresh,
                // we need execute only it's subforms refresh. It will be done in recompute.
                if (((DataView)task.DataView).getCurrRec().InRecompute)
                {
                    task.ExecuteClientSubformRefresh = true;
                }
                else
                {
                    // Do not execute RP & RS of the parent, because it was done already.
                    task.PerformParentRecordPrefix = false;
                    ((Task)task).getParent().SubformRefresh(task, true);
                    task.PerformParentRecordPrefix = true;
                }
            }
        }
Exemple #2
0
        /// <summary>
        /// Execute AddSortCommand
        /// </summary>
        /// <param name="res"></param>
        public override void  Execute(rt.IResultValue res)
        {
            MGDataCollection           mgDataTab = MGDataCollection.Instance;
            Task                       task      = (Task)mgDataTab.GetTaskByID(TaskTag);
            AddUserSortDataViewCommand command   = CommandFactory.CreateAddUserSortDataviewCommand(TaskTag, UserSort);

            task.DataviewManager.Execute(command);
        }
Exemple #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="exp"></param>
        public override void Execute(rt.IResultValue res)
        {
            MGDataCollection mgDataTab = MGDataCollection.Instance;

            Task task = (Task)(mgDataTab.GetTaskByID(TaskTag) ?? mgDataTab.GetTaskByID(_callingTaskTag));

            if (task == null)
            {
                task = ClientManager.Instance.getLastFocusedTask();
            }

            // In order to keep the behavior same as in Online, verify operation warning messages
            // will be written as error messages in Client log (QCR #915122)
            if (_errLogAppend)
            {
                Logger.Instance.WriteExceptionToLog(_text + ", program : " + ClientManager.Instance.getPrgName());
            }

            //Blank Message will not be shown, same as in Online
            if (!String.IsNullOrEmpty(_text))
            {
                if (_display == ConstInterface.DISPLAY_BOX)
                {
                    MgForm currForm;
                    int    style = 0;

                    // on verify box, show translated value. (status is handled in property).
                    String mlsTransText  = ClientManager.Instance.getLanguageData().translate(_text);
                    String mlsTransTitle = String.Empty;

                    if (task != null && task.isStarted())
                    {
                        currForm = (MgForm)task.getTopMostForm();
                    }
                    else
                    {
                        currForm = null;
                    }

                    PrepareMessageBoxForDisplay(task, ref mlsTransTitle, ref style);

                    int returnValue = Commands.messageBox(currForm, mlsTransTitle, mlsTransText, style);

                    ProcessMessageBoxResponse(task, returnValue);
                }
                // display message on status only if we have a task
                //Blank Message will not be shown, same as in Online
                else if (_display == ConstInterface.DISPLAY_STATUS && task != null)
                {
                    task.DisplayMessageToStatusBar(_text);
                }
            }

            if (_sendAck)
            {
                task.CommandsProcessor.Execute(CommandsProcessorBase.SendingInstruction.NO_TASKS_OR_COMMANDS);
            }
        }
Exemple #4
0
        /// <summary>
        /// Execute ResetRange command.
        /// </summary>
        /// <param name="res"></param>
        public override void  Execute(rt.IResultValue res)
        {
            MGDataCollection mgDataTab = MGDataCollection.Instance;

            Task task = (Task)mgDataTab.GetTaskByID(TaskTag);

            IClientCommand command = CommandFactory.CreateDataViewCommand(TaskTag, DataViewCommandType.ResetUserRange);

            task.DataviewManager.Execute(command);
        }
Exemple #5
0
        /// <summary>
        /// Execute AddLocateCommand
        /// </summary>
        /// <param name="exp"></param>
        public override void  Execute(rt.IResultValue res)
        {
            MGDataCollection mgDataTab = MGDataCollection.Instance;

            Task     task     = (Task)mgDataTab.GetTaskByID(TaskTag);
            FieldDef fieldDef = task.DataView.getField((int)UserRange.veeIdx - 1);
            int      parsedLen;

            AddUserLocateDataViewCommand command = CommandFactory.CreateAddUserLocateDataviewCommand(TaskTag, UserRange);

            if (!UserRange.nullMin)
            {
                command.Range.min = RecordUtils.deSerializeItemVal(UserRange.min, fieldDef.getType(), fieldDef.getSize(), true, fieldDef.getType(), out parsedLen);
            }
            if (!UserRange.nullMax)
            {
                command.Range.max = RecordUtils.deSerializeItemVal(UserRange.max, fieldDef.getType(), fieldDef.getSize(), true, fieldDef.getType(), out parsedLen);
            }

            task.DataviewManager.Execute(command);
        }
 public abstract void Execute(rt.IResultValue res);
Exemple #7
0
        public override void Execute(rt.IResultValue res)
        {
            MGData           mgd       = null;
            MGDataCollection mgDataTab = MGDataCollection.Instance;
            bool             destinationSubformSucceeded = false;
            bool             refreshWhenHidden           = true;
            int          mgdID = 0;
            MgControl    subformCtrl = null;
            List <Int32> oldTimers = new List <Int32>(), newTimers = new List <Int32>();
            bool         moveToFirstControl = true;
            Task         guiParentTask;
            MGData       guiParentMgData = null;
            Task         callingTask     = (_callingTaskTag != null ? (Task)mgDataTab.GetTaskByID(_callingTaskTag) : null);
            Task         pathParentTask  = (_pathParentTaskTag != null ? (Task)mgDataTab.GetTaskByID(_pathParentTaskTag) : null);
            MgForm       formToBeActivatedOnClosingCurrentForm = null;

            Task lastFocusedTask = ClientManager.Instance.getLastFocusedTask();

            if (lastFocusedTask != null && lastFocusedTask.IsOffline)
            {
                formToBeActivatedOnClosingCurrentForm = (MgForm)lastFocusedTask.getForm();
            }

            // TODO (Ronak): It is wrong to set Parent task as a last focus task when
            // non-offline task is being called from an offline task.

            //When a nonOffline task was called from an Offline task (of course via MP event),
            //the calling task id was not sent to the server because the server is unaware of the
            //offline task. So, when coming back from the server, assign the correct calling task.
            //Task lastFocusedTask = ClientManager.Instance.getLastFocusedTask();
            //if (lastFocusedTask != null && lastFocusedTask.IsOffline)
            //   _callingTaskTag = lastFocusedTask.getTaskTag();

            guiParentTask = callingTask = (Task)mgDataTab.GetTaskByID(_callingTaskTag);
            if (callingTask != null)
            {
                mgd = callingTask.getMGData();
            }

            //QCR#712370: we should always perform refreshTables for the old MgData before before opening new window
            ClientManager.Instance.EventsManager.refreshTables();

            //ditIdx is send by server only for subform opening for refreshWhenHidden
            if ((_subformCtrlName != null) || (_ditIdx != Int32.MinValue))
            {
                subformCtrl = (_ditIdx != Int32.MinValue
                             ? (MgControl)callingTask.getForm().getCtrl(_ditIdx)
                             : ((MgForm)callingTask.getForm()).getSubFormCtrlByName(_subformCtrlName));
                if (subformCtrl != null)
                {
                    var subformTask = subformCtrl.getSubformTask();
                    guiParentTask   = (Task)subformCtrl.getForm().getTask();
                    mgdID           = guiParentTask.getMgdID();
                    guiParentMgData = guiParentTask.getMGData();
                    if (guiParentMgData.getTimerHandlers() != null)
                    {
                        oldTimers = guiParentMgData.getTimerHandlers().getTimersVector();
                    }

                    if (_ditIdx != Int32.MinValue) //for refresh when hidden
                    {
                        refreshWhenHidden  = false;
                        moveToFirstControl = false;
                    }
                    else //for destination
                    {
                        destinationSubformSucceeded = true;
                        // Pass transaction ownership
                        if (_transOwner != null)
                        {
                            var newTransOwnerTask = (Task)mgDataTab.GetTaskByID(_transOwner);
                            if (newTransOwnerTask != null)
                            {
                                newTransOwnerTask.setTransOwnerTask();
                            }
                        }

                        if (subformTask != null)
                        {
                            subformTask.setDestinationSubform(true);
                            subformTask.stop();
                        }

                        if (!ClientManager.Instance.validReturnToCtrl())
                        {
                            ClientManager.Instance.ReturnToCtrl = GUIManager.getLastFocusedControl();
                        }
                    }

                    subformCtrl.setSubformTaskId(_newId);
                }
            }

            MGData parentMgData;

            if (callingTask == null)
            {
                parentMgData = MGDataCollection.Instance.getMGData(0);
            }
            else
            {
                parentMgData = callingTask.getMGData();
            }

            if (!destinationSubformSucceeded && refreshWhenHidden)
            {
                mgdID = mgDataTab.getAvailableIdx();
                Debug.Assert(mgdID > 0);
                mgd = new MGData(mgdID, parentMgData, _isModal, _forceModal);
                mgd.copyUnframedCmds();
                MGDataCollection.Instance.addMGData(mgd, mgdID, false);

                MGDataCollection.Instance.currMgdID = mgdID;
            }

            Obj  = _key;
            _key = null;

            try
            {
                // Large systems appear to consume a lot of memory, the garbage collector is not always
                // "quick" enough to catch it, so free memory before initiating a memory consuming job as
                // reading a new MGData.
                if (GC.GetTotalMemory(false) > 30000000)
                {
                    GC.Collect();
                }

                ClientManager.Instance.ProcessResponse(NewTaskXML, mgdID, new OpeningTaskDetails(callingTask, pathParentTask, formToBeActivatedOnClosingCurrentForm), null);
            }
            finally
            {
                ClientManager.Instance.EventsManager.setIgnoreUnknownAbort(false);
            }

            if (callingTask != null && subformCtrl != null)
            {
                callingTask.PrepareForSubform(subformCtrl);
            }

            if (destinationSubformSucceeded || !refreshWhenHidden)
            {
                subformCtrl.initSubformTask();
                if (destinationSubformSucceeded)
                {
                    var subformTask = subformCtrl.getSubformTask();
                    moveToFirstControl = !callingTask.RetainFocus;
                    subformTask.setIsDestinationCall(true);
                }
            }

            if (subformCtrl != null)
            {
                if (guiParentMgData.getTimerHandlers() != null)
                {
                    newTimers = guiParentMgData.getTimerHandlers().getTimersVector();
                }
                guiParentMgData.changeTimers(oldTimers, newTimers);
            }

            Task nonInteractiveTask = ClientManager.Instance.StartProgram(destinationSubformSucceeded, moveToFirstControl, _varList, _returnVal, null);

            if (destinationSubformSucceeded || !refreshWhenHidden)
            {
                guiParentTask.resetRcmpTabOrder();
            }

            // in local tasks, ismodal is calculated after the main display, so we need to update the command member
            _isModal = mgd.IsModal;

            // If we have a non interactive task starting, we need to create an eventLoop for it , just like modal.
            // This is because we cannot allow the tasks above it to catch events.
            if (nonInteractiveTask == null)
            {
                // a non interactive parent will cause the called task to behave like modal by having its own events loop.
                // In case of main program caller (which is flagged as non interactive) we will have a new events loop for the called program
                // if the main program is without a form. If the main prog has a form , then the callee can be included in the main prog loop.
                if (callingTask != null &&
                    ((_isModal && !destinationSubformSucceeded && refreshWhenHidden) || (!callingTask.IsInteractive && (!callingTask.isMainProg() || callingTask.getForm() == null))))
                {
                    ClientManager.Instance.EventsManager.EventsLoop(mgd);
                }
            }
            else
            {
                ClientManager.Instance.EventsManager.NonInteractiveEventsLoop(mgd, nonInteractiveTask);
            }
        }