/// <summary>
///
/// </summary>
internal override void Execute()
{
Task parentTask = Manager.MGDataTable.GetTaskByID(CallingTaskTag) as Task;
MgForm parentForm = parentTask.getForm() as MgForm;
MgControl destSubformCtrl = parentForm.getSubFormCtrlByName(SubformCtrlName);
// Subform task is not allowed to be opened before the first record prefix of the parent.
// In Task Prefix or in the first Record Prefix do not execute call but put the task from the call on the subform control property.
// So after the first record prefix the task from the call operation will be loaded into the subform control.
if (destSubformCtrl != null && !((Task)destSubformCtrl.getForm().getTask()).AfterFirstRecordPrefix)
{
// QCR #310113. If the subform was loaded, now it must be closed.
Task subformTaskToRemove = destSubformCtrl.getSubformTask();
if (subformTaskToRemove != null)
{
subformTaskToRemove.stop();
}
SetCalledTaskDefinitionId(destSubformCtrl);
SetCalledSubformType(destSubformCtrl);
destSubformCtrl.ArgList = ArgList;
// TODO: Task Suffix
}
else
{
base.Execute();
}
}
/// <summary>
/// CTOR
/// </summary>
/// <param name = "ctrlRef">a reference to the control </param>
internal RunTimeEvent(MgControl ctrlRef)
: this(null, ctrlRef)
{
if (ctrlRef != null && getType() == Char.MinValue) // not initialized yet
{
// on the first time, if a TRIGGER property exists, parse the event and add it to the control
Property prop = ctrlRef.getProp(PropInterface.PROP_TYPE_TRIGGER);
if (prop != null)
{
var xmlParser = new XmlParser(prop.getValue());
fillData(xmlParser, (Task)ctrlRef.getForm().getTask());
}
}
}
/// <summary>
///
/// </summary>
private void ExecuteAbortCommand()
{
MGDataTable mgDataTab = MGDataTable.Instance;
int oldMgdID = MGDataTable.Instance.currMgdID;
MGData mgd = null;
var task = (Task)mgDataTab.GetTaskByID(TaskTag);
// Pass transaction ownership
if (_transOwner != null)
{
var newTransOwnerTask = (Task)mgDataTab.GetTaskByID(_transOwner);
if (newTransOwnerTask != null)
{
newTransOwnerTask.setTransOwnerTask();
}
}
// On special occasions, the server may send abort commands on tasks which were not parsed yet
if (task == null && ClientManager.Instance.EventsManager.ignoreUnknownAbort())
{
return;
}
Debug.Assert(task != null);
mgd = task.getMGData();
task.stop();
mgd.abort();
MGDataTable.Instance.currMgdID = mgd.GetId();
GUIManager.Instance.abort((MgForm)task.getForm());
MGDataTable.Instance.currMgdID = (mgd.GetId() != oldMgdID || mgd.getParentMGdata() == null
? oldMgdID
: mgd.getParentMGdata().GetId());
if (!ClientManager.Instance.validReturnToCtrl())
{
MgControl mgControl = GUIManager.getLastFocusedControl();
ClientManager.Instance.ReturnToCtrl = mgControl;
if (mgControl != null)// Refresh the status bar.
{
((MgForm)mgControl.getForm()).RefreshStatusBar();
}
}
}
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);
}
}
/// <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;
}