@magic-xpa/engine 4.1100.0-dev4110.2 → 4.1100.0-dev4110.202

package/{esm2020 → esm2022}/src/CurrentClientVersion.mjs

@@ -1,2 +1,2 @@
-export let CurrentClientVersion = '4.1100.0-dev4110.2';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ3VycmVudENsaWVudFZlcnNpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lbmdpbmUvc3JjL0N1cnJlbnRDbGllbnRWZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxJQUFJLG9CQUFvQixHQUFHLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGxldCBDdXJyZW50Q2xpZW50VmVyc2lvbiA9ICc0LjExMDAuMC1kZXY0MTEwLjInOyJdfQ==
+export let CurrentClientVersion = '4.1100.0-dev4110.202';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ3VycmVudENsaWVudFZlcnNpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lbmdpbmUvc3JjL0N1cnJlbnRDbGllbnRWZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxJQUFJLG9CQUFvQixHQUFHLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGxldCBDdXJyZW50Q2xpZW50VmVyc2lvbiA9ICc0LjExMDAuMC1kZXY0MTEwLjIwMic7Il19

package/esm2022/src/FlowMonitorInterface.mjs

@@ -0,0 +1,16 @@
+export class FlowMonitorInterface {
+    static FLWMTR_START = 0;
+    static FLWMTR_END = 1;
+    static FLWMTR_PROPAGATE = 2;
+    static FLWMTR_EVENT = 7;
+    static FLWMTR_CHNG_MODE = 8;
+    static FLWMTR_PREFIX = 15;
+    static FLWMTR_SUFFIX = 16;
+    static FLWMTR_CTRL_PREFIX = 18;
+    static FLWMTR_CTRL_SUFFIX = 19;
+    static FLWMTR_TSK_HANDLER = 20;
+    static FLWMTR_RECOMP = 31;
+    static FLWMTR_DATA_OPER = 41;
+    static FLWMTR_VARCHG_VALUE = 119;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmxvd01vbml0b3JJbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lbmdpbmUvc3JjL0Zsb3dNb25pdG9ySW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxvQkFBb0I7SUFDL0IsTUFBTSxDQUFDLFlBQVksR0FBVyxDQUFDLENBQUM7SUFDaEMsTUFBTSxDQUFDLFVBQVUsR0FBVyxDQUFDLENBQUM7SUFDOUIsTUFBTSxDQUFDLGdCQUFnQixHQUFXLENBQUMsQ0FBQztJQUdwQyxNQUFNLENBQUMsWUFBWSxHQUFXLENBQUMsQ0FBQztJQUNoQyxNQUFNLENBQUMsZ0JBQWdCLEdBQVcsQ0FBQyxDQUFDO0lBRXBDLE1BQU0sQ0FBQyxhQUFhLEdBQVcsRUFBRSxDQUFDO0lBQ2xDLE1BQU0sQ0FBQyxhQUFhLEdBQVcsRUFBRSxDQUFDO0lBRWxDLE1BQU0sQ0FBQyxrQkFBa0IsR0FBVyxFQUFFLENBQUM7SUFDdkMsTUFBTSxDQUFDLGtCQUFrQixHQUFXLEVBQUUsQ0FBQztJQUN2QyxNQUFNLENBQUMsa0JBQWtCLEdBQVcsRUFBRSxDQUFDO0lBTXZDLE1BQU0sQ0FBQyxhQUFhLEdBQVcsRUFBRSxDQUFDO0lBRWxDLE1BQU0sQ0FBQyxnQkFBZ0IsR0FBVyxFQUFFLENBQUM7SUFJckMsTUFBTSxDQUFDLG1CQUFtQixHQUFXLEdBQUcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBGbG93TW9uaXRvckludGVyZmFjZSB7XHJcbiAgc3RhdGljIEZMV01UUl9TVEFSVDogbnVtYmVyID0gMDtcclxuICBzdGF0aWMgRkxXTVRSX0VORDogbnVtYmVyID0gMTtcclxuICBzdGF0aWMgRkxXTVRSX1BST1BBR0FURTogbnVtYmVyID0gMjtcclxuXHJcblxyXG4gIHN0YXRpYyBGTFdNVFJfRVZFTlQ6IG51bWJlciA9IDc7XHJcbiAgc3RhdGljIEZMV01UUl9DSE5HX01PREU6IG51bWJlciA9IDg7XHJcblxyXG4gIHN0YXRpYyBGTFdNVFJfUFJFRklYOiBudW1iZXIgPSAxNTtcclxuICBzdGF0aWMgRkxXTVRSX1NVRkZJWDogbnVtYmVyID0gMTY7XHJcblxyXG4gIHN0YXRpYyBGTFdNVFJfQ1RSTF9QUkVGSVg6IG51bWJlciA9IDE4O1xyXG4gIHN0YXRpYyBGTFdNVFJfQ1RSTF9TVUZGSVg6IG51bWJlciA9IDE5O1xyXG4gIHN0YXRpYyBGTFdNVFJfVFNLX0hBTkRMRVI6IG51bWJlciA9IDIwO1xyXG5cclxuXHJcblxyXG5cclxuICAvKiBSZWNvbXB1dGUgbWVzc2FnZXMgKi9cclxuICBzdGF0aWMgRkxXTVRSX1JFQ09NUDogbnVtYmVyID0gMzE7XHJcbiAgLyogT3BlcmF0aW9ucyBtZXNzYWdlcyAqL1xyXG4gIHN0YXRpYyBGTFdNVFJfREFUQV9PUEVSOiBudW1iZXIgPSA0MTtcclxuICAvKiBMT0cgbWVzc2FnZXMgKi9cclxuXHJcblxyXG4gIHN0YXRpYyBGTFdNVFJfVkFSQ0hHX1ZBTFVFOiBudW1iZXIgPSAxMTk7XHJcblxyXG59XHJcbiJdfQ==

package/esm2022/src/GUIManager.mjs

@@ -0,0 +1,62 @@
+import { MsgInterface } from '@magic-xpa/utils';
+import { Commands, Manager, Styles } from '@magic-xpa/gui';
+import { RCTimer } from './tasks/RCTimer';
+import { LanguageData } from './env/LanguageData';
+import { AccessHelper } from './AccessHelper';
+export class GUIManager {
+    static _instance = null;
+    static get Instance() {
+        if (GUIManager._instance === null)
+            GUIManager._instance = new GUIManager();
+        return GUIManager._instance;
+    }
+    execGuiCommandQueue() {
+        Commands.beginInvoke();
+    }
+    startTimer(mgData, seconds, isIdleTimer) {
+        if (seconds > 0) {
+            let objRCTimer = new RCTimer(mgData, seconds * 1000, isIdleTimer);
+            (objRCTimer).Start();
+            Commands.beginInvoke();
+        }
+    }
+    stopTimer(mgData, seconds, isIdleTimer) {
+        if (seconds > 0)
+            RCTimer.StopTimer(mgData, seconds * 1000, isIdleTimer);
+    }
+    abort(form) {
+        if (arguments.length === 1)
+            this.abort_0(form);
+        else
+            this.abort_1();
+    }
+    abort_0(form) {
+        if (form !== null) {
+            Manager.Abort(form);
+        }
+    }
+    abort_1() {
+        for (let i = AccessHelper.mgDataTable.getSize(); i > 0; i--) {
+            const task = AccessHelper.mgDataTable.getMGData(i - 1).getFirstTask();
+            if (task !== null)
+                this.abort(task.Form);
+        }
+    }
+    async MessageBox(title, msg, style) {
+        await AccessHelper.eventsManager.CheckAndShowSpinner(false);
+        return await Commands.messageBox(title, msg, style);
+    }
+    async writeToMessageBox(titleId, msgId, style) {
+        let title = LanguageData.Instance.getConstMessage(titleId);
+        let msg = LanguageData.Instance.getConstMessage(msgId);
+        return await this.MessageBox(title, msg, style);
+    }
+    async confirm(msgId, style) {
+        return await this.writeToMessageBox(MsgInterface.CONFIRM_STR_WINDOW_TITLE, msgId, style);
+    }
+    async confirm_bool(msgId) {
+        let retResult = await this.confirm(msgId, Styles.MSGBOX_BUTTON_OK_CANCEL);
+        return retResult == Styles.MSGBOX_RESULT_OK;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GUIManager.js","sourceRoot":"","sources":["../../../../../projects/engine/src/GUIManager.ts"],"names":[],"mappings":"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","sourcesContent":["import {MsgInterface} from '@magic-xpa/utils';\r\nimport {Commands, Manager, Styles} from '@magic-xpa/gui';\r\nimport {MGData} from './tasks/MGData';\r\nimport {RCTimer} from './tasks/RCTimer';\r\nimport {MgForm} from './gui/MgForm';\r\n\r\nimport {LanguageData} from './env/LanguageData';\r\nimport {AccessHelper} from './AccessHelper';\r\n\r\n/// <summary>\r\n/// </summary>\r\n// @dynamic\r\nexport class GUIManager {\r\n  private static _instance: GUIManager = null; // the single instance of the GUIManager\r\n\r\n  ///   singleton\r\n  /// </summary>\r\n  static get Instance(): GUIManager {\r\n    if (GUIManager._instance === null)\r\n      GUIManager._instance = new GUIManager();\r\n    return GUIManager._instance;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   execute the commands in the queue\r\n  /// </summary>\r\n  execGuiCommandQueue(): void {\r\n    Commands.beginInvoke();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   start a timer\r\n  /// </summary>\r\n  /// <param name = \"mgd\"> MgData </param>\r\n  /// <param name = \"seconds\">interval in full seconds to invoke the function (from current time)</param>\r\n  /// <param name = \"isIdleTimer\">true if this timer is the idle timer</param>\r\n  startTimer(mgData: MGData, seconds: number, isIdleTimer: boolean): void {\r\n    if (seconds > 0) {\r\n      // RCTimer/MgTimer works on milliseconds so convert seconds to milliseconds\r\n      let objRCTimer: RCTimer = new RCTimer(mgData, seconds * 1000, isIdleTimer);\r\n      (objRCTimer).Start();\r\n      // fixed bug 284566, while we have command in he queue, execute them\r\n      Commands.beginInvoke();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   stop the timer\r\n  /// </summary>\r\n  /// <param name = \"MgData\"> MgData</param>\r\n  /// <param name = \"seconds\">interval in full seconds to invoke the function (from current time)</param>\r\n  /// <param name = \"isIdleTimer\">true if this timer is the idle timer</param>\r\n  stopTimer(mgData: MGData, seconds: number, isIdleTimer: boolean): void {\r\n    if (seconds > 0)\r\n    // RCTimer/MgTimer works on milliseconds so convert seconds to milliseconds\r\n      RCTimer.StopTimer(mgData, seconds * 1000, isIdleTimer);\r\n  }\r\n\r\n  abort(form: MgForm): void;\r\n  abort(): void;\r\n  abort(form?: MgForm): void {\r\n    if (arguments.length === 1)\r\n      this.abort_0(form);\r\n    else\r\n      this.abort_1();\r\n  }\r\n\r\n  /// <summary>\r\n  ///  close the task\r\n  /// </summary>\r\n  /// <param name = \"form\"> </param>\r\n  private abort_0(form: MgForm): void {\r\n    if (form !== null) {\r\n      Manager.Abort(form);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   process ABORT command.Close all shells. Last shell closed, will close the display.\r\n  /// </summary>\r\n  private abort_1(): void {\r\n    for (let i = AccessHelper.mgDataTable.getSize(); i > 0; i--) {\r\n      const task =  AccessHelper.mgDataTable.getMGData(i - 1).getFirstTask();\r\n      if(task !== null)\r\n        this.abort(<MgForm>task.Form);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Open message box with title string and message string\r\n  /// </summary>\r\n  /// <param name = \"title\">title of the message box</param>\r\n  /// <param name = \"msg\">message for the message box</param>\r\n  /// <param name = \"style\">the style of the message box --- buttons, icon</param>\r\n  /// <returns> the button clicked </returns>\r\n  async MessageBox(title: string, msg: string, style: number) : Promise<number> {\r\n    // Stop the spinner before showing the mesage box\r\n    await AccessHelper.eventsManager.CheckAndShowSpinner(false);\r\n\r\n    return await Commands.messageBox(title, msg, style);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Open message box with title id and message id that will take from MGBCL*ENG.xml (created by mgconst)\r\n  /// </summary>\r\n  /// <param name = \"titleId\">message from from MGBCL*ENG.xml</param>\r\n  /// <param name = \"msgId\">message from from MGBCL*ENG.xml</param>\r\n  /// <param name = \"style\">the style of the message box can be flags of Styles.MSGBOX_xxx </param>\r\n  /// <returns> message box style from Styles.MSGBOX_XXX</returns>\r\n  async writeToMessageBox(titleId: string, msgId: string, style: number):Promise<number> {\r\n    let title: string = LanguageData.Instance.getConstMessage(titleId);\r\n    let msg: string = LanguageData.Instance.getConstMessage(msgId);\r\n\r\n    return await this.MessageBox(title, msg, style);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   display a Message Box (confirm) with 2 buttons .\r\n  /// </summary>\r\n  /// <param name = \"msgId\">message number (from MsgInterface.java) that will be display on the content of the Message Box </param>\r\n  /// <param name = \"style\">the icon and the button that will be display on the confirmation box </param>\r\n  /// <returns> the button that was pressed (Styles.MSGBOX_BUTTON_xxx) </returns>\r\n  async confirm(msgId: string, style: number): Promise<number>;\r\n  async confirm(msgId: string, style?: number): Promise<any> {\r\n\r\n    return await this.writeToMessageBox(MsgInterface.CONFIRM_STR_WINDOW_TITLE, msgId, style);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   display a Message Box (confirm) with 2 buttons : yes & no and icon question.\r\n  /// </summary>\r\n  /// <param name = \"msgId\">message number (from MsgInterface.java) that will be display on the content of the Message Box\r\n  ///   return true if the button YES was pressed\r\n  /// </param>\r\n  public async confirm_bool(msgId: string): Promise<boolean> {\r\n    let retResult: number = await this.confirm(msgId, Styles.MSGBOX_BUTTON_OK_CANCEL);\r\n    return retResult == <number>Styles.MSGBOX_RESULT_OK;\r\n  }\r\n}\r\n"]}

package/esm2022/src/GlobalCommandsManager.mjs

@@ -0,0 +1,34 @@
+import { List } from "@magic-xpa/mscorelib";
+export class GlobalCommandsManager {
+    static Instance = new GlobalCommandsManager();
+    constructor() {
+        this._CommandsExecutedAfterTaskStarted = new List();
+        this._cmdFrame = 0;
+        this._unframedCmds = new List();
+    }
+    _CommandsExecutedAfterTaskStarted = null;
+    _cmdFrame = 0;
+    _unframedCmds = null;
+    getCommandsExecutedAfterTaskStarted() {
+        return this._CommandsExecutedAfterTaskStarted;
+    }
+    addCommandsExecutedAfterTaskStarted(cmd) {
+        this._CommandsExecutedAfterTaskStarted.push(cmd);
+    }
+    removeCommandsExecutedAfterTaskStarted(cmd) {
+        this._CommandsExecutedAfterTaskStarted.Remove(cmd);
+    }
+    add1toCmdFrame() {
+        this._cmdFrame++;
+    }
+    getCmdFrame() {
+        return this._cmdFrame;
+    }
+    addUnframedCmd(cmd) {
+        this._unframedCmds.push(cmd);
+    }
+    getUnframedCmds() {
+        return this._unframedCmds;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/GuiEventsProcessor.mjs

@@ -0,0 +1,157 @@
+import { CtrlButtonTypeGui, InternalInterface, Logger, MgControlType, Misc } from '@magic-xpa/utils';
+import { Events, EventsProcessor, RuntimeContextBase } from '@magic-xpa/gui';
+import { RunTimeEvent } from './event/RunTimeEvent';
+import { RCTimer } from './tasks/RCTimer';
+import { MGDataCollection } from './tasks/MGDataCollection';
+import { EventsManager } from './event/EventsManager';
+import { LanguageData } from './env/LanguageData';
+import { EnvParamsTable } from './env/EnvVariablesTable';
+import { LastFocusedManager } from './rt/LastFocusedManager';
+import { ServerConfig } from './ServerConfig';
+import { ClientManager } from "./ClientManager";
+export class GuiEventsProcessor extends EventsProcessor {
+    RegisterSubclassHandlers() {
+        Events.FocusEvent = GuiEventsProcessor.processFocus;
+        Events.FocusOnNonMagicControlEvent = GuiEventsProcessor.processFocusOnNonMagicControl;
+        Events.MouseUpEvent = GuiEventsProcessor.processMouseUp;
+        Events.SelectionEvent = GuiEventsProcessor.processSelection;
+        Events.DisposeEvent = GuiEventsProcessor.processDispose;
+        Events.TimerEvent = GuiEventsProcessor.ProcessTimer;
+        Events.TableResizeEvent = GuiEventsProcessor.processTableResize;
+        Events.GetRowsDataEvent = GuiEventsProcessor.processGetRowsData;
+        Events.NonParkableLastParkedCtrlEvent = GuiEventsProcessor.OnNonParkableLastParkedCtrl;
+        Events.ShowSessionStatisticsEvent = GuiEventsProcessor.ShowSessionStatistics;
+        Events.WriteExceptionToLogEvent = Logger.Instance.WriteExceptionToLogWithMsg.bind(Logger.Instance);
+        Events.WriteErrorToLogEvent = Logger.Instance.WriteErrorToLog.bind(Logger.Instance);
+        Events.WriteWarningToLogEvent = Logger.Instance.WriteWarningToLogWithMsg.bind(Logger.Instance);
+        Events.ShouldLogEvent = Logger.Instance.ShouldLog.bind(Logger.Instance);
+        Events.WriteGuiToLogEvent = Logger.Instance.WriteGuiToLog.bind(Logger.Instance);
+        Events.WriteDevToLogEvent = Logger.Instance.WriteDevToLog.bind(Logger.Instance);
+        Events.TranslateEvent = LanguageData.Instance.translate.bind(LanguageData.Instance);
+        Events.PeekEndOfWorkEvent = GuiEventsProcessor.peekEndOfWork;
+        Events.TranslateLogicalNameEvent = EnvParamsTable.Instance.translate.bind(EnvParamsTable.Instance);
+        Events.GetAssetsURL = ClientManager.GetAssetsURL;
+        Events.GetMainProgramEvent = GuiEventsProcessor.getMainProgram;
+        Events.GetMessageStringEvent = LanguageData.Instance.getConstMessage.bind(LanguageData.Instance);
+        Events.CtrlFocusEvent = GuiEventsProcessor.processCtrlFocus;
+        Events.GetRuntimeContextEvent = GuiEventsProcessor.GetRuntimeContext;
+        Events.SaveLastClickedCtrlEvent = GuiEventsProcessor.SaveLastClickedControlName;
+        Events.SaveLastClickInfoEvent = GuiEventsProcessor.SaveLastClickInfo;
+        Events.OnIsLogonRTLEvent = GuiEventsProcessor.IsLogonRTL;
+        Events.ShouldAddEnterAsKeyEvent = GuiEventsProcessor.ShouldAddEnterAsKeyEvent;
+    }
+    constructor() {
+        super();
+    }
+    static processCtrlFocus(iTask, mgControl) {
+        LastFocusedManager.setLastFocusedControl(iTask, mgControl);
+    }
+    static processFocus(guiMgCtrl, line, isProduceClick, onMultiMark) {
+        let mgControl = guiMgCtrl;
+        EventsManager.Instance.addGuiTriggeredEventWithCtrlAndLineAndCodeAndIsProductClick(mgControl, InternalInterface.MG_ACT_CTRL_FOCUS, line, isProduceClick);
+    }
+    static processFocusOnNonMagicControl(guiMgCtrl) {
+        let mgControl = guiMgCtrl;
+        EventsManager.Instance.addGuiTriggeredEventWithCtrlAndCodeAndLine(mgControl, InternalInterface.MG_ACT_CTRL_FOCUS_ON_NON_MAGIC_CONTROL, mgControl.getDisplayLine(true));
+    }
+    static processMouseUp(guiMgCtrl, line) {
+        let mgControl = guiMgCtrl;
+        let rtEvt = new RunTimeEvent(mgControl, line, true);
+        let produceClick = true;
+        if (mgControl.Type === MgControlType.CTRL_TYPE_BUTTON && guiMgCtrl.ButtonStyle === CtrlButtonTypeGui.Hypertext)
+            produceClick = false;
+        rtEvt.setProduceClick(produceClick);
+        rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_MOUSEUP);
+        EventsManager.Instance.addToTail(rtEvt);
+    }
+    static processDispose(guiMgForm) {
+        let form = guiMgForm;
+        let task = form.getTask();
+        let mgd = task.getMGData();
+        RCTimer.StopAll(mgd);
+        if (mgd.IsAborting)
+            MGDataCollection.Instance.deleteMGDataTree(mgd.GetId());
+    }
+    static ProcessTimer(mgTimer) {
+        let mgd = mgTimer.GetMgdata();
+        let task = mgd.getFirstTask();
+        let seconds = Math.floor((mgTimer.TimerIntervalMiliSeconds) / 1000);
+        let isIdle = mgTimer.IsIdleTimer;
+        if (mgd.IsAborting)
+            return;
+        let rtEvt = new RunTimeEvent(task, true);
+        rtEvt.setTimer(seconds, mgd.GetId(), isIdle);
+        rtEvt.setMainPrgCreator(rtEvt.getTask());
+        if (!isIdle)
+            rtEvt.setCtrl(task.getLastParkedCtrl());
+        rtEvt.setInternal(InternalInterface.MG_ACT_TIMER);
+        EventsManager.Instance.addToTail(rtEvt);
+    }
+    static processTableResize(guiMgCtrl, newRowsInPage) {
+        let mgControl = guiMgCtrl;
+        if (mgControl != null) {
+            let rtEvt = new RunTimeEvent(mgControl, newRowsInPage, true);
+            rtEvt.setInternal(InternalInterface.MG_ACT_RESIZE);
+            EventsManager.Instance.addToTail(rtEvt);
+        }
+    }
+    static processGetRowsData(guiMgCtrl, desiredTopIndex, sendAll, lastFocusedVal) {
+        let mgControl = guiMgCtrl;
+        if (mgControl != null && mgControl.Type === MgControlType.CTRL_TYPE_TABLE) {
+            let rtEvt = new RunTimeEvent(mgControl, desiredTopIndex, true);
+            rtEvt.setInternal(InternalInterface.MG_ACT_ROW_DATA_CURR_PAGE);
+            rtEvt.setSendAll(sendAll);
+            rtEvt.LastFocusedVal = lastFocusedVal;
+            EventsManager.Instance.addToTail(rtEvt);
+        }
+    }
+    static OnNonParkableLastParkedCtrl(ctrl) {
+    }
+    static processSelection(val, guiMgCtrl, line, produceClick) {
+        let mgControl = guiMgCtrl;
+        if (guiMgCtrl.ConnectedControl) {
+            let rtEvt = new RunTimeEvent(mgControl, +line, true);
+            rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_FOCUS);
+            rtEvt.ShouldHandleZoom = true;
+            rtEvt.setProduceClick(produceClick);
+            EventsManager.Instance.addToTail(rtEvt);
+        }
+        else {
+            if (mgControl.Type === MgControlType.CTRL_TYPE_BUTTON && mgControl.getForm().getTask().getLastParkedCtrl() !== mgControl)
+                produceClick = true;
+            let rtEvt = new RunTimeEvent(mgControl, +line, true);
+            rtEvt.setInternal(InternalInterface.MG_ACT_SELECTION);
+            rtEvt.setValue(val);
+            rtEvt.setProduceClick(produceClick);
+            EventsManager.Instance.addToTail(rtEvt);
+        }
+    }
+    processKeyDown(guiMgForm, guiMgCtrl, modifier, keyCode, start, end, text, isActChar, suggestedValue, handled) {
+        LastFocusedManager.Instance.LastActionTime = Misc.getSystemMilliseconds();
+        return super.processKeyDown(guiMgForm, guiMgCtrl, modifier, keyCode, start, end, text, isActChar, suggestedValue, handled);
+    }
+    static peekEndOfWork() {
+        return EventsManager.Instance.getEndOfWork();
+    }
+    static getMainProgram(contextID, ctlIdx) {
+        return MGDataCollection.Instance.GetMainProgByCtlIdx(contextID, ctlIdx);
+    }
+    static GetRuntimeContext(contextID) {
+        return RuntimeContextBase.Instance;
+    }
+    static SaveLastClickedControlName(ctrlName) {
+        RuntimeContextBase.Instance.LastClickedCtrlName = ctrlName;
+    }
+    static SaveLastClickInfo(controlName, X, Y, offsetX, offsetY, LastClickCoordinatesAreInPixels) {
+        RuntimeContextBase.Instance.SaveLastClickInfo(controlName, X, Y, offsetX, offsetY, LastClickCoordinatesAreInPixels);
+    }
+    static IsLogonRTL() {
+        return ServerConfig.Instance.IsLogonRTL();
+    }
+    static ShowSessionStatistics() {
+    }
+    static ShouldAddEnterAsKeyEvent() {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GuiEventsProcessor.js","sourceRoot":"","sources":["../../../../../projects/engine/src/GuiEventsProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAC;AACnG,OAAO,EACL,MAAM,EACN,eAAe,EAQf,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAGlD,OAAO,EAAC,OAAO,EAAC,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAC,kBAAkB,EAAC,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAE9C,MAAM,OAAO,kBAAmB,SAAQ,eAAe;IACrD,wBAAwB;QACtB,MAAM,CAAC,UAAU,GAAG,kBAAkB,CAAC,YAAY,CAAC;QACpD,MAAM,CAAC,2BAA2B,GAAG,kBAAkB,CAAC,6BAA6B,CAAC;QACtF,MAAM,CAAC,YAAY,GAAG,kBAAkB,CAAC,cAAc,CAAC;QACxD,MAAM,CAAC,cAAc,GAAG,kBAAkB,CAAC,gBAAgB,CAAC;QAC5D,MAAM,CAAC,YAAY,GAAG,kBAAkB,CAAC,cAAc,CAAC;QACxD,MAAM,CAAC,UAAU,GAAG,kBAAkB,CAAC,YAAY,CAAC;QACpD,MAAM,CAAC,gBAAgB,GAAG,kBAAkB,CAAC,kBAAkB,CAAC;QAChE,MAAM,CAAC,gBAAgB,GAAG,kBAAkB,CAAC,kBAAkB,CAAC;QAChE,MAAM,CAAC,8BAA8B,GAAG,kBAAkB,CAAC,2BAA2B,CAAC;QACvF,MAAM,CAAC,0BAA0B,GAAG,kBAAkB,CAAC,qBAAqB,CAAC;QAE7E,MAAM,CAAC,wBAAwB,GAAG,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACnG,MAAM,CAAC,oBAAoB,GAAG,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACpF,MAAM,CAAC,sBAAsB,GAAG,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC/F,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACxE,MAAM,CAAC,kBAAkB,GAAG,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAChF,MAAM,CAAC,kBAAkB,GAAG,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEhF,MAAM,CAAC,cAAc,GAAG,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAEpF,MAAM,CAAC,kBAAkB,GAAG,kBAAkB,CAAC,aAAa,CAAC;QAE7D,MAAM,CAAC,yBAAyB,GAAG,cAAc,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QACnG,MAAM,CAAC,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC;QACjD,MAAM,CAAC,mBAAmB,GAAG,kBAAkB,CAAC,cAAc,CAAC;QAC/D,MAAM,CAAC,qBAAqB,GAAG,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAEjG,MAAM,CAAC,cAAc,GAAG,kBAAkB,CAAC,gBAAgB,CAAC;QAC5D,MAAM,CAAC,sBAAsB,GAAG,kBAAkB,CAAC,iBAAiB,CAAC;QACrE,MAAM,CAAC,wBAAwB,GAAG,kBAAkB,CAAC,0BAA0B,CAAC;QAChF,MAAM,CAAC,sBAAsB,GAAG,kBAAkB,CAAC,iBAAiB,CAAC;QAGrE,MAAM,CAAC,iBAAiB,GAAG,kBAAkB,CAAC,UAAU,CAAC;QACzD,MAAM,CAAC,wBAAwB,GAAG,kBAAkB,CAAC,wBAAwB,CAAC;IAEhF,CAAC;IAGD;QACE,KAAK,EAAE,CAAC;IACV,CAAC;IAKO,MAAM,CAAC,gBAAgB,CAAC,KAAY,EAAE,SAAwB;QACpE,kBAAkB,CAAC,qBAAqB,CAAO,KAAK,EAAE,SAAS,CAAC,CAAC;IACnE,CAAC;IAQO,MAAM,CAAC,YAAY,CAAC,SAAuB,EAAE,IAAY,EAAE,cAAuB,EAAE,WAAoB;QAC9G,IAAI,SAAS,GAAyB,SAAS,CAAC;QAChD,aAAa,CAAC,QAAQ,CAAC,2DAA2D,CAAC,SAAS,EAAE,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;IAC3J,CAAC;IAIO,MAAM,CAAC,6BAA6B,CAAC,SAAuB;QAClE,IAAI,SAAS,GAAyB,SAAS,CAAC;QAChD,aAAa,CAAC,QAAQ,CAAC,0CAA0C,CAAC,SAAS,EAAE,iBAAiB,CAAC,sCAAsC,EAAE,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;IACzK,CAAC;IAMO,MAAM,CAAC,cAAc,CAAC,SAAuB,EAAE,IAAY;QACjE,IAAI,SAAS,GAAc,SAAS,CAAC;QACrC,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QACpD,IAAI,YAAY,GAAY,IAAI,CAAC;QAEjC,IAAI,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,gBAAgB,IAAI,SAAS,CAAC,WAAW,KAAK,iBAAiB,CAAC,SAAS;YAC5G,YAAY,GAAG,KAAK,CAAC;QAEvB,KAAK,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;QACpC,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;QACzD,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAOO,MAAM,CAAC,cAAc,CAAC,SAAoB;QAChD,IAAI,IAAI,GAAW,SAAS,CAAC;QAC7B,IAAI,IAAI,GAAS,IAAI,CAAC,OAAO,EAAE,CAAC;QAChC,IAAI,GAAG,GAAW,IAAI,CAAC,SAAS,EAAE,CAAC;QAEnC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAErB,IAAI,GAAG,CAAC,UAAU;YAChB,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5D,CAAC;IAIO,MAAM,CAAC,YAAY,CAAC,OAAgB;QAC1C,IAAI,GAAG,GAAqB,OAAQ,CAAC,SAAS,EAAE,CAAC;QACjD,IAAI,IAAI,GAAG,GAAG,CAAC,YAAY,EAAE,CAAC;QAI9B,IAAI,OAAO,GAAW,IAAI,CAAC,KAAK,CAAC,CAAW,OAAQ,CAAC,wBAAwB,CAAC,GAAG,IAAI,CAAC,CAAC;QACvF,IAAI,MAAM,GAAsB,OAAQ,CAAC,WAAW,CAAC;QAErD,IAAI,GAAG,CAAC,UAAU;YAChB,OAAO;QAET,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACzC,KAAK,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,KAAK,EAAE,EAAE,MAAM,CAAC,CAAC;QAC7C,KAAK,CAAC,iBAAiB,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAEzC,IAAI,CAAC,MAAM;YACT,KAAK,CAAC,OAAO,CAAY,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC;QAErD,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;QAClD,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAKO,MAAM,CAAC,kBAAkB,CAAC,SAAuB,EAAE,aAAqB;QAC5E,IAAI,SAAS,GAAc,SAAS,CAAC;QACrC,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;YACpB,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;YAC7D,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC;YACnD,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC5C,CAAC;IACL,CAAC;IAKO,MAAM,CAAC,kBAAkB,CAAC,SAAuB,EAAE,eAAuB,EAAE,OAAgB,EAAE,cAA8B;QAChI,IAAI,SAAS,GAAc,SAAS,CAAC;QAErC,IAAI,SAAS,IAAI,IAAI,IAAI,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,eAAe,EAAE,CAAC;YACxE,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,SAAS,EAAE,eAAe,EAAE,IAAI,CAAC,CAAC;YAC/D,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,yBAAyB,CAAC,CAAC;YAC/D,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YAC1B,KAAK,CAAC,cAAc,GAAG,cAAc,CAAC;YACtC,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC5C,CAAC;IACL,CAAC;IAOO,MAAM,CAAC,2BAA2B,CAAC,IAAkB;IAC7D,CAAC;IAOO,MAAM,CAAC,gBAAgB,CAAC,GAAW,EAAE,SAAuB,EAAE,IAAY,EAAE,YAAqB;QACrG,IAAI,SAAS,GAAc,SAAS,CAAC;QAErC,IAAI,SAAS,CAAC,gBAAgB,EAAE,CAAC;YAC7B,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACrD,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;YACvD,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAC9B,KAAK,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;YACpC,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC5C,CAAC;aACI,CAAC;YACF,IAAI,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,gBAAgB,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,iBAAiB,EAAE,KAAK,SAAS;gBACpH,YAAY,GAAG,IAAI,CAAC;YAExB,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACrD,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;YACtD,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACpB,KAAK,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;YACpC,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC5C,CAAC;IACL,CAAC;IAiBD,cAAc,CAAC,SAAoB,EAAE,SAAuB,EAAE,QAAmB,EAClE,OAAe,EAAE,KAAa,EAAE,GAAW,EAAE,IAAY,EACzD,SAAkB,EAAE,cAAsB,EAC1C,OAAgB;QAE7B,kBAAkB,CAAC,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAG1E,OAAO,KAAK,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAG,OAAO,CAAC,CAAC;IAC9H,CAAC;IAMO,MAAM,CAAC,aAAa;QAC1B,OAAO,aAAa,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;IAC/C,CAAC;IAMO,MAAM,CAAC,cAAc,CAAC,SAAiB,EAAE,MAAc;QAC7D,OAAO,gBAAgB,CAAC,QAAQ,CAAC,mBAAmB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAC1E,CAAC;IAMO,MAAM,CAAC,iBAAiB,CAAC,SAAiB;QAChD,OAAO,kBAAkB,CAAC,QAAQ,CAAC;IACrC,CAAC;IAOO,MAAM,CAAC,0BAA0B,CAAC,QAAgB;QACxD,kBAAkB,CAAC,QAAQ,CAAC,mBAAmB,GAAG,QAAQ,CAAC;IAC7D,CAAC;IAYO,MAAM,CAAC,iBAAiB,CAAC,WAAmB,EAAE,CAAS,EAAE,CAAS,EAAE,OAAe,EAAE,OAAe,EAAE,+BAAwC;QACpJ,kBAAkB,CAAC,QAAQ,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,+BAA+B,CAAC,CAAC;IACtH,CAAC;IAOO,MAAM,CAAC,UAAU;QACvB,OAAO,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;IAC5C,CAAC;IAIO,MAAM,CAAC,qBAAqB;IACpC,CAAC;IAOO,MAAM,CAAC,wBAAwB;QACrC,OAAO,KAAK,CAAC;IACf,CAAC;CAGF","sourcesContent":["import {CtrlButtonTypeGui, InternalInterface, Logger, MgControlType, Misc} from '@magic-xpa/utils';\r\nimport {\r\n  Events,\r\n  EventsProcessor,\r\n  GuiMgControl,\r\n  GuiMgForm,\r\n  ITask,\r\n  LastFocusedVal,\r\n  MgControlBase,\r\n  MgTimer,\r\n  Modifiers,\r\n  RuntimeContextBase\r\n} from '@magic-xpa/gui';\r\nimport {MgControl} from './gui/MgControl';\r\nimport {RunTimeEvent} from './event/RunTimeEvent';\r\nimport {MgForm} from './gui/MgForm';\r\nimport {MGData} from './tasks/MGData';\r\nimport {RCTimer} from './tasks/RCTimer';\r\nimport {MGDataCollection} from './tasks/MGDataCollection';\r\nimport {Task} from './tasks/Task';\r\nimport {EventsManager} from './event/EventsManager';\r\nimport {LanguageData} from './env/LanguageData';\r\nimport {EnvParamsTable} from './env/EnvVariablesTable';\r\nimport {LastFocusedManager} from './rt/LastFocusedManager';\r\nimport {ServerConfig} from './ServerConfig';\r\nimport {ClientManager} from \"./ClientManager\";\r\n\r\nexport class GuiEventsProcessor extends EventsProcessor {\r\n  RegisterSubclassHandlers(): void {\r\n    Events.FocusEvent = GuiEventsProcessor.processFocus;\r\n    Events.FocusOnNonMagicControlEvent = GuiEventsProcessor.processFocusOnNonMagicControl;\r\n    Events.MouseUpEvent = GuiEventsProcessor.processMouseUp;\r\n    Events.SelectionEvent = GuiEventsProcessor.processSelection;\r\n    Events.DisposeEvent = GuiEventsProcessor.processDispose;\r\n    Events.TimerEvent = GuiEventsProcessor.ProcessTimer;\r\n    Events.TableResizeEvent = GuiEventsProcessor.processTableResize;\r\n    Events.GetRowsDataEvent = GuiEventsProcessor.processGetRowsData;\r\n    Events.NonParkableLastParkedCtrlEvent = GuiEventsProcessor.OnNonParkableLastParkedCtrl;\r\n    Events.ShowSessionStatisticsEvent = GuiEventsProcessor.ShowSessionStatistics;\r\n\r\n    Events.WriteExceptionToLogEvent = Logger.Instance.WriteExceptionToLogWithMsg.bind(Logger.Instance);\r\n    Events.WriteErrorToLogEvent = Logger.Instance.WriteErrorToLog.bind(Logger.Instance);\r\n    Events.WriteWarningToLogEvent = Logger.Instance.WriteWarningToLogWithMsg.bind(Logger.Instance);\r\n    Events.ShouldLogEvent = Logger.Instance.ShouldLog.bind(Logger.Instance);\r\n    Events.WriteGuiToLogEvent = Logger.Instance.WriteGuiToLog.bind(Logger.Instance);\r\n    Events.WriteDevToLogEvent = Logger.Instance.WriteDevToLog.bind(Logger.Instance);\r\n\r\n    Events.TranslateEvent = LanguageData.Instance.translate.bind(LanguageData.Instance);\r\n\r\n    Events.PeekEndOfWorkEvent = GuiEventsProcessor.peekEndOfWork;\r\n\r\n    Events.TranslateLogicalNameEvent = EnvParamsTable.Instance.translate.bind(EnvParamsTable.Instance);\r\n    Events.GetAssetsURL = ClientManager.GetAssetsURL;\r\n    Events.GetMainProgramEvent = GuiEventsProcessor.getMainProgram;\r\n    Events.GetMessageStringEvent = LanguageData.Instance.getConstMessage.bind(LanguageData.Instance);\r\n\r\n    Events.CtrlFocusEvent = GuiEventsProcessor.processCtrlFocus;\r\n    Events.GetRuntimeContextEvent = GuiEventsProcessor.GetRuntimeContext;\r\n    Events.SaveLastClickedCtrlEvent = GuiEventsProcessor.SaveLastClickedControlName;\r\n    Events.SaveLastClickInfoEvent = GuiEventsProcessor.SaveLastClickInfo;\r\n\r\n\r\n    Events.OnIsLogonRTLEvent = GuiEventsProcessor.IsLogonRTL;\r\n    Events.ShouldAddEnterAsKeyEvent = GuiEventsProcessor.ShouldAddEnterAsKeyEvent;\r\n\r\n  }\r\n\r\n  /// <summary> CTOR </summary>\r\n  constructor() {\r\n    super();\r\n  }\r\n\r\n  /// <summary> </summary>\r\n  /// <param name=\"iTask\"></param>\r\n  /// <param name=\"mgControl\"></param>\r\n  private static processCtrlFocus(iTask: ITask, mgControl: MgControlBase): void {\r\n    LastFocusedManager.setLastFocusedControl(<Task>iTask, mgControl);\r\n  }\r\n\r\n  /// <summary>process \"focus\" event</summary>\r\n  /// <param name = \"value\">the value of the control</param>\r\n  /// <param name = \"line\">the line of multiline control</param>\r\n  /// <returns> TRUE if Magic internal rules allow us to perform the focus.\r\n  ///   sometimes, Magic forces us to return to the original control thus FALSE will be returned.\r\n  /// </returns>\r\n  private static processFocus(guiMgCtrl: GuiMgControl, line: number, isProduceClick: boolean, onMultiMark: boolean): void {\r\n    let mgControl: MgControl = <MgControl>guiMgCtrl;\r\n    EventsManager.Instance.addGuiTriggeredEventWithCtrlAndLineAndCodeAndIsProductClick(mgControl, InternalInterface.MG_ACT_CTRL_FOCUS, line, isProduceClick);\r\n  }\r\n\r\n  /// <summary>process \"focus\" event</summary>\r\n  /// <param name = \"guiMgCtrl\">the control</param>\r\n  private static processFocusOnNonMagicControl(guiMgCtrl: GuiMgControl): void {\r\n    let mgControl: MgControl = <MgControl>guiMgCtrl;\r\n    EventsManager.Instance.addGuiTriggeredEventWithCtrlAndCodeAndLine(mgControl, InternalInterface.MG_ACT_CTRL_FOCUS_ON_NON_MAGIC_CONTROL, mgControl.getDisplayLine(true));\r\n  }\r\n\r\n  /// <summary>process \"click\" event</summary>\r\n  ///<param name = \"guiMgCtrl\">the control</param>\r\n  /// <param name = \"line\"> the line of the multiline control</param>\r\n  /// <param name = \"value\">the value of the control</param>\r\n  private static processMouseUp(guiMgCtrl: GuiMgControl, line: number): void {\r\n    let mgControl = <MgControl>guiMgCtrl;\r\n    let rtEvt = new RunTimeEvent(mgControl, line, true);\r\n    let produceClick: boolean = true;\r\n\r\n    if (mgControl.Type === MgControlType.CTRL_TYPE_BUTTON && guiMgCtrl.ButtonStyle === CtrlButtonTypeGui.Hypertext)\r\n      produceClick = false;\r\n\r\n    rtEvt.setProduceClick(produceClick);\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_MOUSEUP);\r\n    EventsManager.Instance.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Release references to mgData and to the task in order to let the gc to free the memory.\r\n  ///   This code was moved from processClose in order to clean also when the \"open window = NO\" (non interactive tasks).\r\n  /// </summary>\r\n  /// <param name = \"form\"></param>\r\n  private static processDispose(guiMgForm: GuiMgForm): void {\r\n    let form = <MgForm>guiMgForm;\r\n    let task = <Task>form.getTask();\r\n    let mgd: MGData = task.getMGData();\r\n\r\n    RCTimer.StopAll(mgd);\r\n\r\n    if (mgd.IsAborting)\r\n      MGDataCollection.Instance.deleteMGDataTree(mgd.GetId());\r\n  }\r\n\r\n  /// <summary>process \"timer\" event</summary>\r\n  /// <param name = \"mgTimer\">object of 'MgTimer' class</param>\r\n  private static ProcessTimer(mgTimer: MgTimer): void {\r\n    let mgd: MGData = (<RCTimer>mgTimer).GetMgdata();\r\n    let task = mgd.getFirstTask();\r\n\r\n    // MgTimer/RCTimer uses interval in milliseconds but RuntimeEvent uses interval in seconds\r\n    // so convert it to seconds.\r\n    let seconds: number = Math.floor(((<RCTimer>mgTimer).TimerIntervalMiliSeconds) / 1000);\r\n    let isIdle: boolean = (<RCTimer>mgTimer).IsIdleTimer;\r\n\r\n    if (mgd.IsAborting)\r\n      return;\r\n\r\n    let rtEvt = new RunTimeEvent(task, true);\r\n    rtEvt.setTimer(seconds, mgd.GetId(), isIdle);\r\n    rtEvt.setMainPrgCreator(rtEvt.getTask());\r\n\r\n    if (!isIdle)\r\n      rtEvt.setCtrl(<MgControl>task.getLastParkedCtrl());\r\n\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_TIMER);\r\n    EventsManager.Instance.addToTail(rtEvt);\r\n  }\r\n\r\n  /// <summary>process Resize of the page, for table controls only</summary>\r\n  /// <param name = \"guiMgCtrl\"></param>\r\n  /// <param name = \"newRowsInPage\"></param>\r\n  private static processTableResize(guiMgCtrl: GuiMgControl, newRowsInPage: number): void {\r\n      let mgControl = <MgControl>guiMgCtrl;\r\n      if (mgControl != null) {\r\n          let rtEvt = new RunTimeEvent(mgControl, newRowsInPage, true);\r\n          rtEvt.setInternal(InternalInterface.MG_ACT_RESIZE);\r\n          EventsManager.Instance.addToTail(rtEvt);\r\n      }\r\n  }\r\n\r\n  /// <summary>process set data for row</summary>\r\n  ///<param name = \"guiMgCtrl\">table control</param>\r\n  /// <param name = \"sendAll\">if true , always send all records</param>\r\n  private static processGetRowsData(guiMgCtrl: GuiMgControl, desiredTopIndex: number, sendAll: boolean, lastFocusedVal: LastFocusedVal): void {\r\n      let mgControl = <MgControl>guiMgCtrl;\r\n\r\n      if (mgControl != null && mgControl.Type === MgControlType.CTRL_TYPE_TABLE) {\r\n          let rtEvt = new RunTimeEvent(mgControl, desiredTopIndex, true);\r\n          rtEvt.setInternal(InternalInterface.MG_ACT_ROW_DATA_CURR_PAGE);\r\n          rtEvt.setSendAll(sendAll);\r\n          rtEvt.LastFocusedVal = lastFocusedVal;\r\n          EventsManager.Instance.addToTail(rtEvt);\r\n      }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// If current control becomes invisible/disabled/non parkable, then put MG_ACT_TBL_NXTFLD into queue.\r\n  /// </summary>\r\n  /// <param name=\"ctrl\">control whose property is changed.</param>\r\n  private static OnNonParkableLastParkedCtrl(ctrl: GuiMgControl): void {\r\n  }\r\n\r\n  /// <summary>process \"selection\" event</summary>\r\n  /// <param name = \"val\">the value of the control </param>\r\n  /// <param name = \"guiMgCtrl\">the control </param>\r\n  /// <param name = \"line\"> the line of the multiline control </param>\r\n  /// <param name = \"produceClick\">TODO </param>\r\n  private static processSelection(val: string, guiMgCtrl: GuiMgControl, line: number, produceClick: boolean): void {\r\n      let mgControl = <MgControl>guiMgCtrl;\r\n      \r\n      if (guiMgCtrl.ConnectedControl) {\r\n          let rtEvt = new RunTimeEvent(mgControl, +line, true);\r\n          rtEvt.setInternal(InternalInterface.MG_ACT_CTRL_FOCUS);\r\n          rtEvt.ShouldHandleZoom = true;\r\n          rtEvt.setProduceClick(produceClick);\r\n          EventsManager.Instance.addToTail(rtEvt);\r\n      }\r\n      else {\r\n          if (mgControl.Type === MgControlType.CTRL_TYPE_BUTTON && mgControl.getForm().getTask().getLastParkedCtrl() !== mgControl)\r\n              produceClick = true;\r\n\r\n          let rtEvt = new RunTimeEvent(mgControl, +line, true);\r\n          rtEvt.setInternal(InternalInterface.MG_ACT_SELECTION);\r\n          rtEvt.setValue(val);\r\n          rtEvt.setProduceClick(produceClick);\r\n          EventsManager.Instance.addToTail(rtEvt);\r\n      }\r\n  }\r\n\r\n  /// <summary></summary>\r\n  /// <param name = \"guiMgForm\"></param>\r\n  /// <param name = \"guiMgCtrl\"></param>\r\n  /// <param name = \"modifier\"></param>\r\n  /// <param name = \"keyCode\"></param>\r\n  /// <param name = \"start\"></param>\r\n  /// <param name = \"end\"></param>\r\n  /// <param name = \"text\"></param>\r\n  /// <param name = \"im\"></param>\r\n  /// <param name = \"isActChar\"></param>\r\n  /// <param name = \"suggestedValue\"></param>\r\n  /// <param name = \"dotNetArgs\"></param>\r\n  /// <param name = \"comboIsDropDown\"></param>\r\n  /// <param name=\"handled\">boolean variable event is handled or not.</param>\r\n  /// <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>\r\n  processKeyDown(guiMgForm: GuiMgForm, guiMgCtrl: GuiMgControl, modifier: Modifiers,\r\n                 keyCode: number, start: number, end: number, text: string,\r\n                 isActChar: boolean, suggestedValue: string,\r\n                 handled: boolean): boolean {\r\n    // time of last user action for IDLE function\r\n    LastFocusedManager.Instance.LastActionTime = Misc.getSystemMilliseconds();\r\n\r\n    // DOWN or UP invoked on a SELECT/RADIO control\r\n    return super.processKeyDown(guiMgForm, guiMgCtrl, modifier, keyCode, start, end, text, isActChar, suggestedValue,  handled);\r\n  }\r\n\r\n\r\n\r\n\r\n  /// <summary>peek the value of the \"end of work\" flag.</summary>\r\n  private static peekEndOfWork(): boolean {\r\n    return EventsManager.Instance.getEndOfWork();\r\n  }\r\n\r\n  /// <summary>This method returns Main program for a ctl</summary>\r\n  /// <param name=\"contextID\">active/target context (irelevant for RC)</param>\r\n  /// <param name=\"ctlIdx\"></param>\r\n  /// <returns></returns>\r\n  private static getMainProgram(contextID: number, ctlIdx: number): Task {\r\n    return MGDataCollection.Instance.GetMainProgByCtlIdx(contextID, ctlIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the RuntimeContext of ClientManager.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private static GetRuntimeContext(contextID: string): RuntimeContextBase {\r\n    return RuntimeContextBase.Instance;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Saves the last clicked control in a respective RuntimeContextBase.\r\n  /// </summary>\r\n  /// <param name=\"guiMgControl\"></param>\r\n  /// <param name=\"ctrlName\"></param>\r\n  private static SaveLastClickedControlName(ctrlName: string): void {\r\n    RuntimeContextBase.Instance.LastClickedCtrlName = ctrlName;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Saves the last clicked information.\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"controlName\"></param>\r\n  /// <param name=\"X\"></param>\r\n  /// <param name=\"Y\"></param>\r\n  /// <param name=\"offsetX\"></param>\r\n  /// <param name=\"offsetY\"></param>\r\n  /// <param name=\"LastClickCoordinatesAreInPixels\"></param>\r\n  private static SaveLastClickInfo(controlName: string, X: number, Y: number, offsetX: number, offsetY: number, LastClickCoordinatesAreInPixels: boolean): void {\r\n    RuntimeContextBase.Instance.SaveLastClickInfo(controlName, X, Y, offsetX, offsetY, LastClickCoordinatesAreInPixels);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// Should we show logon window RTL or not.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private static IsLogonRTL(): boolean {\r\n    return ServerConfig.Instance.IsLogonRTL();\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  private static ShowSessionStatistics(): void {\r\n  }\r\n\r\n  /// <summary>\r\n  /// In RIA, enter will cause a keyboard event according to the OS.\r\n  /// This is mostly important for default button, where ENTER on any control triggers click event on the button.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private static ShouldAddEnterAsKeyEvent(): boolean {\r\n    return false;\r\n  }\r\n\r\n\r\n}\r\n"]}

package/{esm2020 → esm2022}/src/ICommandsTable.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSUNvbW1hbmRzVGFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lbmdpbmUvc3JjL0lDb21tYW5kc1RhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTdHJpbmdCdWlsZGVyIH0gZnJvbSBcIkBtYWdpYy14cGEvbXNjb3JlbGliXCI7XHJcbmltcG9ydCB7IFhtbFBhcnNlciB9IGZyb20gXCJAbWFnaWMteHBhL3V0aWxzXCI7XHJcbmltcG9ydCB7IElDbGllbnRDb21tYW5kIH0gZnJvbSBcIi4vY29tbWFuZHMvSUNsaWVudENvbW1hbmRcIjtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSUNvbW1hbmRzVGFibGUge1xyXG4gIGZpbGxEYXRhKHBhcnNlcjogWG1sUGFyc2VyKTogdm9pZDtcclxuXHJcbiAgYnVpbGRYTUwobWVzc2FnZTogU3RyaW5nQnVpbGRlcik6IHZvaWQ7XHJcblxyXG4gIEFkZChjbWQ6IElDbGllbnRDb21tYW5kKTogdm9pZDtcclxuXHJcbiAgQ2xlYXIoKTogdm9pZDtcclxufVxyXG4iXX0=

package/esm2022/src/ServerConfig.mjs

@@ -0,0 +1,122 @@
+import { NString } from '@magic-xpa/mscorelib';
+import { GuiConstants } from '@magic-xpa/gui';
+import { ConstInterface } from './ConstInterface';
+import { HttpManager } from './http/HttpManager';
+export class ServerConfig {
+    static Instance = new ServerConfig();
+    constructor() {
+    }
+    _executionProps;
+    _protocol = null;
+    _server = null;
+    _httpReq = null;
+    _appName = null;
+    _serverUrl = null;
+    Init(obj) {
+        this._executionProps = obj;
+    }
+    ShouldDisplayGenericError() {
+        return this._executionProps.DisplayGenericError;
+    }
+    setUsername(username) {
+        this._executionProps[ConstInterface.MG_TAG_USERNAME] = username;
+    }
+    setPassword(password) {
+        this._executionProps[ConstInterface.MG_TAG_PASSWORD] = password;
+    }
+    setSkipAuthenticationDialog(value) {
+        this._executionProps[ConstInterface.REQ_SKIP_AUTHENTICATION] = value.toString();
+    }
+    setGlobalParams(val) {
+        if (val !== null)
+            this._executionProps[ConstInterface.MG_TAG_GLOBALPARAMS] = val;
+        else
+            delete this._executionProps[ConstInterface.MG_TAG_GLOBALPARAMS];
+    }
+    getGlobalParams() {
+        let ret = this._executionProps[ConstInterface.MG_TAG_GLOBALPARAMS];
+        return typeof ret === "undefined" ? null : ret;
+    }
+    getProtocol() {
+        if (this._protocol === null)
+            this._protocol = this._executionProps.protocol;
+        return this._protocol;
+    }
+    getServer() {
+        if (this._server === null)
+            this._server = this._executionProps.server;
+        return this._server;
+    }
+    getHttpReq() {
+        if (this._httpReq === null) {
+            this._httpReq = this._executionProps.requester;
+            if (this._httpReq !== null) {
+                while (this._httpReq.startsWith("/"))
+                    this._httpReq = this._httpReq.substr(1);
+                while (this._httpReq.endsWith("/"))
+                    this._httpReq = this._httpReq.substr(0, this._httpReq.length - 1);
+            }
+        }
+        return this._httpReq;
+    }
+    getAppName() {
+        if (this._appName === null)
+            this._appName = this._executionProps.appname;
+        return this._appName;
+    }
+    getInternalLogLevel() {
+        return this._executionProps.InternalLogLevel;
+    }
+    setInternalLogLevel(value) {
+        this._executionProps.InternalLogLevel = value;
+    }
+    getInternalLogSync() {
+        return this._executionProps.InternalLogSync;
+    }
+    getUsername() {
+        let ret = this._executionProps[ConstInterface.MG_TAG_USERNAME];
+        return typeof ret === "undefined" ? null : ret;
+    }
+    getPassword() {
+        let ret = this._executionProps[ConstInterface.MG_TAG_PASSWORD];
+        return typeof ret === "undefined" ? null : ret;
+    }
+    getAssetsURL() {
+        let ret = this._executionProps[ConstInterface.MG_TAG_ASSETS_URL];
+        return (typeof ret === "undefined" || ret === "") ? null : ret;
+    }
+    getCtxGroup() {
+        let ret = this._executionProps[ConstInterface.CTX_GROUP];
+        return typeof ret === "undefined" ? null : ret;
+    }
+    setCtxGroup(CtxGroup) {
+        this._executionProps[ConstInterface.CTX_GROUP] = CtxGroup;
+    }
+    getSkipAuthenticationDialog() {
+        let property = this._executionProps[ConstInterface.REQ_SKIP_AUTHENTICATION];
+        return !NString.IsNullOrEmpty(property) && property === true.toString();
+    }
+    GetFirstHttpRequestTimeout() {
+        let firstHttpTimeout = this._executionProps.FirstHTTPRequestTimeout;
+        return ((firstHttpTimeout > 0) ? (firstHttpTimeout * 1000) : HttpManager.DEFAULT_OFFLINE_HTTP_COMMUNICATION_TIMEOUT);
+    }
+    GetExecutionProperty(propName) {
+        let ret = this._executionProps[propName];
+        return typeof ret === "undefined" ? null : ret;
+    }
+    getServerURL() {
+        if (this._serverUrl === null) {
+            let httpReq = ServerConfig.Instance.getHttpReq();
+            if (httpReq !== null && httpReq.toLowerCase().startsWith("http"))
+                this._serverUrl = httpReq;
+            else
+                this._serverUrl = ServerConfig.Instance.getProtocol() + "://" + ServerConfig.Instance.getServer() + "/" + ServerConfig.Instance.getHttpReq();
+        }
+        return this._serverUrl;
+    }
+    IsLogonRTL() {
+        let text = ServerConfig.Instance.GetExecutionProperty[GuiConstants.STR_LOGON_RTL];
+        return text !== null && typeof text !== "undefined" && text === "Y";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ServerConfig.js","sourceRoot":"","sources":["../../../../../projects/engine/src/ServerConfig.ts"],"names":[],"mappings":"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","sourcesContent":["import { NString } from '@magic-xpa/mscorelib';\r\nimport { GuiConstants } from '@magic-xpa/gui';\r\nimport { IServerConfig } from './util/IServerConfig';\r\nimport { ConstInterface } from './ConstInterface';\r\nimport { HttpManager } from './http/HttpManager';\r\n\r\nexport class ServerConfig {\r\n  static Instance: ServerConfig = new ServerConfig();\r\n\r\n  private constructor() {\r\n  }\r\n\r\n  private _executionProps: IServerConfig;\r\n\r\n  private _protocol: string = null;\r\n  private _server: string = null;\r\n  private _httpReq: string = null;\r\n  private _appName: string = null;\r\n  private _serverUrl: string = null;\r\n\r\n  Init(obj: IServerConfig) {\r\n    this._executionProps = obj;\r\n  }\r\n\r\n  /// <summary>\r\n  /// If a server error occurred, display a generic error message and instead of the message from the server.\r\n  /// True by default.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  ShouldDisplayGenericError(): boolean {\r\n    return this._executionProps.DisplayGenericError;\r\n  }\r\n\r\n  setUsername(username: string): void {\r\n    this._executionProps[ConstInterface.MG_TAG_USERNAME] = username;\r\n  }\r\n\r\n  setPassword(password: string): void {\r\n    this._executionProps[ConstInterface.MG_TAG_PASSWORD] = password;\r\n  }\r\n\r\n  setSkipAuthenticationDialog(value: boolean): void {\r\n    this._executionProps[ConstInterface.REQ_SKIP_AUTHENTICATION] = value.toString();\r\n  }\r\n\r\n  setGlobalParams(val: string): void {\r\n    if (val !== null)\r\n      this._executionProps[ConstInterface.MG_TAG_GLOBALPARAMS] = val;\r\n    else\r\n      delete this._executionProps[ConstInterface.MG_TAG_GLOBALPARAMS];\r\n  }\r\n\r\n  getGlobalParams(): string {\r\n    let ret = this._executionProps[ConstInterface.MG_TAG_GLOBALPARAMS];\r\n    return typeof ret === \"undefined\" ? null : ret;\r\n  }\r\n\r\n  getProtocol(): string {\r\n    if (this._protocol === null)\r\n      this._protocol = this._executionProps.protocol;\r\n\r\n    return this._protocol;\r\n  }\r\n\r\n  getServer(): string {\r\n    if (this._server === null)\r\n      this._server = this._executionProps.server;\r\n\r\n    return this._server;\r\n  }\r\n\r\n  getHttpReq(): string {\r\n    if (this._httpReq === null) {\r\n      this._httpReq = this._executionProps.requester;\r\n\r\n      // remove leading slashes\r\n      if (this._httpReq !== null) {\r\n        while (this._httpReq.startsWith(\"/\"))\r\n          this._httpReq = this._httpReq.substr(1);\r\n\r\n        while (this._httpReq.endsWith(\"/\"))\r\n          this._httpReq = this._httpReq.substr(0, this._httpReq.length - 1);\r\n      }\r\n    }\r\n\r\n    return this._httpReq;\r\n  }\r\n\r\n  getAppName(): string {\r\n    if (this._appName === null)\r\n      this._appName = this._executionProps.appname;\r\n\r\n    return this._appName;\r\n  }\r\n\r\n  getInternalLogLevel(): string {\r\n    return this._executionProps.InternalLogLevel;\r\n  }\r\n\r\n  setInternalLogLevel(value: string): void {\r\n    this._executionProps.InternalLogLevel = value;\r\n  }\r\n\r\n  getInternalLogSync(): string {\r\n    return this._executionProps.InternalLogSync;\r\n  }\r\n\r\n  getUsername(): string {\r\n    let ret = this._executionProps[ConstInterface.MG_TAG_USERNAME];\r\n    return typeof ret === \"undefined\" ? null : ret;\r\n  }\r\n\r\n  getPassword(): string {\r\n    let ret = this._executionProps[ConstInterface.MG_TAG_PASSWORD];\r\n    return typeof ret === \"undefined\" ? null : ret;\r\n  }\r\n\r\n  getAssetsURL(): string {\r\n    let ret = this._executionProps[ConstInterface.MG_TAG_ASSETS_URL];\r\n    return (typeof ret === \"undefined\" || ret === \"\") ? null : ret;\r\n  }\r\n\r\n  getCtxGroup(): string {\r\n    let ret = this._executionProps[ConstInterface.CTX_GROUP];\r\n    return typeof ret === \"undefined\" ? null : ret;\r\n  }\r\n\r\n  setCtxGroup(CtxGroup: string): void {\r\n    this._executionProps[ConstInterface.CTX_GROUP] = CtxGroup;\r\n  }\r\n\r\n  getSkipAuthenticationDialog(): boolean {\r\n    let property: string = this._executionProps[ConstInterface.REQ_SKIP_AUTHENTICATION];\r\n    return !NString.IsNullOrEmpty(property) && property === true.toString();\r\n  }\r\n\r\n  GetFirstHttpRequestTimeout(): number {\r\n    let firstHttpTimeout: number = this._executionProps.FirstHTTPRequestTimeout;\r\n    return <number>((firstHttpTimeout > 0) ? (firstHttpTimeout * 1000) : HttpManager.DEFAULT_OFFLINE_HTTP_COMMUNICATION_TIMEOUT);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// Retrieves execution property value by it's name\r\n  /// </summary>\r\n  /// <param name=\"propertyName\"></param>\r\n  /// <returns>property value as string</returns>\r\n  GetExecutionProperty(propName: string): string {\r\n    let ret = this._executionProps[propName];\r\n    return typeof ret === \"undefined\" ? null : ret;\r\n  }\r\n\r\n\r\n  /// <summary> returns the URL needed to connect to the server</summary>\r\n  /// <returns> server URL</returns>\r\n  getServerURL(): string {\r\n    if (this._serverUrl === null) {\r\n      // construct the URL string\r\n      let httpReq: string = ServerConfig.Instance.getHttpReq();\r\n\r\n      if (httpReq !== null && httpReq.toLowerCase().startsWith(\"http\"))\r\n        this._serverUrl = httpReq;\r\n      else\r\n        this._serverUrl = ServerConfig.Instance.getProtocol() + \"://\" + ServerConfig.Instance.getServer() + \"/\" + ServerConfig.Instance.getHttpReq();\r\n    }\r\n\r\n    return this._serverUrl;\r\n  }\r\n\r\n  IsLogonRTL(): boolean {\r\n    let text: string = ServerConfig.Instance.GetExecutionProperty[GuiConstants.STR_LOGON_RTL];\r\n    return text !== null && typeof text !== \"undefined\" && text === \"Y\";\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/src/bridge/IGuiEvent.mjs

@@ -1,20 +1,20 @@
-import { Modifiers } from "@magic-xpa/gui";
-export function getGuiEventObj(eventType, controlName, line, fromButton = false) {
-    return {
-        EventType: eventType,
-        TaskID: null,
-        ControlName: controlName,
-        Line: line,
-        PageSize: 0,
-        Value: null,
-        RouterPath: null,
-        RouterOutletName: null,
-        RouterParams: null,
-        modifiers: Modifiers.MODIFIER_NONE,
-        keyCode: 0,
-        externalValue: null,
-        param: null,
-        fromButton: fromButton
-    };
-}
+import { Modifiers } from "@magic-xpa/gui";
+export function getGuiEventObj(eventType, controlName, line, fromButton = false) {
+    return {
+        EventType: eventType,
+        TaskID: null,
+        ControlName: controlName,
+        Line: line,
+        PageSize: 0,
+        Value: null,
+        RouterPath: null,
+        RouterOutletName: null,
+        RouterParams: null,
+        modifiers: Modifiers.MODIFIER_NONE,
+        keyCode: 0,
+        externalValue: null,
+        param: null,
+        fromButton: fromButton
+    };
+}
 //# sourceMappingURL=data:application/json;base64,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