@magic-xpa/gui 4.1000.0-dev4100.33 → 4.1000.0-dev4100.331

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (24) hide show
  1. package/esm2020/src/Commands.mjs +3 -3
  2. package/esm2020/src/Events.mjs +3 -3
  3. package/esm2020/src/GuiEnums.mjs +3 -1
  4. package/esm2020/src/management/data/DcValues.mjs +4 -4
  5. package/esm2020/src/management/data/FieldDef.mjs +7 -7
  6. package/esm2020/src/management/data/GuiDataViewBase.mjs +1 -1
  7. package/esm2020/src/management/data/NUM_TYPE.mjs +7 -7
  8. package/esm2020/src/management/data/RecordUtils.mjs +4 -4
  9. package/esm2020/src/management/gui/DisplayConvertor.mjs +33 -10
  10. package/esm2020/src/management/gui/Helps.mjs +16 -16
  11. package/esm2020/src/management/gui/MgControlBase.mjs +13 -26
  12. package/esm2020/src/management/gui/MgFormBase.mjs +3 -2
  13. package/esm2020/src/management/gui/Property.mjs +4 -4
  14. package/esm2020/src/management/gui/ValidationDetails.mjs +10 -10
  15. package/esm2020/src/management/tasks/GuiTaskBase.mjs +16 -16
  16. package/fesm2015/magic-xpa-gui.mjs +113 -104
  17. package/fesm2015/magic-xpa-gui.mjs.map +1 -1
  18. package/fesm2020/magic-xpa-gui.mjs +112 -99
  19. package/fesm2020/magic-xpa-gui.mjs.map +1 -1
  20. package/package.json +4 -4
  21. package/src/GuiEnums.d.ts +3 -1
  22. package/src/management/data/GuiDataViewBase.d.ts +1 -0
  23. package/src/management/gui/MgControlBase.d.ts +0 -1
  24. package/magic-xpa-gui.d.ts +0 -2
package/esm2020/src/Commands.mjs CHANGED
@@ -5,8 +5,6 @@ import { CommandType } from './GuiEnums';
5
5
  import { GuiCommandQueue } from './gui/low/GuiCommandQueue';
6
6
  import { GuiCommand } from './gui/low/GuiCommand';
7
7
  export class Commands {
8
- constructor() {
9
- }
10
8
  static SetResolveCallback(resolveCallback) {
11
9
  this.resolveCallback = resolveCallback;
12
10
  }
@@ -169,6 +167,8 @@ export class Commands {
169
167
  static invoke() {
170
168
  GuiCommandQueue.getInstance().invoke();
171
169
  }
170
+ constructor() {
171
+ }
172
172
  }
173
173
  Commands.resolveCallback = null;
174
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Commands.js","sourceRoot":"","sources":["../../../../../projects/gui/src/Commands.ts"],"names":[],"mappings":"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","sourcesContent":["import {List} from '@magic-xpa/mscorelib';\r\nimport {GuiMgForm} from './gui/GuiMgForm';\r\nimport {GuiInteractive} from './gui/low/GuiInteractive';\r\nimport {GuiMgControl} from './gui/GuiMgControl';\r\nimport {CommandType} from './GuiEnums';\r\nimport {GuiCommandQueue} from './gui/low/GuiCommandQueue';\r\nimport {GuiCommand} from './gui/low/GuiCommand';\r\n\r\n\r\n/// <summary>\r\n///   Commands to the GUI thread.\r\n///   There’re two types of commands (grouped in #regions):\r\n///      1.\tCommands that are executed immediately.\r\n///      2.\tCommands that are queued (overloaded methods ‘addAsync’) and then executed,\r\n///         either synchronously (method ‘invoke’) or asynchronously (method ‘beginInvoke’).\r\n/// </summary>\r\nexport class Commands {\r\n\r\n\r\n  private static  resolveCallback = null; // callback to resolve the promise\r\n\r\n  /// <summary>\r\n  /// save the callback\r\n  /// </summary>\r\n  static SetResolveCallback(resolveCallback) {\r\n    this.resolveCallback = resolveCallback;\r\n  }\r\n\r\n  /// <summary>\r\n  /// resolve promise\r\n  /// </summary>\r\n  static ResolvePromise(result: number) {\r\n    this.resolveCallback(result);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Sync call to display message box\r\n  /// </summary>\r\n  /// <param name = \"title\"></param>\r\n  /// <param name = \"msg\"></param>\r\n  /// <param name = \"style\"></param>\r\n  /// <returns></returns>\r\n  static async messageBox(title: string, msg: string, style: number): Promise<number> {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    let returnValue: number;\r\n\r\n    await new Promise((resolve) => {\r\n      this.SetResolveCallback(resolve);\r\n      guiInteractive.messageBox(title, msg, style);\r\n     // save the resolve callback on EventsManager, so that it can be resolved on closing modal window\r\n    }).then((res: number)=>{returnValue = res;});\r\n    return returnValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set title to browser\r\n  /// </summary>\r\n  /// <param name = \"topMostForm\"></param>\r\n  /// <param name = \"title\"></param>\r\n  static setTitle(topMostForm: GuiMgForm, title: string): void {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    guiInteractive.setTitle(topMostForm, title);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Sync call. This methode is set TRUE\\FALSE that GuiUtiles\\GetValue() method will be use\r\n  ///   this falg say if to return the : (true) suggested value or (false)the real value\r\n  ///   this method is use for MG_ACT_CTRL_MODIFY\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  /// <param name = \"retSuggestedValue\"></param>\r\n  static setGetSuggestedValueOfChoiceControlOnTagData(ctrl: GuiMgControl, line: number, retSuggestedValue: boolean): void {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    guiInteractive.setGetSuggestedValueOfChoiceControlOnTagData(ctrl, line, retSuggestedValue);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to get value of the control\r\n  /// </summary>\r\n  /// <param name = \"obj\"></param>\r\n  /// <param name = \"mgValue\"></param>\r\n  /// <param name = \"line\"></param>\r\n  static getValue(obj: any, line: number): string {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.getValue(obj, line);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to get table top index\r\n  /// </summary>\r\n  /// <param name = \"tablecontrol\"></param>\r\n  /// <returns></returns>\r\n  static getTopIndex(tablecontrol: GuiMgControl): number {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.getTopIndex(tablecontrol);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to get is row editing on row index\r\n  /// </summary>\r\n  /// <param name = \"tablecontrol\"></param>\r\n  /// <returns></returns>\r\n  static getIsRowEditing(tablecontrol: any, rowIndex: number, isLineMode: boolean): boolean {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.getIsRowEditing(tablecontrol, rowIndex, isLineMode);\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to set the text to the the control\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <param name = \"line\"></param>\r\n  /// <param name = \"text\"></param>\r\n  /// <returns></returns>\r\n  static setEditText(control: GuiMgControl, line: number, text: string): boolean {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.setEditText(control, line, text);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Insert text to a text control at a given position\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <param name = \"line\"></param>\r\n  /// <param name = \"startPosition\">where to add the text</param>\r\n  /// <param name = \"textToInsert\">the text to add</param>\r\n  /// <returns></returns>\r\n  static insertEditText(control: GuiMgControl, line: number, startPosition: number, textToInsert: string): boolean {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.insertEditText(control, line, startPosition, textToInsert);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to get the position of the caret on the control\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <param name = \"line\"></param>\r\n  /// <param name = \"mgValue\"></param>\r\n  static caretPosGet(control: GuiMgControl, line: number): number {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.caretPosGet(control, line);\r\n  }\r\n\r\n  static addRefreshPage(navigateToRootRoute : boolean, initialUrl: string) {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n\r\n    guiInteractive.RefreshPage(navigateToRootRoute, initialUrl);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Sync call to get number of rows in the table\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <returns></returns>\r\n  static getRowsInPage(control: GuiMgControl): number {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    let rowsInPage = guiInteractive.getRowsInPage(control);\r\n    return (rowsInPage === 0 ? 1 : rowsInPage);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get max no of rows in paginated table\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <returns></returns>\r\n  static getMaxRowsInPaginatedTable(control: GuiMgControl): number {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    let maxRows = guiInteractive.getMaxRowsInPaginatedTable(control);\r\n    return (maxRows);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the last route\r\n  /// </summary>\r\n  static getLastRoute(): string {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.getLastRoute();\r\n  }\r\n\r\n  static addBoolWithLine(commandType: CommandType, obj: any, line: number, bool: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.Bool1 = bool;\r\n    guiCommand.line = line;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addNoParameters(commandType: CommandType, obj: any): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addWithNumber(commandType: CommandType, obj: any, num: number): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.number = num;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addValueWithLine(commandType: CommandType, obj: any, line: number, value: any): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.value = value;\r\n    guiCommand.line = line;\r\n    if (commandType === CommandType.SET_VALUE)\r\n    {\r\n      if (obj instanceof  GuiMgControl && obj.isChoiceControl())\r\n      {\r\n        if(value < 0)\r\n          guiCommand.value = '';\r\n      }\r\n    }\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n\r\n  static addOperationWithLine(commandType: CommandType, obj: any, line: number, operation: string, value: any): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.obj1 = value;\r\n    guiCommand.line = line;\r\n    guiCommand.Operation = operation;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n\r\n  static addOpensubform(commandType: CommandType, obj: Object, calledTaskTag: string, subformControlName: string, formName: string, inputControls: string, routerPath: string, routerParams: List<any>, inDefaultRouterOutlet: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.str = calledTaskTag;\r\n    guiCommand.obj1 = subformControlName;\r\n    guiCommand.userDropFormat = formName;\r\n    guiCommand.fileName = inputControls;\r\n    guiCommand.Bool1 = inDefaultRouterOutlet;\r\n    guiCommand.contextID = routerPath;\r\n    guiCommand.params = routerParams;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addClosesubform(commandType: CommandType, obj: Object, calledTaskTag: string, subformControlName: string, formName: string): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.str = calledTaskTag;\r\n    guiCommand.obj1 = subformControlName;\r\n    guiCommand.userDropFormat = formName;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addOpenForm(obj: Object, formName: string, handlerTaskTag: string, calledTaskTag: string, inputControls: string, isDialog: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, CommandType.OPEN_FORM);\r\n    guiCommand.TaskTag = handlerTaskTag;\r\n    guiCommand.str = formName;\r\n    guiCommand.stringList = new List<string>();\r\n    guiCommand.stringList.push(calledTaskTag);\r\n    guiCommand.stringList.push(inputControls);\r\n    guiCommand.Bool1 = isDialog;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addCloseForm(obj: Object, handlerTaskTag: string, calledTaskTag: string): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, CommandType.CLOSE_FORM);\r\n    guiCommand.TaskTag = handlerTaskTag;\r\n    guiCommand.str = calledTaskTag;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addCallJS(form : any, formName: string, name: string, args: Array<any>): string {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.ExecuteCallJS(form , formName,  name, args);\r\n  }\r\n\r\n  static addIsLoggedIn(setBool: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(null, CommandType.SET_IS_LOGGED_IN);\r\n    guiCommand.Bool1 = setBool;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  // adds a command to show or hide the spinner\r\n  static addShowSpinner(show: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(null, CommandType.SHOW_SPINNER);\r\n    guiCommand.Bool1 = show;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  // adds a command which is not related to a specific task\r\n  static addGlobalCommand(commandType: CommandType): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(null, commandType);\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  // adds a command to display the HTML error received from the requeser\r\n  static addShowHTMLError(commandType: CommandType, error: string): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(null, commandType);\r\n    guiCommand.str = error;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute all pending commands, asynchronously\r\n  /// </summary>\r\n  static beginInvoke(): void {\r\n    GuiCommandQueue.getInstance().beginInvoke();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute all pending commands, synchronously\r\n  /// </summary>\r\n  static invoke(): void {\r\n    GuiCommandQueue.getInstance().invoke();\r\n  }\r\n\r\n  constructor() {\r\n  }\r\n}\r\n"]}
174
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Commands.js","sourceRoot":"","sources":["../../../../../projects/gui/src/Commands.ts"],"names":[],"mappings":"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","sourcesContent":["import {List} from '@magic-xpa/mscorelib';\r\nimport {GuiMgForm} from './gui/GuiMgForm';\r\nimport {GuiInteractive} from './gui/low/GuiInteractive';\r\nimport {GuiMgControl} from './gui/GuiMgControl';\r\nimport {CommandType} from './GuiEnums';\r\nimport {GuiCommandQueue} from './gui/low/GuiCommandQueue';\r\nimport {GuiCommand} from './gui/low/GuiCommand';\r\n\r\n\r\n/// <summary>\r\n///   Commands to the GUI thread.\r\n///   There’re two types of commands (grouped in #regions):\r\n///      1.\tCommands that are executed immediately.\r\n///      2.\tCommands that are queued (overloaded methods ‘addAsync’) and then executed,\r\n///         either synchronously (method ‘invoke’) or asynchronously (method ‘beginInvoke’).\r\n/// </summary>\r\nexport class Commands {\r\n\r\n\r\n  private static  resolveCallback = null; // callback to resolve the promise\r\n\r\n  /// <summary>\r\n  /// save the callback\r\n  /// </summary>\r\n  static SetResolveCallback(resolveCallback) {\r\n    this.resolveCallback = resolveCallback;\r\n  }\r\n\r\n  /// <summary>\r\n  /// resolve promise\r\n  /// </summary>\r\n  static ResolvePromise(result: number) {\r\n    this.resolveCallback(result);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Sync call to display message box\r\n  /// </summary>\r\n  /// <param name = \"title\"></param>\r\n  /// <param name = \"msg\"></param>\r\n  /// <param name = \"style\"></param>\r\n  /// <returns></returns>\r\n  static async messageBox(title: string, msg: string, style: number): Promise<number> {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    let returnValue: number;\r\n\r\n    await new Promise((resolve) => {\r\n      this.SetResolveCallback(resolve);\r\n      guiInteractive.messageBox(title, msg, style);\r\n     // save the resolve callback on EventsManager, so that it can be resolved on closing modal window\r\n    }).then((res: number)=>{returnValue = res;});\r\n    return returnValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set title to browser\r\n  /// </summary>\r\n  /// <param name = \"topMostForm\"></param>\r\n  /// <param name = \"title\"></param>\r\n  static setTitle(topMostForm: GuiMgForm, title: string): void {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    guiInteractive.setTitle(topMostForm, title);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Sync call. This methode is set TRUE\\FALSE that GuiUtiles\\GetValue() method will be use\r\n  ///   this falg say if to return the : (true) suggested value or (false)the real value\r\n  ///   this method is use for MG_ACT_CTRL_MODIFY\r\n  /// </summary>\r\n  /// <param name = \"ctrl\"></param>\r\n  /// <param name = \"retSuggestedValue\"></param>\r\n  static setGetSuggestedValueOfChoiceControlOnTagData(ctrl: GuiMgControl, line: number, retSuggestedValue: boolean): void {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    guiInteractive.setGetSuggestedValueOfChoiceControlOnTagData(ctrl, line, retSuggestedValue);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to get value of the control\r\n  /// </summary>\r\n  /// <param name = \"obj\"></param>\r\n  /// <param name = \"mgValue\"></param>\r\n  /// <param name = \"line\"></param>\r\n  static getValue(obj: any, line: number): string {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.getValue(obj, line);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to get table top index\r\n  /// </summary>\r\n  /// <param name = \"tablecontrol\"></param>\r\n  /// <returns></returns>\r\n  static getTopIndex(tablecontrol: GuiMgControl): number {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.getTopIndex(tablecontrol);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to get is row editing on row index\r\n  /// </summary>\r\n  /// <param name = \"tablecontrol\"></param>\r\n  /// <returns></returns>\r\n  static getIsRowEditing(tablecontrol: any, rowIndex: number, isLineMode: boolean): boolean {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.getIsRowEditing(tablecontrol, rowIndex, isLineMode);\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to set the text to the the control\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <param name = \"line\"></param>\r\n  /// <param name = \"text\"></param>\r\n  /// <returns></returns>\r\n  static setEditText(control: GuiMgControl, line: number, text: string): boolean {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.setEditText(control, line, text);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Insert text to a text control at a given position\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <param name = \"line\"></param>\r\n  /// <param name = \"startPosition\">where to add the text</param>\r\n  /// <param name = \"textToInsert\">the text to add</param>\r\n  /// <returns></returns>\r\n  static insertEditText(control: GuiMgControl, line: number, startPosition: number, textToInsert: string): boolean {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.insertEditText(control, line, startPosition, textToInsert);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Sync call to get the position of the caret on the control\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <param name = \"line\"></param>\r\n  /// <param name = \"mgValue\"></param>\r\n  static caretPosGet(control: GuiMgControl, line: number): number {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.caretPosGet(control, line);\r\n  }\r\n\r\n  static addRefreshPage(navigateToRootRoute : boolean, initialUrl: string) {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n\r\n    guiInteractive.RefreshPage(navigateToRootRoute, initialUrl);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Sync call to get number of rows in the table\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <returns></returns>\r\n  static getRowsInPage(control: GuiMgControl): number {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    let rowsInPage = guiInteractive.getRowsInPage(control);\r\n    return (rowsInPage === 0 ? 1 : rowsInPage);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get max no of rows in paginated table\r\n  /// </summary>\r\n  /// <param name = \"control\"></param>\r\n  /// <returns></returns>\r\n  static getMaxRowsInPaginatedTable(control: GuiMgControl): number {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    let maxRows = guiInteractive.getMaxRowsInPaginatedTable(control);\r\n    return (maxRows);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the last route\r\n  /// </summary>\r\n  static getLastRoute(): string {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.getLastRoute();\r\n  }\r\n\r\n  static addBoolWithLine(commandType: CommandType, obj: any, line: number, bool: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.Bool1 = bool;\r\n    guiCommand.line = line;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addNoParameters(commandType: CommandType, obj: any): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addWithNumber(commandType: CommandType, obj: any, num: number): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.number = num;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addValueWithLine(commandType: CommandType, obj: any, line: number, value: any): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.value = value;\r\n    guiCommand.line = line;\r\n    if (commandType === CommandType.SET_VALUE)\r\n    {\r\n      if (obj instanceof  GuiMgControl && obj.isChoiceControl())\r\n      {\r\n        if(value < 0)\r\n          guiCommand.value = '';\r\n      }\r\n    }\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n\r\n  static addOperationWithLine(commandType: CommandType, obj: any, line: number, operation: string, value: any): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.obj1 = value;\r\n    guiCommand.line = line;\r\n    guiCommand.Operation = operation;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n\r\n  static addOpensubform(commandType: CommandType, obj: Object, calledTaskTag: string, subformControlName: string, formName: string, inputControls: string, routerPath: string, routerParams: List<any>, inDefaultRouterOutlet: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.str = calledTaskTag;\r\n    guiCommand.obj1 = subformControlName;\r\n    guiCommand.userDropFormat = formName;\r\n    guiCommand.fileName = inputControls;\r\n    guiCommand.Bool1 = inDefaultRouterOutlet;\r\n    guiCommand.contextID = routerPath;\r\n    guiCommand.params = routerParams;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addClosesubform(commandType: CommandType, obj: Object, calledTaskTag: string, subformControlName: string, formName: string): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, commandType);\r\n    guiCommand.str = calledTaskTag;\r\n    guiCommand.obj1 = subformControlName;\r\n    guiCommand.userDropFormat = formName;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addOpenForm(obj: Object, formName: string, handlerTaskTag: string, calledTaskTag: string, inputControls: string, isDialog: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, CommandType.OPEN_FORM);\r\n    guiCommand.TaskTag = handlerTaskTag;\r\n    guiCommand.str = formName;\r\n    guiCommand.stringList = new List<string>();\r\n    guiCommand.stringList.push(calledTaskTag);\r\n    guiCommand.stringList.push(inputControls);\r\n    guiCommand.Bool1 = isDialog;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addCloseForm(obj: Object, handlerTaskTag: string, calledTaskTag: string): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(obj, CommandType.CLOSE_FORM);\r\n    guiCommand.TaskTag = handlerTaskTag;\r\n    guiCommand.str = calledTaskTag;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  static addCallJS(form : any, formName: string, name: string, args: Array<any>): string {\r\n    let guiInteractive: GuiInteractive = new GuiInteractive();\r\n    return guiInteractive.ExecuteCallJS(form , formName,  name, args);\r\n  }\r\n\r\n  static addIsLoggedIn(setBool: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(null, CommandType.SET_IS_LOGGED_IN);\r\n    guiCommand.Bool1 = setBool;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  // adds a command to show or hide the spinner\r\n  static addShowSpinner(show: boolean): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(null, CommandType.SHOW_SPINNER);\r\n    guiCommand.Bool1 = show;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  // adds a command which is not related to a specific task\r\n  static addGlobalCommand(commandType: CommandType): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(null, commandType);\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  // adds a command to display the HTML error received from the requeser\r\n  static addShowHTMLError(commandType: CommandType, error: string): void {\r\n    let guiCommand: GuiCommand = new GuiCommand(null, commandType);\r\n    guiCommand.str = error;\r\n    GuiCommandQueue.getInstance().addCommand(guiCommand);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute all pending commands, asynchronously\r\n  /// </summary>\r\n  static beginInvoke(): void {\r\n    GuiCommandQueue.getInstance().beginInvoke();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute all pending commands, synchronously\r\n  /// </summary>\r\n  static invoke(): void {\r\n    GuiCommandQueue.getInstance().invoke();\r\n  }\r\n\r\n  constructor() {\r\n  }\r\n}\r\n"]}
package/esm2020/src/Events.mjs CHANGED
@@ -1,8 +1,6 @@
1
1
  import { Debug, NString, StringBuilder } from "@magic-xpa/mscorelib";
2
2
  import { OSEnvironment } from "@magic-xpa/utils";
3
3
  export class Events {
4
- constructor() {
5
- }
6
4
  static OnFocus(ctrl, line, isProduceClick, onMultiMark) {
7
5
  Debug.Assert(Events.FocusEvent !== null);
8
6
  Events.FocusEvent(ctrl, line, isProduceClick, onMultiMark);
@@ -351,6 +349,8 @@ export class Events {
351
349
  Events.CopyDataEvent(guiMgForm, copyData);
352
350
  }
353
351
  }
352
+ constructor() {
353
+ }
354
354
  }
355
355
  Events.NonParkableLastParkedCtrlEvent = null;
356
356
  Events.IsBatchRunningInMainContextEvent = null;
@@ -417,4 +417,4 @@ Events.OnIsSpecialIgnoreButtonFormatEvent = null;
417
417
  Events.GetMainProgramEvent = null;
418
418
  Events.TranslateLogicalNameEvent = null;
419
419
  Events.GetMessageStringEvent = null;
420
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Events.js","sourceRoot":"","sources":["../../../../../projects/gui/src/Events.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,EAAmB,OAAO,EAAE,aAAa,EAAC,MAAM,sBAAsB,CAAC;AAIpF,OAAO,EAAmB,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAWjE,MAAM,OAAO,MAAM;IA0kCjB;IACA,CAAC;IA/qBD,MAAM,CAAC,OAAO,CAAC,IAAkB,EAAE,IAAY,EAAE,cAAuB,EAAE,WAAoB;QAC5F,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;IAC7D,CAAC;IAID,MAAM,CAAC,wBAAwB,CAAC,IAAkB;QAChD,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,2BAA2B,KAAK,IAAI,CAAC,CAAC;QAC1D,MAAM,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAUD,MAAM,CAAC,WAAW,CAAC,SAAoB,EAAE,SAAuB,EAAE,UAAiB,EAAE,mBAA4B,EAAE,IAAY,EAAE,WAAoB,EAAE,eAAwB;QAC7K,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,IAAI,EAAE,WAAW,EAAE,eAAe,CAAC,CAAC;IACnH,CAAC;IAKD,MAAM,CAAC,2BAA2B,CAAC,IAAkB;QACnD,IAAI,MAAM,CAAC,8BAA8B,KAAK,IAAI,EAAE;YAClD,MAAM,CAAC,8BAA8B,CAAC,IAAI,CAAC,CAAC;SAC7C;IACH,CAAC;IAKD,MAAM,CAAC,cAAc,CAAC,IAAkB,EAAE,YAAgC;QACxE,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACrC,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;SAC9C;IACH,CAAC;IAKD,MAAM,CAAC,SAAS,CAAC,IAAkB,EAAE,IAAY;QAC/C,IAAI,MAAM,CAAC,YAAY,KAAK,IAAI,EAAE;YAChC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;SACjC;IACH,CAAC;IAKD,MAAM,CAAC,mBAAmB,CAAC,IAAkB,EAAE,IAAY;QACzD,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,sBAAsB,KAAK,IAAI,CAAC,CAAC;QACrD,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC5C,CAAC;IAOD,MAAM,CAAC,WAAW,CAAC,GAAW,EAAE,IAAkB,EAAE,IAAY,EAAE,YAAqB;QACrF,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IACvD,CAAC;IAKD,MAAM,CAAC,UAAU,CAAC,IAAkB,EAAE,IAAY;QAChD,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,KAAK,IAAI,CAAC,CAAC;QAC5C,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IAmBD,MAAM,CAAC,SAAS,CAAC,IAAe,EAAE,eAA6B,EAAE,QAAmB,EAAE,OAAe,EAAE,qBAA0B,EAAE,oBAAyB,EAAE,aAAkB,EAAE,SAAmB,EAAE,cAAuB,EAAE,wBAAkC,EAAE,OAAiB;QACnR,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE;YACzB,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,wBAAwB,EAAE,OAAO,CAAC,CAAC;aAEpL,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE;YAC9B,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,wBAAwB,CAAC,CAAC;;YAE9K,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,aAAa,CAAC,CAAC;IAC7H,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,IAAe,EAAE,SAAuB,EAAE,QAAmB,EAAE,OAAe,EAAE,KAAa,EAAE,GAAW,EAAE,IAAY,EAAE,SAAkB,EAAE,cAAsB,EAAE,eAAwB,EAAE,OAAgB;QACzO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;QAC3C,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACjI,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,IAAkB,EAAE,GAAW,EAAE,QAAmB;QACxE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,iBAAiB,KAAK,IAAI,CAAC,CAAC;QAChD,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IAChD,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,IAAe,EAAE,IAAkB,EAAE,QAAmB,EAAE,OAAe,EAAE,KAAa,EAAE,GAAW,EAAE,IAAY,EAAE,SAAkB,EAAE,cAAsB,EAAE,OAAgB;QAC1M,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;QAC3C,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACzH,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,IAAe,EAAE,IAAkB,EAAE,QAAmB,EAAE,OAAe,EAAE,cAAsB,EAAE,eAAwB,EAAE,OAAgB;QACtK,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;QAC3C,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACzH,CAAC;IAMD,MAAM,CAAC,WAAW,CAAC,IAAe;QAChC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAID,MAAM,CAAC,SAAS,CAAC,IAAe;QAC9B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;QAC3C,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAID,MAAM,CAAC,OAAO,CAAC,OAAgB;QAC7B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAOD,MAAM,CAAC,aAAa,CAAC,IAAkB,EAAE,aAAqB;QAC5D,IAAI,MAAM,CAAC,gBAAgB,KAAK,IAAI,EAAE;YACpC,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;SAC9C;IACH,CAAC;IAOD,MAAM,CAAC,aAAa,CAAC,IAAkB,EAAE,eAAuB,EAAE,OAAgB,EAAE,cAA8B;QAC9G,IAAI,MAAM,CAAC,gBAAgB,KAAK,IAAI,EAAE;YAClC,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC;SAC3E;IACL,CAAC;IAOD,MAAM,CAAC,aAAa,CAAC,UAAwB,EAAE,SAAiB,EAAE,YAAoB;QACpF,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,KAAK,IAAI,CAAC,CAAC;QAC/C,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;IAC/D,CAAC;IAMD,MAAM,CAAC,aAAa;QAClB,IAAI,MAAM,CAAC,kBAAkB,KAAK,IAAI,EAAE;YACtC,MAAM,CAAC,kBAAkB,EAAE,CAAC;SAC7B;IACH,CAAC;IAKD,MAAM,CAAC,WAAW,CAAC,UAAqB;QACtC,IAAI,MAAM,CAAC,cAAc,KAAK,IAAI,EAAE;YAClC,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;SACnC;IACH,CAAC;IAMD,MAAM,CAAC,2BAA2B;QAChC,IAAI,QAAQ,GAAY,KAAK,CAAC;QAC9B,IAAI,MAAM,CAAC,gCAAgC,KAAK,IAAI,EAAE;YACpD,QAAQ,GAAG,MAAM,CAAC,gCAAgC,EAAE,CAAC;SACtD;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAMD,MAAM,CAAC,SAAS,CAAC,UAAkB;QACjC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,OAAO,CAAC,UAAU,KAAK,IAAI,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;IACzG,CAAC;IAUD,MAAM,CAAC,mBAAmB,CAAC,SAAiB,EAAE,KAAa,EAAE,MAAc,EAAE,UAAmB,EAAE,IAAY;QAC5G,IAAI,MAAM,CAAC,sBAAsB,KAAK,IAAI,EAAE;YAC1C,MAAM,CAAC,sBAAsB,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;SAC3E;IACH,CAAC;IAMD,MAAM,CAAC,uBAAuB,CAAC,gBAAwB;QACrD,IAAI,MAAM,CAAC,0BAA0B,KAAK,IAAI,EAAE;YAC9C,MAAM,CAAC,0BAA0B,CAAC,gBAAgB,CAAC,CAAC;SACrD;IACH,CAAC;IAMD,MAAM,CAAC,SAAS,CAAC,SAAiB;QAChC,IAAI,GAAG,GAAW,CAAC,CAAC;QACpB,IAAI,MAAM,CAAC,cAAc,KAAK,IAAI,EAAE;YAClC,GAAG,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;SACxC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAMD,MAAM,CAAC,oBAAoB,CAAC,WAAmB;QAC7C,IAAI,MAAM,CAAC,uBAAuB,KAAK,IAAI,EAAE;YAC3C,MAAM,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;SAC7C;IACH,CAAC;IAUD,MAAM,CAAC,kBAAkB,CAAC,SAAiB,EAAE,OAAe,EAAE,MAAc,EAAE,KAAa,EAAE,SAAiB;QAC5G,IAAI,MAAM,CAAC,qBAAqB,KAAK,IAAI,EAAE;YACzC,MAAM,CAAC,qBAAqB,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;SAC5E;IACH,CAAC;IAkBD,MAAM,CAAC,iBAAiB,CAAC,OAAe,EAAE,SAAiB,EAAE,UAAkB,EAAE,KAAa,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,MAAc,EAAE,UAAkB,EAAE,KAAa,EAAE,SAAiB,EAAE,MAAc;QACvN,IAAI,QAAQ,GAAW,CAAC,CAAC;QACzB,IAAI,MAAM,CAAC,oBAAoB,KAAK,IAAI,EAAE;YACxC,QAAQ,GAAG,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;SAC1I;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAMD,MAAM,CAAC,kBAAkB,CAAC,OAAe;QACvC,IAAI,MAAM,CAAC,qBAAqB,KAAK,IAAI,EAAE;YACzC,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;SACvC;IACH,CAAC;IAMD,MAAM,CAAC,mBAAmB,CAAC,mBAA2B;QACpD,IAAI,MAAM,CAAC,sBAAsB,KAAK,IAAI,EAAE;YAC1C,MAAM,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;SACpD;IACH,CAAC;IAMD,MAAM,CAAC,iBAAiB,CAAC,GAAW;QAClC,IAAI,QAAQ,GAAW,CAAC,CAAC;QACzB,IAAI,MAAM,CAAC,oBAAoB,KAAK,IAAI,EAAE;YACxC,QAAQ,GAAG,MAAM,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;SAC7C;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAGD,MAAM,CAAC,wBAAwB;QAC7B,IAAI,MAAM,CAAC,6BAA6B,KAAK,IAAI,EAAE;YACjD,MAAM,CAAC,6BAA6B,EAAE,CAAC;SACxC;IACH,CAAC;IAOD,MAAM,CAAC,sBAAsB,CAAC,IAAkB;QAC9C,OAAO,MAAM,CAAC,2BAA2B,KAAK,IAAI,IAAI,MAAM,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;IACjG,CAAC;IAID,MAAM,CAAC,aAAa;QAClB,OAAO,MAAM,CAAC,kBAAkB,KAAK,IAAI,IAAI,MAAM,CAAC,kBAAkB,EAAE,CAAC;IAC3E,CAAC;IAID,MAAM,CAAC,YAAY;QACjB,OAAO,CAAC,MAAM,CAAC,iBAAiB,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,CAAC;IAWD,MAAM,CAAC,aAAa,CAAC,WAAgB,EAAE,IAAY,EAAE,YAAoB,EAAE,YAAqB,EAAE,aAAsB,EAAE,oBAA6B;QACrJ,IAAI,OAAO,GAAY,KAAK,CAAC;QAC7B,IAAI,MAAM,CAAC,gBAAgB,KAAK,IAAI,EAAE;YACpC,OAAO,GAAG,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,oBAAoB,CAAC,CAAC;SACvH;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAOD,MAAM,CAAC,kBAAkB;QACvB,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,uBAAuB,KAAK,IAAI,CAAC,CAAC;QACtD,OAAO,MAAM,CAAC,uBAAuB,EAAE,CAAC;IAC1C,CAAC;IAOD,MAAM,CAAC,YAAY,CAAC,SAAoB;QACtC,IAAI,SAAS,GAAW,CAAC,CAAC,CAAC;QAC3B,KAAK,CAAC,MAAM,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC;QACjC,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACrC,SAAS,GAAG,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;SACjD;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAOD,MAAM,CAAC,QAAQ,CAAC,MAAkB,EAAE,EAAW;QAC7C,IAAI,MAAM,CAAC,aAAa,KAAK,IAAI,EAAE;YACjC,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;SAClC;IACH,CAAC;IAKD,MAAM,CAAC,UAAU,CAAC,SAAoB;QACpC,IAAI,MAAM,CAAC,aAAa,KAAK,IAAI,EAAE;YACjC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;SACjC;IACH,CAAC;IAKD,MAAM,CAAC,cAAc,CAAC,SAAoB;QACxC,IAAI,MAAM,CAAC,mBAAmB,KAAK,IAAI,EAAE;YACvC,MAAM,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;SACvC;IACH,CAAC;IAKD,MAAM,CAAC,YAAY,CAAC,SAAoB;QACtC,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACrC,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;SACrC;IACH,CAAC;IASD,MAAM,CAAC,kBAAkB,CAAC,SAAoB,EAAE,OAAe;QAC7D,IAAI,MAAM,CAAC,uBAAuB,KAAK,IAAI,EAAE;YAC3C,MAAM,CAAC,uBAAuB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;SACpD;IACH,CAAC;IAMD,MAAM,CAAC,UAAU;QACf,IAAI,KAAK,GAAY,KAAK,CAAC;QAC3B,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACrC,KAAK,GAAG,MAAM,CAAC,iBAAiB,EAAE,CAAC;SACpC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,CAAC,iBAAiB;QACtB,IAAI,UAAU,GAAY,KAAK,CAAC;QAChC,IAAI,MAAM,CAAC,wBAAwB,KAAK,IAAI,EAAE;YAC5C,UAAU,GAAG,MAAM,CAAC,wBAAwB,EAAE,CAAC;SAChD;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,2BAA2B;QAChC,IAAI,oBAAoB,GAAY,KAAK,CAAC;QAC1C,IAAI,MAAM,CAAC,kCAAkC,KAAK,IAAI,EAAE;YACtD,oBAAoB,GAAG,MAAM,CAAC,kCAAkC,EAAE,CAAC;SACpE;QACD,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAMD,MAAM,CAAC,cAAc,CAAC,SAAiB,EAAE,MAAc;QACrD,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,mBAAmB,KAAK,IAAI,CAAC,CAAC;QAClD,OAAO,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACvD,CAAC;IAOD,MAAM,CAAC,oBAAoB,CAAC,UAAkB;QAC5C,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,yBAAyB,KAAK,IAAI,CAAC,CAAC;QACxD,OAAO,MAAM,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC;IAKD,MAAM,CAAC,gBAAgB,CAAC,KAAa;QACnC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,qBAAqB,KAAK,IAAI,CAAC,CAAC;QACpD,IAAI,UAAU,GAAW,MAAM,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC7D,IAAI,IAAI,GAAW,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACvC,IAAI,GAAkB,CAAC;YACvB,GAAG,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC;YAC9B,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAC7B,IAAI,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;SACvB;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAID,MAAM,CAAC,WAAW,CAAC,KAAY,EAAE,IAA+B;QAC9D,IAAI,MAAM,CAAC,cAAc,KAAK,IAAI,EAAE;YAClC,MAAM,CAAC,cAAc,CAAC,KAAK,EAAiB,IAAI,CAAC,CAAC;SACnD;IACH,CAAC;IAOD,MAAM,CAAC,iBAAiB,CAAC,SAAiB;QACxC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,sBAAsB,KAAK,IAAI,CAAC,CAAC;QACrD,OAAO,MAAM,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;IAOD,MAAM,CAAC,uBAAuB,CAAC,YAA0B,EAAE,WAAmB;QAC5E,IAAI,MAAM,CAAC,wBAAwB,KAAK,IAAI,EAAE;YAC5C,MAAM,CAAC,wBAAwB,CAAE,WAAW,CAAC,CAAC;SAC/C;IACH,CAAC;IAYD,MAAM,CAAC,iBAAiB,CAAC,SAAoB,EAAE,WAAmB,EAAE,CAAS,EAAE,CAAS,EAAE,OAAe,EAAE,OAAe,EAAE,+BAAwC;QAClK,IAAI,MAAM,CAAC,sBAAsB,KAAK,IAAI,EAAE;YAC1C,MAAM,CAAC,sBAAsB,CAAE,WAAW,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,+BAA+B,CAAC,CAAC;SACtG;IACH,CAAC;IAID,MAAM,CAAC,eAAe,CAAC,GAAW;QAChC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,oBAAoB,KAAK,IAAI,CAAC,CAAC;QACnD,MAAM,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAID,MAAM,CAAC,mBAAmB,CAAC,OAAY;QACrC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,WAAW,KAAK,MAAM,CAAC,EAAE;YAClF,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;YACtC,OAAO;SACR;QACD,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IAEO,MAAM,CAAC,qBAAqB,CAAC,GAAW;QAC9C,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,oBAAoB,KAAK,IAAI,CAAC,CAAC;QACnD,MAAM,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAEO,MAAM,CAAC,qBAAqB,CAAC,EAAa;QAChD,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE;YAC9D,EAAE,CAAC,OAAO,EAAE,EAAE,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,OAAO;SACpF,CAAC,CAAC,CAAC;IACN,CAAC;IAMD,MAAM,CAAC,iBAAiB,CAAC,OAAY;QACnC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,WAAW,KAAK,MAAM,CAAC,EAAE;YAClF,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;YACpC,OAAO;SACR;QACD,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACtC,CAAC;IAEO,MAAM,CAAC,mBAAmB,CAAC,GAAW;QAC5C,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,sBAAsB,KAAK,IAAI,CAAC,CAAC;QACrD,MAAM,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAEO,MAAM,CAAC,mBAAmB,CAAC,EAAa;QAC9C,MAAM,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,aAAa,CAAC,MAAM,GAAG,EAAE,CAAC,UAAU,GAAG,aAAa,CAAC,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC,CAAC;IAC5H,CAAC;IAOD,MAAM,CAAC,SAAS,CAAC,QAA0B;QACzC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,OAAO,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAID,MAAM,CAAC,aAAa,CAAC,GAAW;QAC9B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,KAAK,IAAI,CAAC,CAAC;QACjD,MAAM,CAAC,kBAAkB,CAAC,OAAO,GAAG,GAAG,CAAC,CAAC;IAC3C,CAAC;IAID,MAAM,CAAC,aAAa,CAAC,GAAW;QAC9B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,KAAK,IAAI,CAAC,CAAC;QACjD,MAAM,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAMD,MAAM,CAAC,OAAO,CAAC,IAAkB;QAC7B,IAAI,MAAM,CAAC,UAAU,KAAK,IAAI,EAAE;YAC5B,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SAC3B;IACL,CAAC;IAMD,MAAM,CAAC,MAAM,CAAC,IAAkB;QAC5B,IAAI,MAAM,CAAC,SAAS,KAAK,IAAI,EAAE;YAC3B,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SAC1B;IACL,CAAC;IAQD,MAAM,CAAC,kBAAkB;QACvB,OAAO,MAAM,CAAC,wBAAwB,KAAK,IAAI,IAAI,MAAM,CAAC,wBAAwB,EAAE,CAAC;IACvF,CAAC;IAID,MAAM,CAAC,yBAAyB;QAC9B,IAAI,MAAM,CAAC,0BAA0B,KAAK,IAAI,EAAE;YAC9C,MAAM,CAAC,0BAA0B,EAAE,CAAC;SACrC;IACH,CAAC;IAOD,MAAM,CAAC,UAAU,CAAC,SAAoB,EAAE,QAAgB;QACtD,IAAI,MAAM,CAAC,aAAa,KAAK,IAAI,EAAE;YACjC,MAAM,CAAC,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;SAC3C;IACH,CAAC;;AArkCM,qCAA8B,GAAiC,IAAI,CAAC;AAKpE,uCAAgC,GAAkB,IAAI,CAAC;AAKvD,qBAAc,GAAmC,IAAI,CAAC;AAUtD,6BAAsB,GAAkG,IAAI,CAAC;AAM7H,iCAA0B,GAAuC,IAAI,CAAC;AAMtE,qBAAc,GAAkC,IAAI,CAAC;AAMrD,8BAAuB,GAAkC,IAAI,CAAC;AAU9D,4BAAqB,GAAmG,IAAI,CAAC;AAkB7H,2BAAoB,GAAiN,IAAI,CAAC;AAM1O,4BAAqB,GAA8B,IAAI,CAAC;AAMxD,6BAAsB,GAA8B,IAAI,CAAC;AAMzD,2BAAoB,GAA4B,IAAI,CAAC;AAOrD,oBAAa,GAA8C,IAAI,CAAC;AAIhE,qBAAc,GAAgD,IAAI,CAAC;AAOnE,6BAAsB,GAA8C,IAAI,CAAC;AAOzE,+BAAwB,GAAmC,IAAI,CAAC;AAYhE,6BAAsB,GAAoI,IAAI,CAAC;AAI/J,2BAAoB,GAA0B,IAAI,CAAC;AAInD,+BAAwB,GAA0B,IAAI,CAAC;AAKvD,6BAAsB,GAA0B,IAAI,CAAC;AAOrD,qBAAc,GAA4C,IAAI,CAAC;AAI/D,yBAAkB,GAA0B,IAAI,CAAC;AAIjD,yBAAkB,GAA0B,IAAI,CAAC;AAQjD,iBAAU,GAAiC,IAAI,CAAC;AAMhD,gBAAS,GAAiC,IAAI,CAAC;AAQ/C,+BAAwB,GAAkB,IAAI,CAAC;AAI/C,iCAA0B,GAAe,IAAI,CAAC;AAO9C,oBAAa,GAAqD,IAAI,CAAC;AAMvE,iBAAU,GAA8F,IAAI,CAAC;AAI7G,kCAA2B,GAAiC,IAAI,CAAC;AASjE,qBAAc,GAA8K,IAAI,CAAC;AAKjM,wBAAiB,GAAmE,IAAI,CAAC;AAKzF,mBAAY,GAA+C,IAAI,CAAC;AAKhE,6BAAsB,GAA+C,IAAI,CAAC;AAO1E,qBAAc,GAAmF,IAAI,CAAC;AAKtG,oBAAa,GAA+C,IAAI,CAAC;AAejE,mBAAY,GAAkO,IAAI,CAAC;AAOnP,wBAAiB,GAAwE,IAAI,CAAC;AAM9F,qBAAc,GAAiC,IAAI,CAAC;AAIpD,mBAAY,GAA8B,IAAI,CAAC;AAI/C,iBAAU,GAA+B,IAAI,CAAC;AAM9C,uBAAgB,GAAwD,IAAI,CAAC;AAO7E,uBAAgB,GAA4G,IAAI,CAAC;AAKjI,yBAAkB,GAAkD,IAAI,CAAC;AAKzE,uBAAgB,GAAkD,IAAI,CAAC;AAMvE,uBAAgB,GAAgF,IAAI,CAAC;AAKrG,yBAAkB,GAAe,IAAI,CAAC;AAMtC,qBAAc,GAAoC,IAAI,CAAC;AAIvD,oCAA6B,GAAe,IAAI,CAAC;AAOjD,kCAA2B,GAAoC,IAAI,CAAC;AAIpE,yBAAkB,GAAkB,IAAI,CAAC;AAIzC,wBAAiB,GAAiB,IAAI,CAAC;AAWvC,uBAAgB,GAAoJ,IAAI,CAAC;AAOzK,8BAAuB,GAAiB,IAAI,CAAC;AAO7C,wBAAiB,GAAqC,IAAI,CAAC;AAK3D,oBAAa,GAAmC,IAAI,CAAC;AAKrD,0BAAmB,GAAmC,IAAI,CAAC;AAK3D,wBAAiB,GAAmC,IAAI,CAAC;AASzD,8BAAuB,GAAoD,IAAI,CAAC;AAMhF,wBAAiB,GAAkB,IAAI,CAAC;AAGxC,+BAAwB,GAAkB,IAAI,CAAC;AAG/C,yCAAkC,GAAkB,IAAI,CAAC;AAOzD,0BAAmB,GAAuD,IAAI,CAAC;AAO/E,gCAAyB,GAAmC,IAAI,CAAC;AAKjE,4BAAqB,GAA8B,IAAI,CAAC","sourcesContent":["import {GuiMgControl} from \"./gui/GuiMgControl\";\r\nimport {MgFormBase} from \"./management/gui/MgFormBase\";\r\nimport {ITask} from \"./management/tasks/ITask\";\r\nimport {MgControlBase} from \"./management/gui/MgControlBase\";\r\nimport {RuntimeContextBase} from \"./management/RuntimeContextBase\";\r\nimport {GuiMgForm} from \"./gui/GuiMgForm\";\r\nimport {GuiTaskBase} from \"./management/tasks/GuiTaskBase\";\r\nimport {Debug, Exception, List, NString, StringBuilder} from \"@magic-xpa/mscorelib\";\r\nimport {Modifiers} from \"./GuiEnums\";\r\nimport {MgTimer} from \"./management/tasks/MgTimer\";\r\nimport {LastFocusedVal} from \"./gui/LastFocusedVal\";\r\nimport {Logger_LogLevels, OSEnvironment} from \"@magic-xpa/utils\";\r\nimport { GuiControlPropertyAdapter } from \"./management/gui/GuiControlPropertyAdapter\";\r\n\r\n/// <summary>events raised by MgGui.dll and handled by MgxpaRIA.exe or MgxpaRuntime.exe.\r\n/// Important note: these events are NOT related the events handling of Magic (RC or RTE) -\r\n///   the events exposed from this class contain functionality that the current assembly (MgGui.dll)\r\n///   requires from either MgxpaRIA.exe or MgxpaRuntime.exe.\r\n/// This class contains only the definitions of all delegates and events.\r\n/// Class 'EventsProcessor' contains handlers for events that can be served locally (by MgGui.dll),\r\n///   and registered external handlers (in MgxpaRIA.exe or MgxpaRuntime.exe) for events that can't be served locally.\r\n/// </summary>\r\nexport class Events {\r\n  /// <summary> invokes the VisibilityChanged Event</summary>\r\n  /// <param name=\"ctrl\">control whose visibility is changed</param>\r\n  static NonParkableLastParkedCtrlEvent: (ctrl: GuiMgControl) => void = null;\r\n\r\n  /// <summary>\r\n  /// returns TRUE, if Batch task is running in MAIN context.\r\n  /// </summary>\r\n  static IsBatchRunningInMainContextEvent: () => boolean = null;\r\n\r\n  /// <summary>MLS translation</summary>\r\n  /// <param name=\"fromString\">source string</param>\r\n  /// <returns>translated string</returns>\r\n  static TranslateEvent: (fromString: string) => string = null;\r\n\r\n  /// <summary>\r\n  /// Creates Print Preview Form\r\n  /// </summary>\r\n  /// <param name=\"contextId\">context id</param>\r\n  /// <param name=\"ioPtr\">pointer to current IORT object</param>\r\n  /// <param name=\"copies\">number of copies</param>\r\n  /// <param name=\"enablePDlg\">indicates whether to enable Print dialog</param>\r\n  /// <param name=\"hWnd\">Handle of Print Preview Form</param>\r\n  static PrintPreviewStartEvent: (contextID: number, ioPtr: number, copies: number, enablePDlg: boolean, hWnd: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// Set cursor to Print Preview form\r\n  /// </summary>\r\n  /// <param name=\"prnPrevData\">print preview data</param>\r\n  static PrintPreviewSetCursorEvent: (printPreviewData: number) => void = null;\r\n\r\n  ///<summary>\r\n  /// Handles Invoke UDP operation from GUI thread\r\n  ///</summary>\r\n  ///<param name=\"contextId\">Context id</param>\r\n  static InvokeUDPEvent: (contextId: number) => number = null;\r\n\r\n  /// <summary>\r\n  /// Update Print Preview\r\n  /// </summary>\r\n  /// <param name=\"prnPrevData\">print preview data</param>\r\n  static PrintPreviewUpdateEvent: (prnPrevData: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// Create Rich Edit\r\n  /// </summary>\r\n  /// <param name=\"contextId\"></param>\r\n  /// <param name=\"ctrlPtr\"></param>\r\n  /// <param name=\"prmPtr\"></param>\r\n  /// <param name=\"style\"></param>\r\n  /// <param name=\"dwExStyle\"></param>\r\n  static CreateRichWindowEvent: (contextID: number, ctrlPtr: number, prmPtr: number, style: number, dwExStyle: number) => void = null;\r\n\r\n  ///<summary>\r\n  ///  Creates a window\r\n  ///</summary>\r\n  ///<param name=\"exStyle\">!!.</param>\r\n  ///<param name=\"className\">!!.</param>\r\n  ///<param name=\"windowName\">!!.</param>\r\n  ///<param name=\"style\">!!.</param>\r\n  ///<param name=\"x\">!!.</param>\r\n  ///<param name=\"y\">!!.</param>\r\n  ///<param name=\"width\">!!.</param>\r\n  ///<param name=\"height\">!!.</param>\r\n  ///<param name=\"hwndParent\">!!.</param>\r\n  ///<param name=\"hMenu\">!!.</param>\r\n  ///<param name=\"hInstance\">!!.</param>\r\n  ///<param name=\"lParam\">!!.</param>\r\n  ///<returns>handle of window</returns>\r\n  static CreateGuiWindowEvent: (exStyle: number, className: string, windowName: string, style: number, x: number, y: number, width: number, height: number, hwndParent: number, hMenu: number, hInstance: number, lParam: number) => number = null;\r\n\r\n  /// <summary>\r\n  /// Destroys a window\r\n  /// </summary>\r\n  /// <param name=\"hWndPtr\">handle of window</param>\r\n  static DestroyGuiWindowEvent: (hWndPtr: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// OnClose Print Preview\r\n  /// </summary>\r\n  /// <param name=\"hWndPtr\">print preview data</param>\r\n  static PrintPreviewCloseEvent: (hWndPtr: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// Show Print Dialog\r\n  /// </summary>\r\n  /// <param name=\"gpd\"></param>\r\n  static ShowPrintDialogEvent: (gpd: number) => number = null;\r\n\r\n  /// <summary>\r\n  /// SetModal event\r\n  /// </summary>\r\n  /// <param name=\"currForm\"></param>\r\n  /// <param name=\"on\"></param>\r\n  static SetModalEvent: (mgForm: MgFormBase, on: boolean) => void = null;\r\n\r\n  /// <summary>raises CtrlFocusEvent</summary>\r\n  /// <returns></returns>\r\n  static CtrlFocusEvent: (iTask: ITask, ctrl: MgControlBase) => void = null;\r\n\r\n  /// <summary>\r\n  /// Gets the RuntimeContextBase that belongs to the contextID\r\n  /// </summary>\r\n  /// <param name=\"contextID\"></param>\r\n  /// <returns></returns>\r\n  static GetRuntimeContextEvent: (contextID: string) => RuntimeContextBase = null;\r\n\r\n  /// <summary>\r\n  /// Saves the name of the last clicked control.\r\n  /// </summary>\r\n  /// <param name=\"guiMgControl\">guiMgControl</param>\r\n  /// <param name=\"controlName\">Name of the control</param>\r\n  static SaveLastClickedCtrlEvent: ( controlName: string) => void = null;\r\n\r\n  /// <summary>\r\n  /// Saves the last clicked information. (i.e. Co-ordinates and control name.\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\">guiMgForm</param>\r\n  /// <param name=\"controlName\">name of the control</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\">co-ordinates are in pixel or not.</param>\r\n  static SaveLastClickInfoEvent: (controlName: string, x: number, y: number, offsetX: number, offsetY: number, lastClickCoordinatesAreInPixels: boolean) => void = null;\r\n\r\n  /// <summary>write an error message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteErrorToLogEvent: (msg: string) => void = null;\r\n\r\n  /// <summary>Write an internal error to the log. Also prints stack trace along with the message</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteExceptionToLogEvent: (msg: string) => void = null;\r\n\r\n\r\n  /// <summary>write a warning message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteWarningToLogEvent: (msg: string) => void = null;\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"logLevel\"></param>\r\n  /// <returns></returns>\r\n  static ShouldLogEvent: (logLevel: Logger_LogLevels) => boolean = null;\r\n\r\n  /// <summary>write a GUI message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteGuiToLogEvent: (msg: string) => void = null;\r\n\r\n  /// <summary>write a DEV message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteDevToLogEvent: (msg: string) => void = null;\r\n\r\n\r\n\r\n  /// <summary>\r\n  /// Called when WM_CLEAR message is received\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static ClearEvent: (ctrl: GuiMgControl) => void = null;\r\n\r\n  /// <summary>\r\n  /// Called when WM_UNDO message is received\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static UndoEvent: (ctrl: GuiMgControl) => void = null;\r\n\r\n  /// <summary>\r\n  /// Should Enter be added as keyboard event ? This is important mostly in determining if a click event\r\n  /// will be raised for a default button or not.\r\n  /// Adding Enter as a keyboard event will not raise click on default button.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static ShouldAddEnterAsKeyEvent: () => boolean = null;\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  static ShowSessionStatisticsEvent: () => void = null;\r\n\r\n  /// <summary>\r\n  /// Called when WM_COPYDATA message is received\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"copyData\"></param>\r\n  static CopyDataEvent: (guiMgForm: GuiMgForm, copyData: number) => void = null;\r\n\r\n  /// <summary> invokes the focus event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"isProduceClick\"></param>\r\n  static FocusEvent: (ctrl: GuiMgControl, line: number, isProduceClick: boolean, onMultiMark: boolean) => void = null;\r\n\r\n  /// <summary> invokes the focus out event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static FocusOnNonMagicControlEvent: (ctrl: GuiMgControl) => void = null;\r\n\r\n  /// <summary> invokes the MouseDown Event</summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"guiMgCtrl\"></param>\r\n  /// <param name=\"dotNetArgs\"></param>\r\n  /// <param name=\"leftClickWasPressed\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"onMultiMark\">indicates that Multi Mark continues</param>\r\n  static MouseDownEvent: (guiMgForm: GuiMgForm, guiMgCtrl: GuiMgControl, dotNetArgs: Object[], leftClickWasPressed: boolean, line: number, onMultiMark: boolean, canProduceClick: boolean) => void = null;\r\n\r\n  /// <summary> invokes the TableReorder Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"tabOrderList\"></param>\r\n  static TableReorderEvent: (ctrl: GuiMgControl, tabOrderList: List<GuiMgControl>) => void = null;\r\n\r\n  /// <summary> invokes the MouseUp Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static MouseUpEvent: (ctrl: GuiMgControl, line: number) => void = null;\r\n\r\n  /// <summary> invokes the ComboDroppingDown Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static ComboDroppingDownEvent: (ctrl: GuiMgControl, line: number) => void = null;\r\n\r\n  /// <summary> invokes the Selection Event</summary>\r\n  /// <param name=\"val\"></param>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"produceClick\"></param>\r\n  static SelectionEvent: (val: string, ctrl: GuiMgControl, line: number, produceClick: boolean) => void = null;\r\n\r\n  /// <summary> invokes the DblClick Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static DblClickEvent: (ctrl: GuiMgControl, line: number) => void = null;\r\n\r\n  /// <summary> invokes the KeyDown Event</summary>\r\n  /// <param name=\"form\"></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=\"comboIsDropDown\"></param>\r\n  /// <param name=\"handled\">boolean variable event is handled or not. </param>\r\n  static KeyDownEvent: (form: GuiMgForm, guiMgCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, comboIsDropDown: boolean, handled: boolean) => boolean = null;\r\n\r\n  /// <summary>\r\n  /// delegate for the MultiMark hit event\r\n  /// </summary>\r\n  /// <param name=\"guiMgCtrl\"> control </param>\r\n  /// <param name=\"row\"> table row </param>\r\n  static MultimarkHitEvent: (guiMgCtrl: GuiMgControl, row: number, modifier: Modifiers) => void = null;\r\n\r\n  /// <summary> invokes the Close Event</summary>\r\n  /// <param name=\"form\"></param>\r\n  /// <returns>true if event is CLR handled(closing of the form will be the responsibility of the CLR and no commands will be put\r\n  /// in to close the form) else false.</returns>\r\n  static CloseFormEvent: (form: GuiMgForm) => boolean = null;\r\n\r\n  /// <summary> invokes the Dispose Event</summary>\r\n  /// <param name=\"form\"></param>\r\n  static DisposeEvent: (form: GuiMgForm) => void = null;\r\n\r\n  /// <summary> invokes the Timer Event</summary>\r\n  /// <param name=\"mgTimer\"></param>\r\n  static TimerEvent: (mgTimer: MgTimer) => void = null;\r\n\r\n\r\n  /// <summary> invokes the Resize Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"newRowsInPage\"></param>\r\n  static TableResizeEvent: (ctrl: GuiMgControl, newRowsInPage: number) => void = null;\r\n\r\n  /// <summary> invokes the GetRowsData Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"desiredTopIndex\"></param>\r\n  /// <param name=\"sendAll\"></param>\r\n  /// <param name=\"lastFocusedVal\"></param>\r\n  static GetRowsDataEvent: (ctrl: GuiMgControl, desiredTopIndex: number, sendAll: boolean, lastFocusedVal: LastFocusedVal) => void = null;\r\n\r\n  /// <summary> invokes the EnableCutCopy Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"enable\"></param>\r\n  static EnableCutCopyEvent: (ctrl: GuiMgControl, enable: boolean) => void = null;\r\n\r\n  /// <summary> invokes the EnablePaste Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"enable\"></param>\r\n  static EnablePasteEvent: (ctrl: GuiMgControl, enable: boolean) => void = null;\r\n\r\n  /// <summary> invokes the ColumnClick Event</summary>\r\n  /// <param name=\"columnCtrl\"></param>\r\n  /// <param name=\"direction\"></param>\r\n  /// <param name=\"columnHeader\"></param>\r\n  static ColumnClickEvent: (columnCtrl: GuiMgControl, direction: number, columnHeader: string) => void = null;\r\n\r\n\r\n\r\n  /// <summary>invokes refreshTables delegate</summary>\r\n  static RefreshTablesEvent: () => void = null;\r\n\r\n\r\n\r\n  /// <summary>OnHelpClose</summary>\r\n  /// <param name=\"activeForm\"></param>\r\n  static HelpCloseEvent: (activeForm: GuiMgForm) => void = null;\r\n\r\n\r\n  /// <summary> displaySessionStatistics </summary>\r\n  static DisplaySessionStatisticsEvent: () => void = null;\r\n\r\n  /// <summary>\r\n  /// returns true for non interactive task for all controls except a button control\r\n  /// </summary>\r\n  /// <param name=\"ctrl\">clicked control</param>\r\n  /// <returns></returns>\r\n  static ShouldBlockMouseEventsEvent: (ctrl: GuiMgControl) => boolean = null;\r\n\r\n  /// <summary>peekEndOfWork</summary>\r\n  /// <returns></returns>\r\n  static PeekEndOfWorkEvent: () => boolean = null;\r\n\r\n  /// <summary>invokes the GetEventTime delegate</summary>\r\n  /// <returns></returns>\r\n  static GetEventTimeEvent: () => number = null;\r\n\r\n  /// <summary>\r\n  /// invokes the ScrollTable Event\r\n  /// </summary>\r\n  /// <param name=\"guiMgObject\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"rowsToScroll\"></param>\r\n  /// <param name=\"isPageScroll\">next/prev page?</param>\r\n  /// <param name=\"isTableScroll\">Begin/End Table?</param>\r\n  /// <param name=\"isRaisedByMouseWheel\">indicates whether event is raised by mousewheel or not.</param>\r\n  static ScrollTableEvent: (guiMgObject: any, line: number, rowsToScroll: number, isPageScroll: boolean, isTableScroll: boolean, isRaisedByMouseWheel: boolean) => boolean = null;\r\n\r\n  /// <summary>\r\n  /// Gets the user defined Drop formats\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <returns></returns>\r\n  static GetDropUserFormatsEvent: () => string = null;\r\n\r\n  /// <summary>\r\n  /// Get the context id from GuiMgForm\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <returns></returns>\r\n  static GetContextIDEvent: (guiMgForm: GuiMgForm) => number = null;\r\n\r\n  /// <summary> </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <returns></returns>\r\n  static ShowFormEvent: (guiMgForm: GuiMgForm) => void = null;\r\n\r\n  /// <summary>\r\n  /// invokes OnFormActivateEvent\r\n  /// </summary>\r\n  static OnFormActivateEvent: (guiMgForm: GuiMgForm) => void = null;\r\n\r\n  /// <summary>\r\n  /// invokes OnNCActivate\r\n  /// </summary>\r\n  static OnNCActivateEvent: (guiMgForm: GuiMgForm) => void = null;\r\n\r\n\r\n  /// <summary>\r\n  /// Handle WM_KEYUP - (required only for ACT_NEXT_RT_WINDOW, ACT_PREV_RT_WINDOW for sorting windowlist\r\n  /// when the key associated with the action is released)\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"keyCode\">keycode of a key which is just released</param>\r\n  static HandleKeyUpMessageEvent: (guiMgForm: GuiMgForm, keyCode: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// checks whether we should show Logon window in RTOL format or not.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static OnIsLogonRTLEvent: () => boolean = null;\r\n\r\n\r\n  static OnIsSpecialEngLogonEvent: () => boolean = null;\r\n\r\n\r\n  static OnIsSpecialIgnoreButtonFormatEvent: () => boolean = null;\r\n\r\n\r\n  /// <summary> invokes the getMainProgram Event </summary>\r\n  /// <param name=\"contextID\">active/target context</param>\r\n  /// <param name=\"ctlIdx\"></param>\r\n  /// <returns></returns>\r\n  static GetMainProgramEvent: (contextID: number, ctlIdx: number) => GuiTaskBase = null;\r\n\r\n  /// <summary>\r\n  /// Logical name translation\r\n  /// </summary>\r\n  /// <param name=\"fromString\">source string</param>\r\n  /// <returns>translated string</returns>\r\n  static TranslateLogicalNameEvent: (fromString: string) => string = null;\r\n\r\n  /// <summary>invokes getMessageString Event</summary>\r\n  /// <param name=\"msgId\"></param>\r\n  /// <returns></returns>\r\n  static GetMessageStringEvent: (msgId: string) => string = null;\r\n\r\n  /// <summary> invokes the focus event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"isProduceClick\"></param>\r\n  static OnFocus(ctrl: GuiMgControl, line: number, isProduceClick: boolean, onMultiMark: boolean): void {\r\n    Debug.Assert(Events.FocusEvent !== null);\r\n    Events.FocusEvent(ctrl, line, isProduceClick, onMultiMark);\r\n  }\r\n\r\n  /// <summary> invokes the focus event</summary>\r\n  /// <param name=\"ctrl receiving lostFocus\"></param>\r\n  static OnFocusOnNonMagicControl(ctrl: GuiMgControl): void {\r\n    Debug.Assert(Events.FocusOnNonMagicControlEvent !== null);\r\n    Events.FocusOnNonMagicControlEvent(ctrl);\r\n  }\r\n\r\n\r\n  /// <summary> invokes the MouseDown Event</summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"guiMgCtrl\"></param>\r\n  /// <param name=\"dotNetArgs\"></param>\r\n  /// <param name=\"leftClickWasPressed\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"onMultiMark\">indicates that Multi Mark continues</param>\r\n  static OnMouseDown(guiMgForm: GuiMgForm, guiMgCtrl: GuiMgControl, dotNetArgs: any[], leftClickWasPressed: boolean, line: number, onMultiMark: boolean, canProduceClick: boolean): void {\r\n    Debug.Assert(Events.MouseDownEvent !== null);\r\n    Events.MouseDownEvent(guiMgForm, guiMgCtrl, dotNetArgs, leftClickWasPressed, line, onMultiMark, canProduceClick);\r\n  }\r\n\r\n\r\n  /// <summary> invokes the VisibilityChanged Event</summary>\r\n  /// <param name=\"ctrl\">control whose visibility is changed</param>\r\n  static OnNonParkableLastParkedCtrl(ctrl: GuiMgControl): void {\r\n    if (Events.NonParkableLastParkedCtrlEvent !== null) {\r\n      Events.NonParkableLastParkedCtrlEvent(ctrl);\r\n    }\r\n  }\r\n\r\n  /// <summary> invokes the TableReorder Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"tabOrderList\"></param>\r\n  static OnTableReorder(ctrl: GuiMgControl, tabOrderList: List<GuiMgControl>): void {\r\n    if (Events.TableReorderEvent !== null) {\r\n      Events.TableReorderEvent(ctrl, tabOrderList);\r\n    }\r\n  }\r\n\r\n  /// <summary> invokes the MouseUp Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static OnMouseUp(ctrl: GuiMgControl, line: number): void {\r\n    if (Events.MouseUpEvent !== null) {\r\n      Events.MouseUpEvent(ctrl, line);\r\n    }\r\n  }\r\n\r\n  /// <summary> invokes the ComboDroppingDown Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static OnComboDroppingDown(ctrl: GuiMgControl, line: number): void {\r\n    Debug.Assert(Events.ComboDroppingDownEvent !== null);\r\n    Events.ComboDroppingDownEvent(ctrl, line);\r\n  }\r\n\r\n  /// <summary> invokes the Selection Event</summary>\r\n  /// <param name=\"val\"></param>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"produceClick\"></param>\r\n  static OnSelection(val: string, ctrl: GuiMgControl, line: number, produceClick: boolean): void {\r\n    Debug.Assert(Events.SelectionEvent !== null);\r\n    Events.SelectionEvent(val, ctrl, line, produceClick);\r\n  }\r\n\r\n  /// <summary> invokes the DblClick Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static OnDblClick(ctrl: GuiMgControl, line: number): void {\r\n    Debug.Assert(Events.DblClickEvent !== null);\r\n    Events.DblClickEvent(ctrl, line);\r\n  }\r\n\r\n\r\n  /// <summary> invokes the KeyDown Event</summary>\r\n  /// <param name=\"form\"></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=\"comboIsDropDown\"></param>\r\n  /// <param name=\"handled\">boolean variable event is handled or not. </param>\r\n  static OnKeyDown(form: GuiMgForm, guiMgCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, comboIsDropDown: boolean, handled: boolean): void;\r\n  static OnKeyDown(form: GuiMgForm, ctrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, handled: boolean): void;\r\n  static OnKeyDown(form: GuiMgForm, ctrl: GuiMgControl, modifier: Modifiers, keyCode: number, suggestedValue: string, comboIsDropDown: boolean, handled: boolean): void;\r\n  static OnKeyDown(form: GuiMgForm, guiMgCtrlOrCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, startOrSuggestedValue: any, endOrComboIsDropDown: any, textOrHandled: any, isActChar?: boolean, suggestedValue?: string, comboIsDropDownOrHandled?: boolean, handled?: boolean): void {\r\n    if (arguments.length === 11)\r\n      Events.OnKeyDown_0(form, guiMgCtrlOrCtrl, modifier, keyCode, startOrSuggestedValue, endOrComboIsDropDown, textOrHandled, isActChar, suggestedValue, comboIsDropDownOrHandled, handled);\r\n\r\n    else if (arguments.length === 10)\r\n      Events.OnKeyDown_1(form, guiMgCtrlOrCtrl, modifier, keyCode, startOrSuggestedValue, endOrComboIsDropDown, textOrHandled, isActChar, suggestedValue, comboIsDropDownOrHandled);\r\n    else\r\n      Events.OnKeyDown_2(form, guiMgCtrlOrCtrl, modifier, keyCode, startOrSuggestedValue, endOrComboIsDropDown, textOrHandled);\r\n  }\r\n\r\n  private static OnKeyDown_0(form: GuiMgForm, guiMgCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, comboIsDropDown: boolean, handled: boolean): void {\r\n    Debug.Assert(Events.KeyDownEvent !== null);\r\n    Events.KeyDownEvent(form, guiMgCtrl, modifier, keyCode, start, end, text, isActChar, suggestedValue, comboIsDropDown, handled);\r\n  }\r\n\r\n  static OnMultiMarkHit(ctrl: GuiMgControl, row: number, modifier: Modifiers): void {\r\n    Debug.Assert(Events.MultimarkHitEvent !== null);\r\n    Events.MultimarkHitEvent(ctrl, row, modifier);\r\n  }\r\n\r\n  private static OnKeyDown_1(form: GuiMgForm, ctrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, handled: boolean): boolean {\r\n    Debug.Assert(Events.KeyDownEvent !== null);\r\n    return Events.KeyDownEvent(form, ctrl, modifier, keyCode, start, end, text, isActChar, suggestedValue, false, handled);\r\n  }\r\n\r\n  private static OnKeyDown_2(form: GuiMgForm, ctrl: GuiMgControl, modifier: Modifiers, keyCode: number, suggestedValue: string, comboIsDropDown: boolean, handled: boolean): boolean {\r\n    Debug.Assert(Events.KeyDownEvent !== null);\r\n    return Events.KeyDownEvent(form, ctrl, modifier, keyCode, 0, 0, null, false, suggestedValue, comboIsDropDown, handled);\r\n  }\r\n\r\n  /// <summary> invokes the Close Event</summary>\r\n  /// <param name=\"form\"></param>\r\n  /// <returns>true if event is CLR handled(closing of the form will be the responsibility of the CLR and no commands will be put\r\n  /// in to close the form) else false.</returns>\r\n  static OnFormClose(form: GuiMgForm): boolean {\r\n    Debug.Assert(Events.CloseFormEvent !== null);\r\n    return Events.CloseFormEvent(form);\r\n  }\r\n\r\n  /// <summary> invokes the Dispose Event</summary>\r\n  /// <param name=\"form\"></param>\r\n  static OnDispose(form: GuiMgForm): void {\r\n    Debug.Assert(Events.DisposeEvent !== null);\r\n    Events.DisposeEvent(form);\r\n  }\r\n\r\n  /// <summary> invokes the Timer Event</summary>\r\n  /// <param name=\"mgTimer\"></param>\r\n  static OnTimer(mgTimer: MgTimer): void {\r\n    Debug.Assert(Events.TimerEvent !== null);\r\n    Events.TimerEvent(mgTimer);\r\n  }\r\n\r\n\r\n\r\n  /// <summary> invokes the Resize Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"newRowsInPage\"></param>\r\n  static OnTableResize(ctrl: GuiMgControl, newRowsInPage: number): void {\r\n    if (Events.TableResizeEvent !== null) {\r\n      Events.TableResizeEvent(ctrl, newRowsInPage);\r\n    }\r\n  }\r\n\r\n  /// <summary> invokes the GetRowsData Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"desiredTopIndex\"></param>\r\n  /// <param name=\"sendAll\"></param>\r\n  /// <param name=\"lastFocusedVal\"></param>\r\n  static OnGetRowsData(ctrl: GuiMgControl, desiredTopIndex: number, sendAll: boolean, lastFocusedVal: LastFocusedVal): void {\r\n      if (Events.GetRowsDataEvent !== null) {\r\n          Events.GetRowsDataEvent(ctrl, desiredTopIndex, sendAll, lastFocusedVal);\r\n      }\r\n  }\r\n\r\n\r\n  /// <summary> invokes the ColumnClick Event</summary>\r\n  /// <param name=\"columnCtrl\"></param>\r\n  /// <param name=\"direction\"></param>\r\n  /// <param name=\"columnHeader\"></param>\r\n  static OnColumnClick(columnCtrl: GuiMgControl, direction: number, columnHeader: string): void {\r\n    Debug.Assert(Events.ColumnClickEvent !== null);\r\n    Events.ColumnClickEvent(columnCtrl, direction, columnHeader);\r\n  }\r\n\r\n\r\n\r\n\r\n  /// <summary>invokes refreshTables delegate</summary>\r\n  static RefreshTables(): void {\r\n    if (Events.RefreshTablesEvent !== null) {\r\n      Events.RefreshTablesEvent();\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>OnHelpClose</summary>\r\n  /// <param name=\"activeForm\"></param>\r\n  static OnCloseHelp(activeForm: GuiMgForm): void {\r\n    if (Events.HelpCloseEvent !== null) {\r\n      Events.HelpCloseEvent(activeForm);\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// returns TRUE, if Batch task is running in MAIN context.\r\n  /// </summary>\r\n  static IsBatchRunningInMainContext(): boolean {\r\n    let retValue: boolean = false;\r\n    if (Events.IsBatchRunningInMainContextEvent !== null) {\r\n      retValue = Events.IsBatchRunningInMainContextEvent();\r\n    }\r\n    return retValue;\r\n  }\r\n\r\n\r\n  /// <summary>MLS translation</summary>\r\n  /// <param name=\"fromString\">source string</param>\r\n  /// <returns>translated string</returns>\r\n  static Translate(fromString: string): string {\r\n    Debug.Assert(Events.TranslateEvent !== null);\r\n    return (fromString !== null && fromString.length > 0) ? Events.TranslateEvent(fromString) : fromString;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Creates Print Preview Form\r\n  /// </summary>\r\n  /// <param name=\"contextId\">context id</param>\r\n  /// <param name=\"ioPtr\">pointer to current IORT object</param>\r\n  /// <param name=\"copies\">number of copies</param>\r\n  /// <param name=\"enablePDlg\">indicates whether to enable Print dialog</param>\r\n  /// <param name=\"hWnd\">Handle of Print Preview Form</param>\r\n  static OnPrintPreviewStart(contextID: number, ioPtr: number, copies: number, enablePDlg: boolean, hWnd: number): void {\r\n    if (Events.PrintPreviewStartEvent !== null) {\r\n      Events.PrintPreviewStartEvent(contextID, ioPtr, copies, enablePDlg, hWnd);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Set cursor to Print Preview form\r\n  /// </summary>\r\n  /// <param name=\"prnPrevData\">print preview data</param>\r\n  static OnPrintPreviewSetCursor(printPreviewData: number): void {\r\n    if (Events.PrintPreviewSetCursorEvent !== null) {\r\n      Events.PrintPreviewSetCursorEvent(printPreviewData);\r\n    }\r\n  }\r\n\r\n  ///<summary>\r\n  /// Handles Invoke UDP operation from GUI thread\r\n  ///</summary>\r\n  ///<param name=\"contextId\">Context id</param>\r\n  static InvokeUDP(contextId: number): number {\r\n    let ret: number = 0;\r\n    if (Events.InvokeUDPEvent !== null) {\r\n      ret = Events.InvokeUDPEvent(contextId);\r\n    }\r\n    return ret;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Update Print Preview\r\n  /// </summary>\r\n  /// <param name=\"prnPrevData\">print preview data</param>\r\n  static OnPrintPreviewUpdate(prnPrevData: number): void {\r\n    if (Events.PrintPreviewUpdateEvent !== null) {\r\n      Events.PrintPreviewUpdateEvent(prnPrevData);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Create Rich Edit\r\n  /// </summary>\r\n  /// <param name=\"contextId\"></param>\r\n  /// <param name=\"ctrlPtr\"></param>\r\n  /// <param name=\"prmPtr\"></param>\r\n  /// <param name=\"style\"></param>\r\n  /// <param name=\"dwExStyle\"></param>\r\n  static OnCreateRichWindow(contextID: number, ctrlPtr: number, prmPtr: number, style: number, dwExStyle: number): void {\r\n    if (Events.CreateRichWindowEvent !== null) {\r\n      Events.CreateRichWindowEvent(contextID, ctrlPtr, prmPtr, style, dwExStyle);\r\n    }\r\n  }\r\n\r\n  ///<summary>\r\n  ///  Creates a window\r\n  ///</summary>\r\n  ///<param name=\"exStyle\">!!.</param>\r\n  ///<param name=\"className\">!!.</param>\r\n  ///<param name=\"windowName\">!!.</param>\r\n  ///<param name=\"style\">!!.</param>\r\n  ///<param name=\"x\">!!.</param>\r\n  ///<param name=\"y\">!!.</param>\r\n  ///<param name=\"width\">!!.</param>\r\n  ///<param name=\"height\">!!.</param>\r\n  ///<param name=\"hwndParent\">!!.</param>\r\n  ///<param name=\"hMenu\">!!.</param>\r\n  ///<param name=\"hInstance\">!!.</param>\r\n  ///<param name=\"lParam\">!!.</param>\r\n  ///<returns>handle of window</returns>\r\n  static OnCreateGuiWindow(exStyle: number, className: string, windowName: string, style: number, x: number, y: number, width: number, height: number, hwndParent: number, hMenu: number, hInstance: number, lParam: number): number {\r\n    let retValue: number = 0;\r\n    if (Events.CreateGuiWindowEvent !== null) {\r\n      retValue = Events.CreateGuiWindowEvent(exStyle, className, windowName, style, x, y, width, height, hwndParent, hMenu, hInstance, lParam);\r\n    }\r\n    return retValue;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Destroys a window\r\n  /// </summary>\r\n  /// <param name=\"hWndPtr\">handle of window</param>\r\n  static OnDestroyGuiWindow(hWndPtr: number): void {\r\n    if (Events.DestroyGuiWindowEvent !== null) {\r\n      Events.DestroyGuiWindowEvent(hWndPtr);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// OnClose Print Preview\r\n  /// </summary>\r\n  /// <param name=\"hWndPtr\">print preview data</param>\r\n  static OnPrintPreviewClose(printPreviewDataPtr: number): void {\r\n    if (Events.PrintPreviewCloseEvent !== null) {\r\n      Events.PrintPreviewCloseEvent(printPreviewDataPtr);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Show Print Dialog\r\n  /// </summary>\r\n  /// <param name=\"gpd\"></param>\r\n  static OnShowPrintDialog(gpd: number): number {\r\n    let retValue: number = 0;\r\n    if (Events.ShowPrintDialogEvent !== null) {\r\n      retValue = Events.ShowPrintDialogEvent(gpd);\r\n    }\r\n    return retValue;\r\n  }\r\n\r\n  /// <summary> displaySessionStatistics </summary>\r\n  static DisplaySessionStatistics(): void {\r\n    if (Events.DisplaySessionStatisticsEvent !== null) {\r\n      Events.DisplaySessionStatisticsEvent();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns true for non interactive task for all controls except a button control\r\n  /// </summary>\r\n  /// <param name=\"ctrl\">clicked control</param>\r\n  /// <returns></returns>\r\n  static ShouldBlockMouseEvents(ctrl: GuiMgControl): boolean {\r\n    return Events.ShouldBlockMouseEventsEvent !== null && Events.ShouldBlockMouseEventsEvent(ctrl);\r\n  }\r\n\r\n  /// <summary>peekEndOfWork</summary>\r\n  /// <returns></returns>\r\n  static PeekEndOfWork(): boolean {\r\n    return Events.PeekEndOfWorkEvent !== null && Events.PeekEndOfWorkEvent();\r\n  }\r\n\r\n  /// <summary>invokes the GetEventTime delegate</summary>\r\n  /// <returns></returns>\r\n  static GetEventTime(): number {\r\n    return (Events.GetEventTimeEvent !== null) ? Events.GetEventTimeEvent() : 0;\r\n  }\r\n\r\n  /// <summary>\r\n  /// invokes the ScrollTable Event\r\n  /// </summary>\r\n  /// <param name=\"guiMgObject\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"rowsToScroll\"></param>\r\n  /// <param name=\"isPageScroll\">next/prev page?</param>\r\n  /// <param name=\"isTableScroll\">Begin/End Table?</param>\r\n  /// <param name=\"isRaisedByMouseWheel\">indicates whether event is raised by mousewheel or not.</param>\r\n  static OnScrollTable(guiMgObject: any, line: number, rowsToScroll: number, isPageScroll: boolean, isTableScroll: boolean, isRaisedByMouseWheel: boolean): boolean {\r\n    let handled: boolean = false;\r\n    if (Events.ScrollTableEvent !== null) {\r\n      handled = Events.ScrollTableEvent(guiMgObject, line, rowsToScroll, isPageScroll, isTableScroll, isRaisedByMouseWheel);\r\n    }\r\n    return handled;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets the user defined Drop formats\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <returns></returns>\r\n  static GetDropUserFormats(): string {\r\n    Debug.Assert(Events.GetDropUserFormatsEvent !== null);\r\n    return Events.GetDropUserFormatsEvent();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the context id from GuiMgForm\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <returns></returns>\r\n  static GetContextID(guiMgForm: GuiMgForm): number {\r\n    let contextID: number = -1;\r\n    Debug.Assert(guiMgForm !== null);\r\n    if (Events.GetContextIDEvent !== null) {\r\n      contextID = Events.GetContextIDEvent(guiMgForm);\r\n    }\r\n    return contextID;\r\n  }\r\n\r\n  /// <summary>\r\n  /// SetModal event\r\n  /// </summary>\r\n  /// <param name=\"currForm\"></param>\r\n  /// <param name=\"on\"></param>\r\n  static SetModal(mgForm: MgFormBase, on: boolean): void {\r\n    if (Events.SetModalEvent !== null) {\r\n      Events.SetModalEvent(mgForm, on);\r\n    }\r\n  }\r\n\r\n  /// <summary> </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <returns></returns>\r\n  static OnShowForm(guiMgForm: GuiMgForm): void {\r\n    if (Events.ShowFormEvent !== null) {\r\n      Events.ShowFormEvent(guiMgForm);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// invokes OnFormActivateEvent\r\n  /// </summary>\r\n  static OnFormActivate(guiMgForm: GuiMgForm): void {\r\n    if (Events.OnFormActivateEvent !== null) {\r\n      Events.OnFormActivateEvent(guiMgForm);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// invokes OnNCActivate\r\n  /// </summary>\r\n  static OnNCActivate(guiMgForm: GuiMgForm): void {\r\n    if (Events.OnNCActivateEvent !== null) {\r\n      Events.OnNCActivateEvent(guiMgForm);\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// Handle WM_KEYUP - (required only for ACT_NEXT_RT_WINDOW, ACT_PREV_RT_WINDOW for sorting windowlist\r\n  /// when the key associated with the action is released)\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"keyCode\">keycode of a key which is just released</param>\r\n  static HandleKeyUpMessage(guiMgForm: GuiMgForm, keyCode: number): void {\r\n    if (Events.HandleKeyUpMessageEvent !== null) {\r\n      Events.HandleKeyUpMessageEvent(guiMgForm, keyCode);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// checks whether we should show Logon window in RTOL format or not.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static IsLogonRTL(): boolean {\r\n    let isRTL: boolean = false;\r\n    if (Events.OnIsLogonRTLEvent !== null) {\r\n      isRTL = Events.OnIsLogonRTLEvent();\r\n    }\r\n    return isRTL;\r\n  }\r\n\r\n  static IsSpecialEngLogon(): boolean {\r\n    let isEngLogon: boolean = false;\r\n    if (Events.OnIsSpecialEngLogonEvent !== null) {\r\n      isEngLogon = Events.OnIsSpecialEngLogonEvent();\r\n    }\r\n    return isEngLogon;\r\n  }\r\n\r\n  static IsSpecialIgnoreButtonFormat(): boolean {\r\n    let isIgnoreButtonFormat: boolean = false;\r\n    if (Events.OnIsSpecialIgnoreButtonFormatEvent !== null) {\r\n      isIgnoreButtonFormat = Events.OnIsSpecialIgnoreButtonFormatEvent();\r\n    }\r\n    return isIgnoreButtonFormat;\r\n  }\r\n\r\n  /// <summary> invokes the getMainProgram Event </summary>\r\n  /// <param name=\"contextID\">active/target context</param>\r\n  /// <param name=\"ctlIdx\"></param>\r\n  /// <returns></returns>\r\n  static GetMainProgram(contextID: number, ctlIdx: number): GuiTaskBase {\r\n    Debug.Assert(Events.GetMainProgramEvent !== null);\r\n    return Events.GetMainProgramEvent(contextID, ctlIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Logical name translation\r\n  /// </summary>\r\n  /// <param name=\"fromString\">source string</param>\r\n  /// <returns>translated string</returns>\r\n  static TranslateLogicalName(fromString: string): string {\r\n    Debug.Assert(Events.TranslateLogicalNameEvent !== null);\r\n    return Events.TranslateLogicalNameEvent(fromString);\r\n  }\r\n\r\n  /// <summary>invokes getMessageString Event</summary>\r\n  /// <param name=\"msgId\"></param>\r\n  /// <returns></returns>\r\n  static GetMessageString(msgId: string): string {\r\n    Debug.Assert(Events.GetMessageStringEvent !== null);\r\n    let fromString: string = Events.GetMessageStringEvent(msgId);\r\n    let text: string = Events.Translate(fromString);\r\n    if (text !== null && text.endsWith(\":\")) {\r\n      let str: StringBuilder;\r\n      str = new StringBuilder(text);\r\n      str.Insert(text.length, \" \");\r\n      text = str.ToString();\r\n    }\r\n    return text;\r\n  }\r\n\r\n  /// <summary>raises CtrlFocusEvent</summary>\r\n  /// <returns></returns>\r\n  static OnCtrlFocus(iTask: ITask, ctrl: GuiControlPropertyAdapter): void {\r\n    if (Events.CtrlFocusEvent !== null) {\r\n      Events.CtrlFocusEvent(iTask, <MgControlBase>ctrl);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets the RuntimeContextBase that belongs to the contextID\r\n  /// </summary>\r\n  /// <param name=\"contextID\"></param>\r\n  /// <returns></returns>\r\n  static GetRuntimeContext(contextID: string): RuntimeContextBase {\r\n    Debug.Assert(Events.GetRuntimeContextEvent !== null);\r\n    return Events.GetRuntimeContextEvent(contextID);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Saves the name of the last clicked control.\r\n  /// </summary>\r\n  /// <param name=\"guiMgControl\">guiMgControl</param>\r\n  /// <param name=\"controlName\">Name of the control</param>\r\n  static SaveLastClickedCtrlName(guiMgControl: GuiMgControl, controlName: string): void {\r\n    if (Events.SaveLastClickedCtrlEvent !== null) {\r\n      Events.SaveLastClickedCtrlEvent( controlName);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Saves the last clicked information. (i.e. Co-ordinates and control name.\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\">guiMgForm</param>\r\n  /// <param name=\"controlName\">name of the control</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\">co-ordinates are in pixel or not.</param>\r\n  static SaveLastClickInfo(guiMgForm: GuiMgForm, controlName: string, x: number, y: number, offsetX: number, offsetY: number, lastClickCoordinatesAreInPixels: boolean): void {\r\n    if (Events.SaveLastClickInfoEvent !== null) {\r\n      Events.SaveLastClickInfoEvent( controlName, x, y, offsetX, offsetY, lastClickCoordinatesAreInPixels);\r\n    }\r\n  }\r\n\r\n  /// <summary>write an error message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteErrorToLog(msg: string): void {\r\n    Debug.Assert(Events.WriteErrorToLogEvent !== null);\r\n    Events.WriteErrorToLogEvent(msg);\r\n  }\r\n\r\n  static WriteExceptionToLog(msg: string): void;\r\n  static WriteExceptionToLog(ex: Exception): void;\r\n  static WriteExceptionToLog(msgOrEx: any): void {\r\n    if (arguments.length === 1 && (msgOrEx === null || msgOrEx.constructor === String)) {\r\n      Events.WriteExceptionToLog_0(msgOrEx);\r\n      return;\r\n    }\r\n    Events.WriteExceptionToLog_1(msgOrEx);\r\n  }\r\n\r\n  private static WriteExceptionToLog_0(msg: string): void {\r\n    Debug.Assert(Events.WriteErrorToLogEvent !== null);\r\n    Events.WriteErrorToLogEvent(msg);\r\n  }\r\n\r\n  private static WriteExceptionToLog_1(ex: Exception): void {\r\n    Events.WriteExceptionToLog(NString.Format(\"{0} : {1}{2}{3}{4}\", [\r\n      ex.GetType(), OSEnvironment.EolSeq, ex.StackTrace, OSEnvironment.EolSeq, ex.Message\r\n    ]));\r\n  }\r\n\r\n  /// <summary>write a warning message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteWarningToLog(msg: string): void;\r\n  static WriteWarningToLog(ex: Exception): void;\r\n  static WriteWarningToLog(msgOrEx: any): void {\r\n    if (arguments.length === 1 && (msgOrEx === null || msgOrEx.constructor === String)) {\r\n      Events.WriteWarningToLog_0(msgOrEx);\r\n      return;\r\n    }\r\n    Events.WriteWarningToLog_1(msgOrEx);\r\n  }\r\n\r\n  private static WriteWarningToLog_0(msg: string): void {\r\n    Debug.Assert(Events.WriteWarningToLogEvent !== null);\r\n    Events.WriteWarningToLogEvent(msg);\r\n  }\r\n\r\n  private static WriteWarningToLog_1(ex: Exception): void {\r\n    Events.WriteWarningToLog(ex.GetType() + \" : \" + OSEnvironment.EolSeq + ex.StackTrace + OSEnvironment.EolSeq + ex.Message);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"logLevel\"></param>\r\n  /// <returns></returns>\r\n  static ShouldLog(logLevel: Logger_LogLevels): boolean {\r\n    Debug.Assert(Events.ShouldLogEvent !== null);\r\n    return Events.ShouldLogEvent(logLevel);\r\n  }\r\n\r\n  /// <summary>write a GUI message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteGuiToLog(msg: string): void {\r\n    Debug.Assert(Events.WriteGuiToLogEvent !== null);\r\n    Events.WriteGuiToLogEvent(\"GUI: \" + msg);\r\n  }\r\n\r\n  /// <summary>write a DEV message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteDevToLog(msg: string): void {\r\n    Debug.Assert(Events.WriteDevToLogEvent !== null);\r\n    Events.WriteDevToLogEvent(msg);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Called when WM_CLEAR message is received\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static OnClear(ctrl: GuiMgControl): void {\r\n      if (Events.ClearEvent !== null) {\r\n          Events.ClearEvent(ctrl);\r\n      }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Called when WM_UNDO message is received\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static OnUndo(ctrl: GuiMgControl): void {\r\n      if (Events.UndoEvent !== null) {\r\n          Events.UndoEvent(ctrl);\r\n      }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Should Enter be added as keyboard event ? This is important mostly in determining if a click event\r\n  /// will be raised for a default button or not.\r\n  /// Adding Enter as a keyboard event will not raise click on default button.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static AddEnterAsKeyEvent(): boolean {\r\n    return Events.ShouldAddEnterAsKeyEvent !== null && Events.ShouldAddEnterAsKeyEvent();\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  static ShowSessionStatisticsForm(): void {\r\n    if (Events.ShowSessionStatisticsEvent !== null) {\r\n      Events.ShowSessionStatisticsEvent();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Called when WM_COPYDATA message is received\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"copyData\"></param>\r\n  static OnCopyData(guiMgForm: GuiMgForm, copyData: number): void {\r\n    if (Events.CopyDataEvent !== null) {\r\n      Events.CopyDataEvent(guiMgForm, copyData);\r\n    }\r\n  }\r\n\r\n  constructor() {\r\n  }\r\n}\r\n"]}
420
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Events.js","sourceRoot":"","sources":["../../../../../projects/gui/src/Events.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,EAAmB,OAAO,EAAE,aAAa,EAAC,MAAM,sBAAsB,CAAC;AAIpF,OAAO,EAAmB,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAWjE,MAAM,OAAO,MAAM;IA4ZjB,MAAM,CAAC,OAAO,CAAC,IAAkB,EAAE,IAAY,EAAE,cAAuB,EAAE,WAAoB;QAC5F,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;IAC7D,CAAC;IAID,MAAM,CAAC,wBAAwB,CAAC,IAAkB;QAChD,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,2BAA2B,KAAK,IAAI,CAAC,CAAC;QAC1D,MAAM,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAUD,MAAM,CAAC,WAAW,CAAC,SAAoB,EAAE,SAAuB,EAAE,UAAiB,EAAE,mBAA4B,EAAE,IAAY,EAAE,WAAoB,EAAE,eAAwB;QAC7K,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,IAAI,EAAE,WAAW,EAAE,eAAe,CAAC,CAAC;IACnH,CAAC;IAKD,MAAM,CAAC,2BAA2B,CAAC,IAAkB;QACnD,IAAI,MAAM,CAAC,8BAA8B,KAAK,IAAI,EAAE;YAClD,MAAM,CAAC,8BAA8B,CAAC,IAAI,CAAC,CAAC;SAC7C;IACH,CAAC;IAKD,MAAM,CAAC,cAAc,CAAC,IAAkB,EAAE,YAAgC;QACxE,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACrC,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;SAC9C;IACH,CAAC;IAKD,MAAM,CAAC,SAAS,CAAC,IAAkB,EAAE,IAAY;QAC/C,IAAI,MAAM,CAAC,YAAY,KAAK,IAAI,EAAE;YAChC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;SACjC;IACH,CAAC;IAKD,MAAM,CAAC,mBAAmB,CAAC,IAAkB,EAAE,IAAY;QACzD,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,sBAAsB,KAAK,IAAI,CAAC,CAAC;QACrD,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC5C,CAAC;IAOD,MAAM,CAAC,WAAW,CAAC,GAAW,EAAE,IAAkB,EAAE,IAAY,EAAE,YAAqB;QACrF,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IACvD,CAAC;IAKD,MAAM,CAAC,UAAU,CAAC,IAAkB,EAAE,IAAY;QAChD,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,KAAK,IAAI,CAAC,CAAC;QAC5C,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IAmBD,MAAM,CAAC,SAAS,CAAC,IAAe,EAAE,eAA6B,EAAE,QAAmB,EAAE,OAAe,EAAE,qBAA0B,EAAE,oBAAyB,EAAE,aAAkB,EAAE,SAAmB,EAAE,cAAuB,EAAE,wBAAkC,EAAE,OAAiB;QACnR,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE;YACzB,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,wBAAwB,EAAE,OAAO,CAAC,CAAC;aAEpL,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE;YAC9B,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,wBAAwB,CAAC,CAAC;;YAE9K,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,aAAa,CAAC,CAAC;IAC7H,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,IAAe,EAAE,SAAuB,EAAE,QAAmB,EAAE,OAAe,EAAE,KAAa,EAAE,GAAW,EAAE,IAAY,EAAE,SAAkB,EAAE,cAAsB,EAAE,eAAwB,EAAE,OAAgB;QACzO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;QAC3C,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACjI,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,IAAkB,EAAE,GAAW,EAAE,QAAmB;QACxE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,iBAAiB,KAAK,IAAI,CAAC,CAAC;QAChD,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IAChD,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,IAAe,EAAE,IAAkB,EAAE,QAAmB,EAAE,OAAe,EAAE,KAAa,EAAE,GAAW,EAAE,IAAY,EAAE,SAAkB,EAAE,cAAsB,EAAE,OAAgB;QAC1M,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;QAC3C,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACzH,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,IAAe,EAAE,IAAkB,EAAE,QAAmB,EAAE,OAAe,EAAE,cAAsB,EAAE,eAAwB,EAAE,OAAgB;QACtK,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;QAC3C,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACzH,CAAC;IAMD,MAAM,CAAC,WAAW,CAAC,IAAe;QAChC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAID,MAAM,CAAC,SAAS,CAAC,IAAe;QAC9B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC;QAC3C,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAID,MAAM,CAAC,OAAO,CAAC,OAAgB;QAC7B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAOD,MAAM,CAAC,aAAa,CAAC,IAAkB,EAAE,aAAqB;QAC5D,IAAI,MAAM,CAAC,gBAAgB,KAAK,IAAI,EAAE;YACpC,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;SAC9C;IACH,CAAC;IAOD,MAAM,CAAC,aAAa,CAAC,IAAkB,EAAE,eAAuB,EAAE,OAAgB,EAAE,cAA8B;QAC9G,IAAI,MAAM,CAAC,gBAAgB,KAAK,IAAI,EAAE;YAClC,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC;SAC3E;IACL,CAAC;IAOD,MAAM,CAAC,aAAa,CAAC,UAAwB,EAAE,SAAiB,EAAE,YAAoB;QACpF,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,KAAK,IAAI,CAAC,CAAC;QAC/C,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;IAC/D,CAAC;IAMD,MAAM,CAAC,aAAa;QAClB,IAAI,MAAM,CAAC,kBAAkB,KAAK,IAAI,EAAE;YACtC,MAAM,CAAC,kBAAkB,EAAE,CAAC;SAC7B;IACH,CAAC;IAKD,MAAM,CAAC,WAAW,CAAC,UAAqB;QACtC,IAAI,MAAM,CAAC,cAAc,KAAK,IAAI,EAAE;YAClC,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;SACnC;IACH,CAAC;IAMD,MAAM,CAAC,2BAA2B;QAChC,IAAI,QAAQ,GAAY,KAAK,CAAC;QAC9B,IAAI,MAAM,CAAC,gCAAgC,KAAK,IAAI,EAAE;YACpD,QAAQ,GAAG,MAAM,CAAC,gCAAgC,EAAE,CAAC;SACtD;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAMD,MAAM,CAAC,SAAS,CAAC,UAAkB;QACjC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,OAAO,CAAC,UAAU,KAAK,IAAI,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;IACzG,CAAC;IAUD,MAAM,CAAC,mBAAmB,CAAC,SAAiB,EAAE,KAAa,EAAE,MAAc,EAAE,UAAmB,EAAE,IAAY;QAC5G,IAAI,MAAM,CAAC,sBAAsB,KAAK,IAAI,EAAE;YAC1C,MAAM,CAAC,sBAAsB,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;SAC3E;IACH,CAAC;IAMD,MAAM,CAAC,uBAAuB,CAAC,gBAAwB;QACrD,IAAI,MAAM,CAAC,0BAA0B,KAAK,IAAI,EAAE;YAC9C,MAAM,CAAC,0BAA0B,CAAC,gBAAgB,CAAC,CAAC;SACrD;IACH,CAAC;IAMD,MAAM,CAAC,SAAS,CAAC,SAAiB;QAChC,IAAI,GAAG,GAAW,CAAC,CAAC;QACpB,IAAI,MAAM,CAAC,cAAc,KAAK,IAAI,EAAE;YAClC,GAAG,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;SACxC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAMD,MAAM,CAAC,oBAAoB,CAAC,WAAmB;QAC7C,IAAI,MAAM,CAAC,uBAAuB,KAAK,IAAI,EAAE;YAC3C,MAAM,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;SAC7C;IACH,CAAC;IAUD,MAAM,CAAC,kBAAkB,CAAC,SAAiB,EAAE,OAAe,EAAE,MAAc,EAAE,KAAa,EAAE,SAAiB;QAC5G,IAAI,MAAM,CAAC,qBAAqB,KAAK,IAAI,EAAE;YACzC,MAAM,CAAC,qBAAqB,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;SAC5E;IACH,CAAC;IAkBD,MAAM,CAAC,iBAAiB,CAAC,OAAe,EAAE,SAAiB,EAAE,UAAkB,EAAE,KAAa,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,MAAc,EAAE,UAAkB,EAAE,KAAa,EAAE,SAAiB,EAAE,MAAc;QACvN,IAAI,QAAQ,GAAW,CAAC,CAAC;QACzB,IAAI,MAAM,CAAC,oBAAoB,KAAK,IAAI,EAAE;YACxC,QAAQ,GAAG,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;SAC1I;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAMD,MAAM,CAAC,kBAAkB,CAAC,OAAe;QACvC,IAAI,MAAM,CAAC,qBAAqB,KAAK,IAAI,EAAE;YACzC,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;SACvC;IACH,CAAC;IAMD,MAAM,CAAC,mBAAmB,CAAC,mBAA2B;QACpD,IAAI,MAAM,CAAC,sBAAsB,KAAK,IAAI,EAAE;YAC1C,MAAM,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;SACpD;IACH,CAAC;IAMD,MAAM,CAAC,iBAAiB,CAAC,GAAW;QAClC,IAAI,QAAQ,GAAW,CAAC,CAAC;QACzB,IAAI,MAAM,CAAC,oBAAoB,KAAK,IAAI,EAAE;YACxC,QAAQ,GAAG,MAAM,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;SAC7C;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAGD,MAAM,CAAC,wBAAwB;QAC7B,IAAI,MAAM,CAAC,6BAA6B,KAAK,IAAI,EAAE;YACjD,MAAM,CAAC,6BAA6B,EAAE,CAAC;SACxC;IACH,CAAC;IAOD,MAAM,CAAC,sBAAsB,CAAC,IAAkB;QAC9C,OAAO,MAAM,CAAC,2BAA2B,KAAK,IAAI,IAAI,MAAM,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;IACjG,CAAC;IAID,MAAM,CAAC,aAAa;QAClB,OAAO,MAAM,CAAC,kBAAkB,KAAK,IAAI,IAAI,MAAM,CAAC,kBAAkB,EAAE,CAAC;IAC3E,CAAC;IAID,MAAM,CAAC,YAAY;QACjB,OAAO,CAAC,MAAM,CAAC,iBAAiB,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,CAAC;IAWD,MAAM,CAAC,aAAa,CAAC,WAAgB,EAAE,IAAY,EAAE,YAAoB,EAAE,YAAqB,EAAE,aAAsB,EAAE,oBAA6B;QACrJ,IAAI,OAAO,GAAY,KAAK,CAAC;QAC7B,IAAI,MAAM,CAAC,gBAAgB,KAAK,IAAI,EAAE;YACpC,OAAO,GAAG,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,oBAAoB,CAAC,CAAC;SACvH;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAOD,MAAM,CAAC,kBAAkB;QACvB,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,uBAAuB,KAAK,IAAI,CAAC,CAAC;QACtD,OAAO,MAAM,CAAC,uBAAuB,EAAE,CAAC;IAC1C,CAAC;IAOD,MAAM,CAAC,YAAY,CAAC,SAAoB;QACtC,IAAI,SAAS,GAAW,CAAC,CAAC,CAAC;QAC3B,KAAK,CAAC,MAAM,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC;QACjC,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACrC,SAAS,GAAG,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;SACjD;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAOD,MAAM,CAAC,QAAQ,CAAC,MAAkB,EAAE,EAAW;QAC7C,IAAI,MAAM,CAAC,aAAa,KAAK,IAAI,EAAE;YACjC,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;SAClC;IACH,CAAC;IAKD,MAAM,CAAC,UAAU,CAAC,SAAoB;QACpC,IAAI,MAAM,CAAC,aAAa,KAAK,IAAI,EAAE;YACjC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;SACjC;IACH,CAAC;IAKD,MAAM,CAAC,cAAc,CAAC,SAAoB;QACxC,IAAI,MAAM,CAAC,mBAAmB,KAAK,IAAI,EAAE;YACvC,MAAM,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;SACvC;IACH,CAAC;IAKD,MAAM,CAAC,YAAY,CAAC,SAAoB;QACtC,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACrC,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;SACrC;IACH,CAAC;IASD,MAAM,CAAC,kBAAkB,CAAC,SAAoB,EAAE,OAAe;QAC7D,IAAI,MAAM,CAAC,uBAAuB,KAAK,IAAI,EAAE;YAC3C,MAAM,CAAC,uBAAuB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;SACpD;IACH,CAAC;IAMD,MAAM,CAAC,UAAU;QACf,IAAI,KAAK,GAAY,KAAK,CAAC;QAC3B,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI,EAAE;YACrC,KAAK,GAAG,MAAM,CAAC,iBAAiB,EAAE,CAAC;SACpC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,CAAC,iBAAiB;QACtB,IAAI,UAAU,GAAY,KAAK,CAAC;QAChC,IAAI,MAAM,CAAC,wBAAwB,KAAK,IAAI,EAAE;YAC5C,UAAU,GAAG,MAAM,CAAC,wBAAwB,EAAE,CAAC;SAChD;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,2BAA2B;QAChC,IAAI,oBAAoB,GAAY,KAAK,CAAC;QAC1C,IAAI,MAAM,CAAC,kCAAkC,KAAK,IAAI,EAAE;YACtD,oBAAoB,GAAG,MAAM,CAAC,kCAAkC,EAAE,CAAC;SACpE;QACD,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAMD,MAAM,CAAC,cAAc,CAAC,SAAiB,EAAE,MAAc;QACrD,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,mBAAmB,KAAK,IAAI,CAAC,CAAC;QAClD,OAAO,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACvD,CAAC;IAOD,MAAM,CAAC,oBAAoB,CAAC,UAAkB;QAC5C,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,yBAAyB,KAAK,IAAI,CAAC,CAAC;QACxD,OAAO,MAAM,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC;IAKD,MAAM,CAAC,gBAAgB,CAAC,KAAa;QACnC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,qBAAqB,KAAK,IAAI,CAAC,CAAC;QACpD,IAAI,UAAU,GAAW,MAAM,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC7D,IAAI,IAAI,GAAW,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACvC,IAAI,GAAkB,CAAC;YACvB,GAAG,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC;YAC9B,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAC7B,IAAI,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;SACvB;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAID,MAAM,CAAC,WAAW,CAAC,KAAY,EAAE,IAA+B;QAC9D,IAAI,MAAM,CAAC,cAAc,KAAK,IAAI,EAAE;YAClC,MAAM,CAAC,cAAc,CAAC,KAAK,EAAiB,IAAI,CAAC,CAAC;SACnD;IACH,CAAC;IAOD,MAAM,CAAC,iBAAiB,CAAC,SAAiB;QACxC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,sBAAsB,KAAK,IAAI,CAAC,CAAC;QACrD,OAAO,MAAM,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;IAOD,MAAM,CAAC,uBAAuB,CAAC,YAA0B,EAAE,WAAmB;QAC5E,IAAI,MAAM,CAAC,wBAAwB,KAAK,IAAI,EAAE;YAC5C,MAAM,CAAC,wBAAwB,CAAE,WAAW,CAAC,CAAC;SAC/C;IACH,CAAC;IAYD,MAAM,CAAC,iBAAiB,CAAC,SAAoB,EAAE,WAAmB,EAAE,CAAS,EAAE,CAAS,EAAE,OAAe,EAAE,OAAe,EAAE,+BAAwC;QAClK,IAAI,MAAM,CAAC,sBAAsB,KAAK,IAAI,EAAE;YAC1C,MAAM,CAAC,sBAAsB,CAAE,WAAW,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,+BAA+B,CAAC,CAAC;SACtG;IACH,CAAC;IAID,MAAM,CAAC,eAAe,CAAC,GAAW;QAChC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,oBAAoB,KAAK,IAAI,CAAC,CAAC;QACnD,MAAM,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAID,MAAM,CAAC,mBAAmB,CAAC,OAAY;QACrC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,WAAW,KAAK,MAAM,CAAC,EAAE;YAClF,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;YACtC,OAAO;SACR;QACD,MAAM,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IAEO,MAAM,CAAC,qBAAqB,CAAC,GAAW;QAC9C,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,oBAAoB,KAAK,IAAI,CAAC,CAAC;QACnD,MAAM,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAEO,MAAM,CAAC,qBAAqB,CAAC,EAAa;QAChD,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE;YAC9D,EAAE,CAAC,OAAO,EAAE,EAAE,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,OAAO;SACpF,CAAC,CAAC,CAAC;IACN,CAAC;IAMD,MAAM,CAAC,iBAAiB,CAAC,OAAY;QACnC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,WAAW,KAAK,MAAM,CAAC,EAAE;YAClF,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;YACpC,OAAO;SACR;QACD,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACtC,CAAC;IAEO,MAAM,CAAC,mBAAmB,CAAC,GAAW;QAC5C,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,sBAAsB,KAAK,IAAI,CAAC,CAAC;QACrD,MAAM,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAEO,MAAM,CAAC,mBAAmB,CAAC,EAAa;QAC9C,MAAM,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,aAAa,CAAC,MAAM,GAAG,EAAE,CAAC,UAAU,GAAG,aAAa,CAAC,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC,CAAC;IAC5H,CAAC;IAOD,MAAM,CAAC,SAAS,CAAC,QAA0B;QACzC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,CAAC;QAC7C,OAAO,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAID,MAAM,CAAC,aAAa,CAAC,GAAW;QAC9B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,KAAK,IAAI,CAAC,CAAC;QACjD,MAAM,CAAC,kBAAkB,CAAC,OAAO,GAAG,GAAG,CAAC,CAAC;IAC3C,CAAC;IAID,MAAM,CAAC,aAAa,CAAC,GAAW;QAC9B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,KAAK,IAAI,CAAC,CAAC;QACjD,MAAM,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAMD,MAAM,CAAC,OAAO,CAAC,IAAkB;QAC7B,IAAI,MAAM,CAAC,UAAU,KAAK,IAAI,EAAE;YAC5B,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SAC3B;IACL,CAAC;IAMD,MAAM,CAAC,MAAM,CAAC,IAAkB;QAC5B,IAAI,MAAM,CAAC,SAAS,KAAK,IAAI,EAAE;YAC3B,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SAC1B;IACL,CAAC;IAQD,MAAM,CAAC,kBAAkB;QACvB,OAAO,MAAM,CAAC,wBAAwB,KAAK,IAAI,IAAI,MAAM,CAAC,wBAAwB,EAAE,CAAC;IACvF,CAAC;IAID,MAAM,CAAC,yBAAyB;QAC9B,IAAI,MAAM,CAAC,0BAA0B,KAAK,IAAI,EAAE;YAC9C,MAAM,CAAC,0BAA0B,EAAE,CAAC;SACrC;IACH,CAAC;IAOD,MAAM,CAAC,UAAU,CAAC,SAAoB,EAAE,QAAgB;QACtD,IAAI,MAAM,CAAC,aAAa,KAAK,IAAI,EAAE;YACjC,MAAM,CAAC,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;SAC3C;IACH,CAAC;IAED;IACA,CAAC;;AAxkCM,qCAA8B,GAAiC,IAAI,CAAC;AAKpE,uCAAgC,GAAkB,IAAI,CAAC;AAKvD,qBAAc,GAAmC,IAAI,CAAC;AAUtD,6BAAsB,GAAkG,IAAI,CAAC;AAM7H,iCAA0B,GAAuC,IAAI,CAAC;AAMtE,qBAAc,GAAkC,IAAI,CAAC;AAMrD,8BAAuB,GAAkC,IAAI,CAAC;AAU9D,4BAAqB,GAAmG,IAAI,CAAC;AAkB7H,2BAAoB,GAAiN,IAAI,CAAC;AAM1O,4BAAqB,GAA8B,IAAI,CAAC;AAMxD,6BAAsB,GAA8B,IAAI,CAAC;AAMzD,2BAAoB,GAA4B,IAAI,CAAC;AAOrD,oBAAa,GAA8C,IAAI,CAAC;AAIhE,qBAAc,GAAgD,IAAI,CAAC;AAOnE,6BAAsB,GAA8C,IAAI,CAAC;AAOzE,+BAAwB,GAAmC,IAAI,CAAC;AAYhE,6BAAsB,GAAoI,IAAI,CAAC;AAI/J,2BAAoB,GAA0B,IAAI,CAAC;AAInD,+BAAwB,GAA0B,IAAI,CAAC;AAKvD,6BAAsB,GAA0B,IAAI,CAAC;AAOrD,qBAAc,GAA4C,IAAI,CAAC;AAI/D,yBAAkB,GAA0B,IAAI,CAAC;AAIjD,yBAAkB,GAA0B,IAAI,CAAC;AAQjD,iBAAU,GAAiC,IAAI,CAAC;AAMhD,gBAAS,GAAiC,IAAI,CAAC;AAQ/C,+BAAwB,GAAkB,IAAI,CAAC;AAI/C,iCAA0B,GAAe,IAAI,CAAC;AAO9C,oBAAa,GAAqD,IAAI,CAAC;AAMvE,iBAAU,GAA8F,IAAI,CAAC;AAI7G,kCAA2B,GAAiC,IAAI,CAAC;AASjE,qBAAc,GAA8K,IAAI,CAAC;AAKjM,wBAAiB,GAAmE,IAAI,CAAC;AAKzF,mBAAY,GAA+C,IAAI,CAAC;AAKhE,6BAAsB,GAA+C,IAAI,CAAC;AAO1E,qBAAc,GAAmF,IAAI,CAAC;AAKtG,oBAAa,GAA+C,IAAI,CAAC;AAejE,mBAAY,GAAkO,IAAI,CAAC;AAOnP,wBAAiB,GAAwE,IAAI,CAAC;AAM9F,qBAAc,GAAiC,IAAI,CAAC;AAIpD,mBAAY,GAA8B,IAAI,CAAC;AAI/C,iBAAU,GAA+B,IAAI,CAAC;AAM9C,uBAAgB,GAAwD,IAAI,CAAC;AAO7E,uBAAgB,GAA4G,IAAI,CAAC;AAKjI,yBAAkB,GAAkD,IAAI,CAAC;AAKzE,uBAAgB,GAAkD,IAAI,CAAC;AAMvE,uBAAgB,GAAgF,IAAI,CAAC;AAKrG,yBAAkB,GAAe,IAAI,CAAC;AAMtC,qBAAc,GAAoC,IAAI,CAAC;AAIvD,oCAA6B,GAAe,IAAI,CAAC;AAOjD,kCAA2B,GAAoC,IAAI,CAAC;AAIpE,yBAAkB,GAAkB,IAAI,CAAC;AAIzC,wBAAiB,GAAiB,IAAI,CAAC;AAWvC,uBAAgB,GAAoJ,IAAI,CAAC;AAOzK,8BAAuB,GAAiB,IAAI,CAAC;AAO7C,wBAAiB,GAAqC,IAAI,CAAC;AAK3D,oBAAa,GAAmC,IAAI,CAAC;AAKrD,0BAAmB,GAAmC,IAAI,CAAC;AAK3D,wBAAiB,GAAmC,IAAI,CAAC;AASzD,8BAAuB,GAAoD,IAAI,CAAC;AAMhF,wBAAiB,GAAkB,IAAI,CAAC;AAGxC,+BAAwB,GAAkB,IAAI,CAAC;AAG/C,yCAAkC,GAAkB,IAAI,CAAC;AAOzD,0BAAmB,GAAuD,IAAI,CAAC;AAO/E,gCAAyB,GAAmC,IAAI,CAAC;AAKjE,4BAAqB,GAA8B,IAAI,CAAC","sourcesContent":["import {GuiMgControl} from \"./gui/GuiMgControl\";\r\nimport {MgFormBase} from \"./management/gui/MgFormBase\";\r\nimport {ITask} from \"./management/tasks/ITask\";\r\nimport {MgControlBase} from \"./management/gui/MgControlBase\";\r\nimport {RuntimeContextBase} from \"./management/RuntimeContextBase\";\r\nimport {GuiMgForm} from \"./gui/GuiMgForm\";\r\nimport {GuiTaskBase} from \"./management/tasks/GuiTaskBase\";\r\nimport {Debug, Exception, List, NString, StringBuilder} from \"@magic-xpa/mscorelib\";\r\nimport {Modifiers} from \"./GuiEnums\";\r\nimport {MgTimer} from \"./management/tasks/MgTimer\";\r\nimport {LastFocusedVal} from \"./gui/LastFocusedVal\";\r\nimport {Logger_LogLevels, OSEnvironment} from \"@magic-xpa/utils\";\r\nimport { GuiControlPropertyAdapter } from \"./management/gui/GuiControlPropertyAdapter\";\r\n\r\n/// <summary>events raised by MgGui.dll and handled by MgxpaRIA.exe or MgxpaRuntime.exe.\r\n/// Important note: these events are NOT related the events handling of Magic (RC or RTE) -\r\n///   the events exposed from this class contain functionality that the current assembly (MgGui.dll)\r\n///   requires from either MgxpaRIA.exe or MgxpaRuntime.exe.\r\n/// This class contains only the definitions of all delegates and events.\r\n/// Class 'EventsProcessor' contains handlers for events that can be served locally (by MgGui.dll),\r\n///   and registered external handlers (in MgxpaRIA.exe or MgxpaRuntime.exe) for events that can't be served locally.\r\n/// </summary>\r\nexport class Events {\r\n  /// <summary> invokes the VisibilityChanged Event</summary>\r\n  /// <param name=\"ctrl\">control whose visibility is changed</param>\r\n  static NonParkableLastParkedCtrlEvent: (ctrl: GuiMgControl) => void = null;\r\n\r\n  /// <summary>\r\n  /// returns TRUE, if Batch task is running in MAIN context.\r\n  /// </summary>\r\n  static IsBatchRunningInMainContextEvent: () => boolean = null;\r\n\r\n  /// <summary>MLS translation</summary>\r\n  /// <param name=\"fromString\">source string</param>\r\n  /// <returns>translated string</returns>\r\n  static TranslateEvent: (fromString: string) => string = null;\r\n\r\n  /// <summary>\r\n  /// Creates Print Preview Form\r\n  /// </summary>\r\n  /// <param name=\"contextId\">context id</param>\r\n  /// <param name=\"ioPtr\">pointer to current IORT object</param>\r\n  /// <param name=\"copies\">number of copies</param>\r\n  /// <param name=\"enablePDlg\">indicates whether to enable Print dialog</param>\r\n  /// <param name=\"hWnd\">Handle of Print Preview Form</param>\r\n  static PrintPreviewStartEvent: (contextID: number, ioPtr: number, copies: number, enablePDlg: boolean, hWnd: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// Set cursor to Print Preview form\r\n  /// </summary>\r\n  /// <param name=\"prnPrevData\">print preview data</param>\r\n  static PrintPreviewSetCursorEvent: (printPreviewData: number) => void = null;\r\n\r\n  ///<summary>\r\n  /// Handles Invoke UDP operation from GUI thread\r\n  ///</summary>\r\n  ///<param name=\"contextId\">Context id</param>\r\n  static InvokeUDPEvent: (contextId: number) => number = null;\r\n\r\n  /// <summary>\r\n  /// Update Print Preview\r\n  /// </summary>\r\n  /// <param name=\"prnPrevData\">print preview data</param>\r\n  static PrintPreviewUpdateEvent: (prnPrevData: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// Create Rich Edit\r\n  /// </summary>\r\n  /// <param name=\"contextId\"></param>\r\n  /// <param name=\"ctrlPtr\"></param>\r\n  /// <param name=\"prmPtr\"></param>\r\n  /// <param name=\"style\"></param>\r\n  /// <param name=\"dwExStyle\"></param>\r\n  static CreateRichWindowEvent: (contextID: number, ctrlPtr: number, prmPtr: number, style: number, dwExStyle: number) => void = null;\r\n\r\n  ///<summary>\r\n  ///  Creates a window\r\n  ///</summary>\r\n  ///<param name=\"exStyle\">!!.</param>\r\n  ///<param name=\"className\">!!.</param>\r\n  ///<param name=\"windowName\">!!.</param>\r\n  ///<param name=\"style\">!!.</param>\r\n  ///<param name=\"x\">!!.</param>\r\n  ///<param name=\"y\">!!.</param>\r\n  ///<param name=\"width\">!!.</param>\r\n  ///<param name=\"height\">!!.</param>\r\n  ///<param name=\"hwndParent\">!!.</param>\r\n  ///<param name=\"hMenu\">!!.</param>\r\n  ///<param name=\"hInstance\">!!.</param>\r\n  ///<param name=\"lParam\">!!.</param>\r\n  ///<returns>handle of window</returns>\r\n  static CreateGuiWindowEvent: (exStyle: number, className: string, windowName: string, style: number, x: number, y: number, width: number, height: number, hwndParent: number, hMenu: number, hInstance: number, lParam: number) => number = null;\r\n\r\n  /// <summary>\r\n  /// Destroys a window\r\n  /// </summary>\r\n  /// <param name=\"hWndPtr\">handle of window</param>\r\n  static DestroyGuiWindowEvent: (hWndPtr: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// OnClose Print Preview\r\n  /// </summary>\r\n  /// <param name=\"hWndPtr\">print preview data</param>\r\n  static PrintPreviewCloseEvent: (hWndPtr: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// Show Print Dialog\r\n  /// </summary>\r\n  /// <param name=\"gpd\"></param>\r\n  static ShowPrintDialogEvent: (gpd: number) => number = null;\r\n\r\n  /// <summary>\r\n  /// SetModal event\r\n  /// </summary>\r\n  /// <param name=\"currForm\"></param>\r\n  /// <param name=\"on\"></param>\r\n  static SetModalEvent: (mgForm: MgFormBase, on: boolean) => void = null;\r\n\r\n  /// <summary>raises CtrlFocusEvent</summary>\r\n  /// <returns></returns>\r\n  static CtrlFocusEvent: (iTask: ITask, ctrl: MgControlBase) => void = null;\r\n\r\n  /// <summary>\r\n  /// Gets the RuntimeContextBase that belongs to the contextID\r\n  /// </summary>\r\n  /// <param name=\"contextID\"></param>\r\n  /// <returns></returns>\r\n  static GetRuntimeContextEvent: (contextID: string) => RuntimeContextBase = null;\r\n\r\n  /// <summary>\r\n  /// Saves the name of the last clicked control.\r\n  /// </summary>\r\n  /// <param name=\"guiMgControl\">guiMgControl</param>\r\n  /// <param name=\"controlName\">Name of the control</param>\r\n  static SaveLastClickedCtrlEvent: ( controlName: string) => void = null;\r\n\r\n  /// <summary>\r\n  /// Saves the last clicked information. (i.e. Co-ordinates and control name.\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\">guiMgForm</param>\r\n  /// <param name=\"controlName\">name of the control</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\">co-ordinates are in pixel or not.</param>\r\n  static SaveLastClickInfoEvent: (controlName: string, x: number, y: number, offsetX: number, offsetY: number, lastClickCoordinatesAreInPixels: boolean) => void = null;\r\n\r\n  /// <summary>write an error message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteErrorToLogEvent: (msg: string) => void = null;\r\n\r\n  /// <summary>Write an internal error to the log. Also prints stack trace along with the message</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteExceptionToLogEvent: (msg: string) => void = null;\r\n\r\n\r\n  /// <summary>write a warning message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteWarningToLogEvent: (msg: string) => void = null;\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"logLevel\"></param>\r\n  /// <returns></returns>\r\n  static ShouldLogEvent: (logLevel: Logger_LogLevels) => boolean = null;\r\n\r\n  /// <summary>write a GUI message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteGuiToLogEvent: (msg: string) => void = null;\r\n\r\n  /// <summary>write a DEV message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteDevToLogEvent: (msg: string) => void = null;\r\n\r\n\r\n\r\n  /// <summary>\r\n  /// Called when WM_CLEAR message is received\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static ClearEvent: (ctrl: GuiMgControl) => void = null;\r\n\r\n  /// <summary>\r\n  /// Called when WM_UNDO message is received\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static UndoEvent: (ctrl: GuiMgControl) => void = null;\r\n\r\n  /// <summary>\r\n  /// Should Enter be added as keyboard event ? This is important mostly in determining if a click event\r\n  /// will be raised for a default button or not.\r\n  /// Adding Enter as a keyboard event will not raise click on default button.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static ShouldAddEnterAsKeyEvent: () => boolean = null;\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  static ShowSessionStatisticsEvent: () => void = null;\r\n\r\n  /// <summary>\r\n  /// Called when WM_COPYDATA message is received\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"copyData\"></param>\r\n  static CopyDataEvent: (guiMgForm: GuiMgForm, copyData: number) => void = null;\r\n\r\n  /// <summary> invokes the focus event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"isProduceClick\"></param>\r\n  static FocusEvent: (ctrl: GuiMgControl, line: number, isProduceClick: boolean, onMultiMark: boolean) => void = null;\r\n\r\n  /// <summary> invokes the focus out event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static FocusOnNonMagicControlEvent: (ctrl: GuiMgControl) => void = null;\r\n\r\n  /// <summary> invokes the MouseDown Event</summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"guiMgCtrl\"></param>\r\n  /// <param name=\"dotNetArgs\"></param>\r\n  /// <param name=\"leftClickWasPressed\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"onMultiMark\">indicates that Multi Mark continues</param>\r\n  static MouseDownEvent: (guiMgForm: GuiMgForm, guiMgCtrl: GuiMgControl, dotNetArgs: Object[], leftClickWasPressed: boolean, line: number, onMultiMark: boolean, canProduceClick: boolean) => void = null;\r\n\r\n  /// <summary> invokes the TableReorder Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"tabOrderList\"></param>\r\n  static TableReorderEvent: (ctrl: GuiMgControl, tabOrderList: List<GuiMgControl>) => void = null;\r\n\r\n  /// <summary> invokes the MouseUp Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static MouseUpEvent: (ctrl: GuiMgControl, line: number) => void = null;\r\n\r\n  /// <summary> invokes the ComboDroppingDown Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static ComboDroppingDownEvent: (ctrl: GuiMgControl, line: number) => void = null;\r\n\r\n  /// <summary> invokes the Selection Event</summary>\r\n  /// <param name=\"val\"></param>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"produceClick\"></param>\r\n  static SelectionEvent: (val: string, ctrl: GuiMgControl, line: number, produceClick: boolean) => void = null;\r\n\r\n  /// <summary> invokes the DblClick Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static DblClickEvent: (ctrl: GuiMgControl, line: number) => void = null;\r\n\r\n  /// <summary> invokes the KeyDown Event</summary>\r\n  /// <param name=\"form\"></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=\"comboIsDropDown\"></param>\r\n  /// <param name=\"handled\">boolean variable event is handled or not. </param>\r\n  static KeyDownEvent: (form: GuiMgForm, guiMgCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, comboIsDropDown: boolean, handled: boolean) => boolean = null;\r\n\r\n  /// <summary>\r\n  /// delegate for the MultiMark hit event\r\n  /// </summary>\r\n  /// <param name=\"guiMgCtrl\"> control </param>\r\n  /// <param name=\"row\"> table row </param>\r\n  static MultimarkHitEvent: (guiMgCtrl: GuiMgControl, row: number, modifier: Modifiers) => void = null;\r\n\r\n  /// <summary> invokes the Close Event</summary>\r\n  /// <param name=\"form\"></param>\r\n  /// <returns>true if event is CLR handled(closing of the form will be the responsibility of the CLR and no commands will be put\r\n  /// in to close the form) else false.</returns>\r\n  static CloseFormEvent: (form: GuiMgForm) => boolean = null;\r\n\r\n  /// <summary> invokes the Dispose Event</summary>\r\n  /// <param name=\"form\"></param>\r\n  static DisposeEvent: (form: GuiMgForm) => void = null;\r\n\r\n  /// <summary> invokes the Timer Event</summary>\r\n  /// <param name=\"mgTimer\"></param>\r\n  static TimerEvent: (mgTimer: MgTimer) => void = null;\r\n\r\n\r\n  /// <summary> invokes the Resize Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"newRowsInPage\"></param>\r\n  static TableResizeEvent: (ctrl: GuiMgControl, newRowsInPage: number) => void = null;\r\n\r\n  /// <summary> invokes the GetRowsData Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"desiredTopIndex\"></param>\r\n  /// <param name=\"sendAll\"></param>\r\n  /// <param name=\"lastFocusedVal\"></param>\r\n  static GetRowsDataEvent: (ctrl: GuiMgControl, desiredTopIndex: number, sendAll: boolean, lastFocusedVal: LastFocusedVal) => void = null;\r\n\r\n  /// <summary> invokes the EnableCutCopy Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"enable\"></param>\r\n  static EnableCutCopyEvent: (ctrl: GuiMgControl, enable: boolean) => void = null;\r\n\r\n  /// <summary> invokes the EnablePaste Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"enable\"></param>\r\n  static EnablePasteEvent: (ctrl: GuiMgControl, enable: boolean) => void = null;\r\n\r\n  /// <summary> invokes the ColumnClick Event</summary>\r\n  /// <param name=\"columnCtrl\"></param>\r\n  /// <param name=\"direction\"></param>\r\n  /// <param name=\"columnHeader\"></param>\r\n  static ColumnClickEvent: (columnCtrl: GuiMgControl, direction: number, columnHeader: string) => void = null;\r\n\r\n\r\n\r\n  /// <summary>invokes refreshTables delegate</summary>\r\n  static RefreshTablesEvent: () => void = null;\r\n\r\n\r\n\r\n  /// <summary>OnHelpClose</summary>\r\n  /// <param name=\"activeForm\"></param>\r\n  static HelpCloseEvent: (activeForm: GuiMgForm) => void = null;\r\n\r\n\r\n  /// <summary> displaySessionStatistics </summary>\r\n  static DisplaySessionStatisticsEvent: () => void = null;\r\n\r\n  /// <summary>\r\n  /// returns true for non interactive task for all controls except a button control\r\n  /// </summary>\r\n  /// <param name=\"ctrl\">clicked control</param>\r\n  /// <returns></returns>\r\n  static ShouldBlockMouseEventsEvent: (ctrl: GuiMgControl) => boolean = null;\r\n\r\n  /// <summary>peekEndOfWork</summary>\r\n  /// <returns></returns>\r\n  static PeekEndOfWorkEvent: () => boolean = null;\r\n\r\n  /// <summary>invokes the GetEventTime delegate</summary>\r\n  /// <returns></returns>\r\n  static GetEventTimeEvent: () => number = null;\r\n\r\n  /// <summary>\r\n  /// invokes the ScrollTable Event\r\n  /// </summary>\r\n  /// <param name=\"guiMgObject\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"rowsToScroll\"></param>\r\n  /// <param name=\"isPageScroll\">next/prev page?</param>\r\n  /// <param name=\"isTableScroll\">Begin/End Table?</param>\r\n  /// <param name=\"isRaisedByMouseWheel\">indicates whether event is raised by mousewheel or not.</param>\r\n  static ScrollTableEvent: (guiMgObject: any, line: number, rowsToScroll: number, isPageScroll: boolean, isTableScroll: boolean, isRaisedByMouseWheel: boolean) => boolean = null;\r\n\r\n  /// <summary>\r\n  /// Gets the user defined Drop formats\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <returns></returns>\r\n  static GetDropUserFormatsEvent: () => string = null;\r\n\r\n  /// <summary>\r\n  /// Get the context id from GuiMgForm\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <returns></returns>\r\n  static GetContextIDEvent: (guiMgForm: GuiMgForm) => number = null;\r\n\r\n  /// <summary> </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <returns></returns>\r\n  static ShowFormEvent: (guiMgForm: GuiMgForm) => void = null;\r\n\r\n  /// <summary>\r\n  /// invokes OnFormActivateEvent\r\n  /// </summary>\r\n  static OnFormActivateEvent: (guiMgForm: GuiMgForm) => void = null;\r\n\r\n  /// <summary>\r\n  /// invokes OnNCActivate\r\n  /// </summary>\r\n  static OnNCActivateEvent: (guiMgForm: GuiMgForm) => void = null;\r\n\r\n\r\n  /// <summary>\r\n  /// Handle WM_KEYUP - (required only for ACT_NEXT_RT_WINDOW, ACT_PREV_RT_WINDOW for sorting windowlist\r\n  /// when the key associated with the action is released)\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"keyCode\">keycode of a key which is just released</param>\r\n  static HandleKeyUpMessageEvent: (guiMgForm: GuiMgForm, keyCode: number) => void = null;\r\n\r\n  /// <summary>\r\n  /// checks whether we should show Logon window in RTOL format or not.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static OnIsLogonRTLEvent: () => boolean = null;\r\n\r\n\r\n  static OnIsSpecialEngLogonEvent: () => boolean = null;\r\n\r\n\r\n  static OnIsSpecialIgnoreButtonFormatEvent: () => boolean = null;\r\n\r\n\r\n  /// <summary> invokes the getMainProgram Event </summary>\r\n  /// <param name=\"contextID\">active/target context</param>\r\n  /// <param name=\"ctlIdx\"></param>\r\n  /// <returns></returns>\r\n  static GetMainProgramEvent: (contextID: number, ctlIdx: number) => GuiTaskBase = null;\r\n\r\n  /// <summary>\r\n  /// Logical name translation\r\n  /// </summary>\r\n  /// <param name=\"fromString\">source string</param>\r\n  /// <returns>translated string</returns>\r\n  static TranslateLogicalNameEvent: (fromString: string) => string = null;\r\n\r\n  /// <summary>invokes getMessageString Event</summary>\r\n  /// <param name=\"msgId\"></param>\r\n  /// <returns></returns>\r\n  static GetMessageStringEvent: (msgId: string) => string = null;\r\n\r\n  /// <summary> invokes the focus event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"isProduceClick\"></param>\r\n  static OnFocus(ctrl: GuiMgControl, line: number, isProduceClick: boolean, onMultiMark: boolean): void {\r\n    Debug.Assert(Events.FocusEvent !== null);\r\n    Events.FocusEvent(ctrl, line, isProduceClick, onMultiMark);\r\n  }\r\n\r\n  /// <summary> invokes the focus event</summary>\r\n  /// <param name=\"ctrl receiving lostFocus\"></param>\r\n  static OnFocusOnNonMagicControl(ctrl: GuiMgControl): void {\r\n    Debug.Assert(Events.FocusOnNonMagicControlEvent !== null);\r\n    Events.FocusOnNonMagicControlEvent(ctrl);\r\n  }\r\n\r\n\r\n  /// <summary> invokes the MouseDown Event</summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"guiMgCtrl\"></param>\r\n  /// <param name=\"dotNetArgs\"></param>\r\n  /// <param name=\"leftClickWasPressed\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"onMultiMark\">indicates that Multi Mark continues</param>\r\n  static OnMouseDown(guiMgForm: GuiMgForm, guiMgCtrl: GuiMgControl, dotNetArgs: any[], leftClickWasPressed: boolean, line: number, onMultiMark: boolean, canProduceClick: boolean): void {\r\n    Debug.Assert(Events.MouseDownEvent !== null);\r\n    Events.MouseDownEvent(guiMgForm, guiMgCtrl, dotNetArgs, leftClickWasPressed, line, onMultiMark, canProduceClick);\r\n  }\r\n\r\n\r\n  /// <summary> invokes the VisibilityChanged Event</summary>\r\n  /// <param name=\"ctrl\">control whose visibility is changed</param>\r\n  static OnNonParkableLastParkedCtrl(ctrl: GuiMgControl): void {\r\n    if (Events.NonParkableLastParkedCtrlEvent !== null) {\r\n      Events.NonParkableLastParkedCtrlEvent(ctrl);\r\n    }\r\n  }\r\n\r\n  /// <summary> invokes the TableReorder Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"tabOrderList\"></param>\r\n  static OnTableReorder(ctrl: GuiMgControl, tabOrderList: List<GuiMgControl>): void {\r\n    if (Events.TableReorderEvent !== null) {\r\n      Events.TableReorderEvent(ctrl, tabOrderList);\r\n    }\r\n  }\r\n\r\n  /// <summary> invokes the MouseUp Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static OnMouseUp(ctrl: GuiMgControl, line: number): void {\r\n    if (Events.MouseUpEvent !== null) {\r\n      Events.MouseUpEvent(ctrl, line);\r\n    }\r\n  }\r\n\r\n  /// <summary> invokes the ComboDroppingDown Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static OnComboDroppingDown(ctrl: GuiMgControl, line: number): void {\r\n    Debug.Assert(Events.ComboDroppingDownEvent !== null);\r\n    Events.ComboDroppingDownEvent(ctrl, line);\r\n  }\r\n\r\n  /// <summary> invokes the Selection Event</summary>\r\n  /// <param name=\"val\"></param>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"produceClick\"></param>\r\n  static OnSelection(val: string, ctrl: GuiMgControl, line: number, produceClick: boolean): void {\r\n    Debug.Assert(Events.SelectionEvent !== null);\r\n    Events.SelectionEvent(val, ctrl, line, produceClick);\r\n  }\r\n\r\n  /// <summary> invokes the DblClick Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"line\"></param>\r\n  static OnDblClick(ctrl: GuiMgControl, line: number): void {\r\n    Debug.Assert(Events.DblClickEvent !== null);\r\n    Events.DblClickEvent(ctrl, line);\r\n  }\r\n\r\n\r\n  /// <summary> invokes the KeyDown Event</summary>\r\n  /// <param name=\"form\"></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=\"comboIsDropDown\"></param>\r\n  /// <param name=\"handled\">boolean variable event is handled or not. </param>\r\n  static OnKeyDown(form: GuiMgForm, guiMgCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, comboIsDropDown: boolean, handled: boolean): void;\r\n  static OnKeyDown(form: GuiMgForm, ctrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, handled: boolean): void;\r\n  static OnKeyDown(form: GuiMgForm, ctrl: GuiMgControl, modifier: Modifiers, keyCode: number, suggestedValue: string, comboIsDropDown: boolean, handled: boolean): void;\r\n  static OnKeyDown(form: GuiMgForm, guiMgCtrlOrCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, startOrSuggestedValue: any, endOrComboIsDropDown: any, textOrHandled: any, isActChar?: boolean, suggestedValue?: string, comboIsDropDownOrHandled?: boolean, handled?: boolean): void {\r\n    if (arguments.length === 11)\r\n      Events.OnKeyDown_0(form, guiMgCtrlOrCtrl, modifier, keyCode, startOrSuggestedValue, endOrComboIsDropDown, textOrHandled, isActChar, suggestedValue, comboIsDropDownOrHandled, handled);\r\n\r\n    else if (arguments.length === 10)\r\n      Events.OnKeyDown_1(form, guiMgCtrlOrCtrl, modifier, keyCode, startOrSuggestedValue, endOrComboIsDropDown, textOrHandled, isActChar, suggestedValue, comboIsDropDownOrHandled);\r\n    else\r\n      Events.OnKeyDown_2(form, guiMgCtrlOrCtrl, modifier, keyCode, startOrSuggestedValue, endOrComboIsDropDown, textOrHandled);\r\n  }\r\n\r\n  private static OnKeyDown_0(form: GuiMgForm, guiMgCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, comboIsDropDown: boolean, handled: boolean): void {\r\n    Debug.Assert(Events.KeyDownEvent !== null);\r\n    Events.KeyDownEvent(form, guiMgCtrl, modifier, keyCode, start, end, text, isActChar, suggestedValue, comboIsDropDown, handled);\r\n  }\r\n\r\n  static OnMultiMarkHit(ctrl: GuiMgControl, row: number, modifier: Modifiers): void {\r\n    Debug.Assert(Events.MultimarkHitEvent !== null);\r\n    Events.MultimarkHitEvent(ctrl, row, modifier);\r\n  }\r\n\r\n  private static OnKeyDown_1(form: GuiMgForm, ctrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, handled: boolean): boolean {\r\n    Debug.Assert(Events.KeyDownEvent !== null);\r\n    return Events.KeyDownEvent(form, ctrl, modifier, keyCode, start, end, text, isActChar, suggestedValue, false, handled);\r\n  }\r\n\r\n  private static OnKeyDown_2(form: GuiMgForm, ctrl: GuiMgControl, modifier: Modifiers, keyCode: number, suggestedValue: string, comboIsDropDown: boolean, handled: boolean): boolean {\r\n    Debug.Assert(Events.KeyDownEvent !== null);\r\n    return Events.KeyDownEvent(form, ctrl, modifier, keyCode, 0, 0, null, false, suggestedValue, comboIsDropDown, handled);\r\n  }\r\n\r\n  /// <summary> invokes the Close Event</summary>\r\n  /// <param name=\"form\"></param>\r\n  /// <returns>true if event is CLR handled(closing of the form will be the responsibility of the CLR and no commands will be put\r\n  /// in to close the form) else false.</returns>\r\n  static OnFormClose(form: GuiMgForm): boolean {\r\n    Debug.Assert(Events.CloseFormEvent !== null);\r\n    return Events.CloseFormEvent(form);\r\n  }\r\n\r\n  /// <summary> invokes the Dispose Event</summary>\r\n  /// <param name=\"form\"></param>\r\n  static OnDispose(form: GuiMgForm): void {\r\n    Debug.Assert(Events.DisposeEvent !== null);\r\n    Events.DisposeEvent(form);\r\n  }\r\n\r\n  /// <summary> invokes the Timer Event</summary>\r\n  /// <param name=\"mgTimer\"></param>\r\n  static OnTimer(mgTimer: MgTimer): void {\r\n    Debug.Assert(Events.TimerEvent !== null);\r\n    Events.TimerEvent(mgTimer);\r\n  }\r\n\r\n\r\n\r\n  /// <summary> invokes the Resize Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"newRowsInPage\"></param>\r\n  static OnTableResize(ctrl: GuiMgControl, newRowsInPage: number): void {\r\n    if (Events.TableResizeEvent !== null) {\r\n      Events.TableResizeEvent(ctrl, newRowsInPage);\r\n    }\r\n  }\r\n\r\n  /// <summary> invokes the GetRowsData Event</summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <param name=\"desiredTopIndex\"></param>\r\n  /// <param name=\"sendAll\"></param>\r\n  /// <param name=\"lastFocusedVal\"></param>\r\n  static OnGetRowsData(ctrl: GuiMgControl, desiredTopIndex: number, sendAll: boolean, lastFocusedVal: LastFocusedVal): void {\r\n      if (Events.GetRowsDataEvent !== null) {\r\n          Events.GetRowsDataEvent(ctrl, desiredTopIndex, sendAll, lastFocusedVal);\r\n      }\r\n  }\r\n\r\n\r\n  /// <summary> invokes the ColumnClick Event</summary>\r\n  /// <param name=\"columnCtrl\"></param>\r\n  /// <param name=\"direction\"></param>\r\n  /// <param name=\"columnHeader\"></param>\r\n  static OnColumnClick(columnCtrl: GuiMgControl, direction: number, columnHeader: string): void {\r\n    Debug.Assert(Events.ColumnClickEvent !== null);\r\n    Events.ColumnClickEvent(columnCtrl, direction, columnHeader);\r\n  }\r\n\r\n\r\n\r\n\r\n  /// <summary>invokes refreshTables delegate</summary>\r\n  static RefreshTables(): void {\r\n    if (Events.RefreshTablesEvent !== null) {\r\n      Events.RefreshTablesEvent();\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>OnHelpClose</summary>\r\n  /// <param name=\"activeForm\"></param>\r\n  static OnCloseHelp(activeForm: GuiMgForm): void {\r\n    if (Events.HelpCloseEvent !== null) {\r\n      Events.HelpCloseEvent(activeForm);\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// returns TRUE, if Batch task is running in MAIN context.\r\n  /// </summary>\r\n  static IsBatchRunningInMainContext(): boolean {\r\n    let retValue: boolean = false;\r\n    if (Events.IsBatchRunningInMainContextEvent !== null) {\r\n      retValue = Events.IsBatchRunningInMainContextEvent();\r\n    }\r\n    return retValue;\r\n  }\r\n\r\n\r\n  /// <summary>MLS translation</summary>\r\n  /// <param name=\"fromString\">source string</param>\r\n  /// <returns>translated string</returns>\r\n  static Translate(fromString: string): string {\r\n    Debug.Assert(Events.TranslateEvent !== null);\r\n    return (fromString !== null && fromString.length > 0) ? Events.TranslateEvent(fromString) : fromString;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Creates Print Preview Form\r\n  /// </summary>\r\n  /// <param name=\"contextId\">context id</param>\r\n  /// <param name=\"ioPtr\">pointer to current IORT object</param>\r\n  /// <param name=\"copies\">number of copies</param>\r\n  /// <param name=\"enablePDlg\">indicates whether to enable Print dialog</param>\r\n  /// <param name=\"hWnd\">Handle of Print Preview Form</param>\r\n  static OnPrintPreviewStart(contextID: number, ioPtr: number, copies: number, enablePDlg: boolean, hWnd: number): void {\r\n    if (Events.PrintPreviewStartEvent !== null) {\r\n      Events.PrintPreviewStartEvent(contextID, ioPtr, copies, enablePDlg, hWnd);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Set cursor to Print Preview form\r\n  /// </summary>\r\n  /// <param name=\"prnPrevData\">print preview data</param>\r\n  static OnPrintPreviewSetCursor(printPreviewData: number): void {\r\n    if (Events.PrintPreviewSetCursorEvent !== null) {\r\n      Events.PrintPreviewSetCursorEvent(printPreviewData);\r\n    }\r\n  }\r\n\r\n  ///<summary>\r\n  /// Handles Invoke UDP operation from GUI thread\r\n  ///</summary>\r\n  ///<param name=\"contextId\">Context id</param>\r\n  static InvokeUDP(contextId: number): number {\r\n    let ret: number = 0;\r\n    if (Events.InvokeUDPEvent !== null) {\r\n      ret = Events.InvokeUDPEvent(contextId);\r\n    }\r\n    return ret;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Update Print Preview\r\n  /// </summary>\r\n  /// <param name=\"prnPrevData\">print preview data</param>\r\n  static OnPrintPreviewUpdate(prnPrevData: number): void {\r\n    if (Events.PrintPreviewUpdateEvent !== null) {\r\n      Events.PrintPreviewUpdateEvent(prnPrevData);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Create Rich Edit\r\n  /// </summary>\r\n  /// <param name=\"contextId\"></param>\r\n  /// <param name=\"ctrlPtr\"></param>\r\n  /// <param name=\"prmPtr\"></param>\r\n  /// <param name=\"style\"></param>\r\n  /// <param name=\"dwExStyle\"></param>\r\n  static OnCreateRichWindow(contextID: number, ctrlPtr: number, prmPtr: number, style: number, dwExStyle: number): void {\r\n    if (Events.CreateRichWindowEvent !== null) {\r\n      Events.CreateRichWindowEvent(contextID, ctrlPtr, prmPtr, style, dwExStyle);\r\n    }\r\n  }\r\n\r\n  ///<summary>\r\n  ///  Creates a window\r\n  ///</summary>\r\n  ///<param name=\"exStyle\">!!.</param>\r\n  ///<param name=\"className\">!!.</param>\r\n  ///<param name=\"windowName\">!!.</param>\r\n  ///<param name=\"style\">!!.</param>\r\n  ///<param name=\"x\">!!.</param>\r\n  ///<param name=\"y\">!!.</param>\r\n  ///<param name=\"width\">!!.</param>\r\n  ///<param name=\"height\">!!.</param>\r\n  ///<param name=\"hwndParent\">!!.</param>\r\n  ///<param name=\"hMenu\">!!.</param>\r\n  ///<param name=\"hInstance\">!!.</param>\r\n  ///<param name=\"lParam\">!!.</param>\r\n  ///<returns>handle of window</returns>\r\n  static OnCreateGuiWindow(exStyle: number, className: string, windowName: string, style: number, x: number, y: number, width: number, height: number, hwndParent: number, hMenu: number, hInstance: number, lParam: number): number {\r\n    let retValue: number = 0;\r\n    if (Events.CreateGuiWindowEvent !== null) {\r\n      retValue = Events.CreateGuiWindowEvent(exStyle, className, windowName, style, x, y, width, height, hwndParent, hMenu, hInstance, lParam);\r\n    }\r\n    return retValue;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Destroys a window\r\n  /// </summary>\r\n  /// <param name=\"hWndPtr\">handle of window</param>\r\n  static OnDestroyGuiWindow(hWndPtr: number): void {\r\n    if (Events.DestroyGuiWindowEvent !== null) {\r\n      Events.DestroyGuiWindowEvent(hWndPtr);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// OnClose Print Preview\r\n  /// </summary>\r\n  /// <param name=\"hWndPtr\">print preview data</param>\r\n  static OnPrintPreviewClose(printPreviewDataPtr: number): void {\r\n    if (Events.PrintPreviewCloseEvent !== null) {\r\n      Events.PrintPreviewCloseEvent(printPreviewDataPtr);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Show Print Dialog\r\n  /// </summary>\r\n  /// <param name=\"gpd\"></param>\r\n  static OnShowPrintDialog(gpd: number): number {\r\n    let retValue: number = 0;\r\n    if (Events.ShowPrintDialogEvent !== null) {\r\n      retValue = Events.ShowPrintDialogEvent(gpd);\r\n    }\r\n    return retValue;\r\n  }\r\n\r\n  /// <summary> displaySessionStatistics </summary>\r\n  static DisplaySessionStatistics(): void {\r\n    if (Events.DisplaySessionStatisticsEvent !== null) {\r\n      Events.DisplaySessionStatisticsEvent();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns true for non interactive task for all controls except a button control\r\n  /// </summary>\r\n  /// <param name=\"ctrl\">clicked control</param>\r\n  /// <returns></returns>\r\n  static ShouldBlockMouseEvents(ctrl: GuiMgControl): boolean {\r\n    return Events.ShouldBlockMouseEventsEvent !== null && Events.ShouldBlockMouseEventsEvent(ctrl);\r\n  }\r\n\r\n  /// <summary>peekEndOfWork</summary>\r\n  /// <returns></returns>\r\n  static PeekEndOfWork(): boolean {\r\n    return Events.PeekEndOfWorkEvent !== null && Events.PeekEndOfWorkEvent();\r\n  }\r\n\r\n  /// <summary>invokes the GetEventTime delegate</summary>\r\n  /// <returns></returns>\r\n  static GetEventTime(): number {\r\n    return (Events.GetEventTimeEvent !== null) ? Events.GetEventTimeEvent() : 0;\r\n  }\r\n\r\n  /// <summary>\r\n  /// invokes the ScrollTable Event\r\n  /// </summary>\r\n  /// <param name=\"guiMgObject\"></param>\r\n  /// <param name=\"line\"></param>\r\n  /// <param name=\"rowsToScroll\"></param>\r\n  /// <param name=\"isPageScroll\">next/prev page?</param>\r\n  /// <param name=\"isTableScroll\">Begin/End Table?</param>\r\n  /// <param name=\"isRaisedByMouseWheel\">indicates whether event is raised by mousewheel or not.</param>\r\n  static OnScrollTable(guiMgObject: any, line: number, rowsToScroll: number, isPageScroll: boolean, isTableScroll: boolean, isRaisedByMouseWheel: boolean): boolean {\r\n    let handled: boolean = false;\r\n    if (Events.ScrollTableEvent !== null) {\r\n      handled = Events.ScrollTableEvent(guiMgObject, line, rowsToScroll, isPageScroll, isTableScroll, isRaisedByMouseWheel);\r\n    }\r\n    return handled;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets the user defined Drop formats\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  /// <returns></returns>\r\n  static GetDropUserFormats(): string {\r\n    Debug.Assert(Events.GetDropUserFormatsEvent !== null);\r\n    return Events.GetDropUserFormatsEvent();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the context id from GuiMgForm\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <returns></returns>\r\n  static GetContextID(guiMgForm: GuiMgForm): number {\r\n    let contextID: number = -1;\r\n    Debug.Assert(guiMgForm !== null);\r\n    if (Events.GetContextIDEvent !== null) {\r\n      contextID = Events.GetContextIDEvent(guiMgForm);\r\n    }\r\n    return contextID;\r\n  }\r\n\r\n  /// <summary>\r\n  /// SetModal event\r\n  /// </summary>\r\n  /// <param name=\"currForm\"></param>\r\n  /// <param name=\"on\"></param>\r\n  static SetModal(mgForm: MgFormBase, on: boolean): void {\r\n    if (Events.SetModalEvent !== null) {\r\n      Events.SetModalEvent(mgForm, on);\r\n    }\r\n  }\r\n\r\n  /// <summary> </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <returns></returns>\r\n  static OnShowForm(guiMgForm: GuiMgForm): void {\r\n    if (Events.ShowFormEvent !== null) {\r\n      Events.ShowFormEvent(guiMgForm);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// invokes OnFormActivateEvent\r\n  /// </summary>\r\n  static OnFormActivate(guiMgForm: GuiMgForm): void {\r\n    if (Events.OnFormActivateEvent !== null) {\r\n      Events.OnFormActivateEvent(guiMgForm);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// invokes OnNCActivate\r\n  /// </summary>\r\n  static OnNCActivate(guiMgForm: GuiMgForm): void {\r\n    if (Events.OnNCActivateEvent !== null) {\r\n      Events.OnNCActivateEvent(guiMgForm);\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// Handle WM_KEYUP - (required only for ACT_NEXT_RT_WINDOW, ACT_PREV_RT_WINDOW for sorting windowlist\r\n  /// when the key associated with the action is released)\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"keyCode\">keycode of a key which is just released</param>\r\n  static HandleKeyUpMessage(guiMgForm: GuiMgForm, keyCode: number): void {\r\n    if (Events.HandleKeyUpMessageEvent !== null) {\r\n      Events.HandleKeyUpMessageEvent(guiMgForm, keyCode);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// checks whether we should show Logon window in RTOL format or not.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static IsLogonRTL(): boolean {\r\n    let isRTL: boolean = false;\r\n    if (Events.OnIsLogonRTLEvent !== null) {\r\n      isRTL = Events.OnIsLogonRTLEvent();\r\n    }\r\n    return isRTL;\r\n  }\r\n\r\n  static IsSpecialEngLogon(): boolean {\r\n    let isEngLogon: boolean = false;\r\n    if (Events.OnIsSpecialEngLogonEvent !== null) {\r\n      isEngLogon = Events.OnIsSpecialEngLogonEvent();\r\n    }\r\n    return isEngLogon;\r\n  }\r\n\r\n  static IsSpecialIgnoreButtonFormat(): boolean {\r\n    let isIgnoreButtonFormat: boolean = false;\r\n    if (Events.OnIsSpecialIgnoreButtonFormatEvent !== null) {\r\n      isIgnoreButtonFormat = Events.OnIsSpecialIgnoreButtonFormatEvent();\r\n    }\r\n    return isIgnoreButtonFormat;\r\n  }\r\n\r\n  /// <summary> invokes the getMainProgram Event </summary>\r\n  /// <param name=\"contextID\">active/target context</param>\r\n  /// <param name=\"ctlIdx\"></param>\r\n  /// <returns></returns>\r\n  static GetMainProgram(contextID: number, ctlIdx: number): GuiTaskBase {\r\n    Debug.Assert(Events.GetMainProgramEvent !== null);\r\n    return Events.GetMainProgramEvent(contextID, ctlIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Logical name translation\r\n  /// </summary>\r\n  /// <param name=\"fromString\">source string</param>\r\n  /// <returns>translated string</returns>\r\n  static TranslateLogicalName(fromString: string): string {\r\n    Debug.Assert(Events.TranslateLogicalNameEvent !== null);\r\n    return Events.TranslateLogicalNameEvent(fromString);\r\n  }\r\n\r\n  /// <summary>invokes getMessageString Event</summary>\r\n  /// <param name=\"msgId\"></param>\r\n  /// <returns></returns>\r\n  static GetMessageString(msgId: string): string {\r\n    Debug.Assert(Events.GetMessageStringEvent !== null);\r\n    let fromString: string = Events.GetMessageStringEvent(msgId);\r\n    let text: string = Events.Translate(fromString);\r\n    if (text !== null && text.endsWith(\":\")) {\r\n      let str: StringBuilder;\r\n      str = new StringBuilder(text);\r\n      str.Insert(text.length, \" \");\r\n      text = str.ToString();\r\n    }\r\n    return text;\r\n  }\r\n\r\n  /// <summary>raises CtrlFocusEvent</summary>\r\n  /// <returns></returns>\r\n  static OnCtrlFocus(iTask: ITask, ctrl: GuiControlPropertyAdapter): void {\r\n    if (Events.CtrlFocusEvent !== null) {\r\n      Events.CtrlFocusEvent(iTask, <MgControlBase>ctrl);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets the RuntimeContextBase that belongs to the contextID\r\n  /// </summary>\r\n  /// <param name=\"contextID\"></param>\r\n  /// <returns></returns>\r\n  static GetRuntimeContext(contextID: string): RuntimeContextBase {\r\n    Debug.Assert(Events.GetRuntimeContextEvent !== null);\r\n    return Events.GetRuntimeContextEvent(contextID);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Saves the name of the last clicked control.\r\n  /// </summary>\r\n  /// <param name=\"guiMgControl\">guiMgControl</param>\r\n  /// <param name=\"controlName\">Name of the control</param>\r\n  static SaveLastClickedCtrlName(guiMgControl: GuiMgControl, controlName: string): void {\r\n    if (Events.SaveLastClickedCtrlEvent !== null) {\r\n      Events.SaveLastClickedCtrlEvent( controlName);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Saves the last clicked information. (i.e. Co-ordinates and control name.\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\">guiMgForm</param>\r\n  /// <param name=\"controlName\">name of the control</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\">co-ordinates are in pixel or not.</param>\r\n  static SaveLastClickInfo(guiMgForm: GuiMgForm, controlName: string, x: number, y: number, offsetX: number, offsetY: number, lastClickCoordinatesAreInPixels: boolean): void {\r\n    if (Events.SaveLastClickInfoEvent !== null) {\r\n      Events.SaveLastClickInfoEvent( controlName, x, y, offsetX, offsetY, lastClickCoordinatesAreInPixels);\r\n    }\r\n  }\r\n\r\n  /// <summary>write an error message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteErrorToLog(msg: string): void {\r\n    Debug.Assert(Events.WriteErrorToLogEvent !== null);\r\n    Events.WriteErrorToLogEvent(msg);\r\n  }\r\n\r\n  static WriteExceptionToLog(msg: string): void;\r\n  static WriteExceptionToLog(ex: Exception): void;\r\n  static WriteExceptionToLog(msgOrEx: any): void {\r\n    if (arguments.length === 1 && (msgOrEx === null || msgOrEx.constructor === String)) {\r\n      Events.WriteExceptionToLog_0(msgOrEx);\r\n      return;\r\n    }\r\n    Events.WriteExceptionToLog_1(msgOrEx);\r\n  }\r\n\r\n  private static WriteExceptionToLog_0(msg: string): void {\r\n    Debug.Assert(Events.WriteErrorToLogEvent !== null);\r\n    Events.WriteErrorToLogEvent(msg);\r\n  }\r\n\r\n  private static WriteExceptionToLog_1(ex: Exception): void {\r\n    Events.WriteExceptionToLog(NString.Format(\"{0} : {1}{2}{3}{4}\", [\r\n      ex.GetType(), OSEnvironment.EolSeq, ex.StackTrace, OSEnvironment.EolSeq, ex.Message\r\n    ]));\r\n  }\r\n\r\n  /// <summary>write a warning message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteWarningToLog(msg: string): void;\r\n  static WriteWarningToLog(ex: Exception): void;\r\n  static WriteWarningToLog(msgOrEx: any): void {\r\n    if (arguments.length === 1 && (msgOrEx === null || msgOrEx.constructor === String)) {\r\n      Events.WriteWarningToLog_0(msgOrEx);\r\n      return;\r\n    }\r\n    Events.WriteWarningToLog_1(msgOrEx);\r\n  }\r\n\r\n  private static WriteWarningToLog_0(msg: string): void {\r\n    Debug.Assert(Events.WriteWarningToLogEvent !== null);\r\n    Events.WriteWarningToLogEvent(msg);\r\n  }\r\n\r\n  private static WriteWarningToLog_1(ex: Exception): void {\r\n    Events.WriteWarningToLog(ex.GetType() + \" : \" + OSEnvironment.EolSeq + ex.StackTrace + OSEnvironment.EolSeq + ex.Message);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"logLevel\"></param>\r\n  /// <returns></returns>\r\n  static ShouldLog(logLevel: Logger_LogLevels): boolean {\r\n    Debug.Assert(Events.ShouldLogEvent !== null);\r\n    return Events.ShouldLogEvent(logLevel);\r\n  }\r\n\r\n  /// <summary>write a GUI message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteGuiToLog(msg: string): void {\r\n    Debug.Assert(Events.WriteGuiToLogEvent !== null);\r\n    Events.WriteGuiToLogEvent(\"GUI: \" + msg);\r\n  }\r\n\r\n  /// <summary>write a DEV message to the internal log file</summary>\r\n  /// <param name=\"msg\"></param>\r\n  static WriteDevToLog(msg: string): void {\r\n    Debug.Assert(Events.WriteDevToLogEvent !== null);\r\n    Events.WriteDevToLogEvent(msg);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Called when WM_CLEAR message is received\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static OnClear(ctrl: GuiMgControl): void {\r\n      if (Events.ClearEvent !== null) {\r\n          Events.ClearEvent(ctrl);\r\n      }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Called when WM_UNDO message is received\r\n  /// </summary>\r\n  /// <param name=\"ctrl\"></param>\r\n  static OnUndo(ctrl: GuiMgControl): void {\r\n      if (Events.UndoEvent !== null) {\r\n          Events.UndoEvent(ctrl);\r\n      }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Should Enter be added as keyboard event ? This is important mostly in determining if a click event\r\n  /// will be raised for a default button or not.\r\n  /// Adding Enter as a keyboard event will not raise click on default button.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static AddEnterAsKeyEvent(): boolean {\r\n    return Events.ShouldAddEnterAsKeyEvent !== null && Events.ShouldAddEnterAsKeyEvent();\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  static ShowSessionStatisticsForm(): void {\r\n    if (Events.ShowSessionStatisticsEvent !== null) {\r\n      Events.ShowSessionStatisticsEvent();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Called when WM_COPYDATA message is received\r\n  /// </summary>\r\n  /// <param name=\"guiMgForm\"></param>\r\n  /// <param name=\"copyData\"></param>\r\n  static OnCopyData(guiMgForm: GuiMgForm, copyData: number): void {\r\n    if (Events.CopyDataEvent !== null) {\r\n      Events.CopyDataEvent(guiMgForm, copyData);\r\n    }\r\n  }\r\n\r\n  constructor() {\r\n  }\r\n}\r\n"]}