/// <summary>
/// Execute subform refresh that is sent from the server
/// </summary>
private void ExecuteClientRefreshCommand()
{
MGDataTable mgDataTab = MGDataTable.Instance;
Task task = (Task)mgDataTab.GetTaskByID(TaskTag);
Debug.Assert(task.IsSubForm);
if (task.AfterFirstRecordPrefix && !task.isInEndTask())
{
IClientCommand command = CommandFactory.CreateSubformRefreshCommand(((Task)task).getParent().getTaskTag(), task.getTaskTag(), true);
((Task)task).DataviewManager.Execute(command);
}
}
/// <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();
}
}
}
/// <summary>
/// code to be used when RangeAdd is called on the server, with a local data field
/// </summary>
private void ExecuteAddRangeCommand()
{
MGDataTable mgDataTab = MGDataTable.Instance;
Task task = (Task)mgDataTab.GetTaskByID(TaskTag);
FieldDef fieldDef = task.DataView.getField((int)UserRange.veeIdx - 1);
int parsedLen;
AddUserRangeDataviewCommand command = CommandFactory.CreateAddUserRangeDataviewCommand(TaskTag, UserRange);
command.Range = 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);
}
/// <summary>
///
/// </summary>
/// <param name="mgDataTab"></param>
private void ExecuteVerifyCommand()
{
MGDataTable mgDataTab = MGDataTable.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.WriteErrorToLog(_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;
// on verify box, show translated value. (status is handled in property).
String mlsTransText = ClientManager.Instance.getLanguageData().translate(_text);
String mlsTransTitle;
if (task != null && task.isStarted())
{
currForm = (MgForm)task.getTopMostForm();
}
else
{
currForm = null;
}
if (Type == ClientCommandType.EnhancedVerify)
{
mlsTransTitle = ClientManager.Instance.getLanguageData().translate(_title);
style = Operation.getButtons(_buttonsID);
style |= Operation.getImage(_image);
style |= Operation.getDefaultButton(_defaultButton);
if (task != null)
{
// Verify command return value can only be used with main program fields
if (Task.isMainProgramField(_returnValStr))
{
_returnVal = Operation.InitField(_returnValStr, task);
}
}
}
else
{
String options = ClientManager.Instance.getMessageString(MsgInterface.BRKTAB_STOP_MODE_TITLE);
_title = ConstUtils.getStringOfOption(options, "EW", _mode);
mlsTransTitle = ClientManager.Instance.getLanguageData().translate(_title);
//add the icon according to the mode :is Error \ Warning
style = Styles.MSGBOX_BUTTON_OK |
((_mode == 'E')
? Styles.MSGBOX_ICON_ERROR
: Styles.MSGBOX_ICON_WARNING);
}
int returnValue = Commands.messageBox(currForm, mlsTransTitle, mlsTransText, style);
if (Type == ClientCommandType.EnhancedVerify && task != null)
{
Operation.setoperVerifyReturnValue(returnValue, _returnVal);
}
}
// 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);
}
}
/// <summary>
///
/// </summary>
/// <param name="callingTask"></param>
/// <param name="mgDataTab"></param>
/// <param name="pathParentTask"></param>
/// <param name="mgd"></param>
/// <returns></returns>
private void ExecuteOpenUrlCommand()
{
MGData mgd = null;
MGDataTable mgDataTab = MGDataTable.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);
// 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 (ofcourse 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 = MGDataTable.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();
MGDataTable.Instance.addMGData(mgd, mgdID, false);
MGDataTable.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), 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);
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.
if (callingTask != null && ((_isModal && !destinationSubformSucceeded && refreshWhenHidden) || !callingTask.IsInteractive))
{
ClientManager.Instance.EventsManager.EventsLoop(mgd);
}
}
else
{
ClientManager.Instance.EventsManager.NonInteractiveEventsLoop(mgd, nonInteractiveTask);
}
}
