@magic-xpa/engine 4.1100.0-dev4110.106 → 4.1100.0-dev4110.109

package/src/rt/IDataSourceViewDefinition.d.ts

@@ -0,0 +1,6 @@
+import { Order } from "@magic-xpa/utils";
+export interface IDataSourceViewDefinition {
+    RecordsOrder: Order;
+    CanInsert: boolean;
+    CanDelete: boolean;
+}

package/src/rt/IDataviewHeader.d.ts

@@ -0,0 +1,10 @@
+import { IDataSourceViewDefinition } from "./IDataSourceViewDefinition";
+import { LnkEval_Cond, LnkMode } from "@magic-xpa/utils";
+export interface IDataviewHeader extends IDataSourceViewDefinition {
+    Id: number;
+    IsMainSource: boolean;
+    Mode: LnkMode;
+    LinkStartAfterField: number;
+    LinkEvaluateCondition: LnkEval_Cond;
+    EvaluateLinkCondition(): boolean;
+}

package/src/rt/IResultValue.d.ts

@@ -0,0 +1,4 @@
+import { StorageAttribute } from "@magic-xpa/utils";
+export interface IResultValue {
+    SetResultValue(result: string, type: StorageAttribute): void;
+}

package/src/rt/LastFocusedManager.d.ts

@@ -0,0 +1,23 @@
+import { ITask, MgControlBase } from "@magic-xpa/gui";
+import { MgControl } from "../gui/MgControl";
+import { TaskBase } from "../tasks/TaskBase";
+import { Task } from "../tasks/Task";
+import { MGDataCollection } from "../tasks/MGDataCollection";
+export declare class LastFocusedManager {
+    static Instance: LastFocusedManager;
+    private static _lastFocusedControls;
+    static LastFocusMgdID: number;
+    private _lastFocusedTasks;
+    LastActionTime: number;
+    Init(mgDataTable: MGDataCollection): void;
+    getCurrTask(): Task;
+    getLastFocusedTask(mgdID?: number): Task;
+    setLastFocusedTask(iTask: ITask): void;
+    clean(index: number): void;
+    static getLastFocusedControl(mgdID?: number): MgControl;
+    private static getLastFocusedControl_0;
+    private static getLastFocusedControl_1;
+    static deleteLastFocusedControlAt(index: number): void;
+    static setLastFocusedControlAt(ctrl: MgControlBase, currMgdID: number): void;
+    static setLastFocusedControl(task: TaskBase, mgControl: MgControlBase): void;
+}

package/src/rt/Operation.d.ts

@@ -0,0 +1,97 @@
+import { List, StringBuilder } from '@magic-xpa/mscorelib';
+import { CallOperationMode, XmlParser } from '@magic-xpa/utils';
+import { TaskDefinitionId } from '@magic-xpa/gui';
+import { ArgumentsList } from './ArgumentsList';
+import { EventHandler } from '../event/EventHandler';
+import { Field } from '../data/Field';
+import { RunTimeEvent } from '../event/RunTimeEvent';
+import { Task } from '../tasks/Task';
+export declare class Operation {
+    private _condExp;
+    private _retainFocus;
+    private _waitExp;
+    private _syncData;
+    private _argList;
+    private _blockClose;
+    private _blockEnd;
+    private _buttons;
+    private _checkByServer;
+    private _cmdToServer;
+    private _display;
+    private _errLogAppend;
+    private _evtHandler;
+    private _execOnServer;
+    private _execOnClient;
+    private _exp;
+    private _field;
+    private _image;
+    private _incremental;
+    private _mode;
+    private _publicName;
+    private _returnVal;
+    private _rtEvt;
+    private _serverId;
+    private calledTaskDefinitionId;
+    private _subformCtrlName;
+    private _subtype;
+    private _task;
+    private _text;
+    private _title;
+    private _titleExp;
+    private _type;
+    private _undo;
+    private _isRoute;
+    private _routerPath;
+    private _originalRouterOutletName;
+    private _routeParams;
+    constructor();
+    get CalledTaskDefinitionId(): TaskDefinitionId;
+    OperCallMode: CallOperationMode;
+    set Task(value: Task);
+    get Task(): Task;
+    private Immediate;
+    fillData(taskRef: Task, evtHandler: EventHandler, parser: XmlParser): void;
+    private initInnerObjects;
+    private fillAttributes;
+    private initElements;
+    InitTaskDefinitionID(parser: XmlParser): void;
+    private SetTaskDefinitionId;
+    static InitField(valueStr: string, task: Task): Field;
+    execute(returnedFromServer: boolean): Promise<boolean>;
+    private operCallParallel;
+    static callParallel(): void;
+    private getCondVal;
+    getType(): number;
+    getRouteParams(): List<any>;
+    getServerId(): number;
+    private operVerify;
+    static getButtons(buttonsID: string): number;
+    static getImage(imageID: string): number;
+    static setoperVerifyReturnValue(returnValue: number, returnVal: Field): Promise<void>;
+    private operBlock;
+    private operElse;
+    private operEvaluate;
+    private operUpdate;
+    private CanModify;
+    static operUpdateVectors(field: Field, vec: string): string;
+    private operRaiseEvent;
+    private operCall;
+    operServer(mprgCreator: Task): Promise<void>;
+    getBlockEnd(): number;
+    setBlockEnd(val: number): void;
+    getBlockClose(): number;
+    setBlockClose(val: number): void;
+    getTaskTag(): string;
+    getHandlerId(): string;
+    getEventHandler(): EventHandler;
+    getExecOnServer(): boolean;
+    setExecOnServer(val: boolean): void;
+    getExecOnClient(): boolean;
+    private canExecute;
+    AddFlowDescription(buffer: StringBuilder): Promise<void>;
+    GetArgList(): ArgumentsList;
+    GetReturnValueField(): Field;
+    GetSubformControlName(): string;
+    toString(): string;
+    GetRuntimeEvent(): RunTimeEvent;
+}

package/src/rt/OperationTable.d.ts

@@ -0,0 +1,15 @@
+import { XmlParser } from "@magic-xpa/utils";
+import { Operation } from "./Operation";
+import { EventHandler } from "../event/EventHandler";
+import { Task } from "../tasks/Task";
+export declare class OperationTable {
+    private _operations;
+    private _firstBlockOperIdx;
+    constructor();
+    fillData(taskRef: Task, evtHandler: EventHandler, parser: XmlParser): void;
+    private initInnerObjects;
+    getSize(): number;
+    getOperation(idx: number): Operation;
+    serverId2operIdx(id: number, startFrom: number): number;
+    serverId2FollowingOperIdx(id: number, startFrom: number): number;
+}

package/src/rt/Recompute.d.ts

@@ -0,0 +1,41 @@
+import { FieldBase } from "../data/FieldBase";
+import { Task } from "../tasks/Task";
+import { XmlParser } from "@magic-xpa/utils";
+import { Record } from "../data/Record";
+import { DataView } from "../data/DataView";
+export declare enum Recompute_RcmpBy {
+    CLIENT = "C",
+    SERVER_ON_CHANGE = "O"
+}
+export declare class Recompute {
+    private _ctrlProps;
+    private _formProps;
+    private _isOwnerFld;
+    OwnerFld: FieldBase;
+    private _rcmpOrder;
+    private _subForms;
+    private _subFormsOnlyRecomp;
+    private _hasServerLinksRecomputes;
+    RcmpMode: Recompute_RcmpBy;
+    Task: Task;
+    constructor();
+    fillData(dataView: DataView, taskRef: Task, parser: XmlParser): void;
+    private initInnerObjects;
+    private AddRecomputeItem;
+    private fillLink;
+    private fillFldField;
+    private initElements;
+    execute(rec: Record): Promise<void>;
+    private RefreshSubforms;
+    private SetSubformsInRecompute;
+    private fldRcmp;
+    private buildSubFormList;
+    RemoveSubform(subformTask: Task): void;
+    AddSubform(subformTask: Task): void;
+    private recSuffixSubForms;
+    private checkRefreshSubForms;
+    private GetSubformsToRefresh;
+    private recPrefixSubForms;
+    notifyServerOnChange(): boolean;
+    isServerRcmp(): boolean;
+}

package/src/rt/RecomputeTable.d.ts

@@ -0,0 +1,9 @@
+import { XmlParser } from "@magic-xpa/utils";
+import { Task } from "../tasks/Task";
+import { DataView } from "../data/DataView";
+export declare class RecomputeTable {
+    private fillAttributes;
+    fillData(parser: XmlParser): void;
+    fillData_1(dataView: DataView, task: Task, parser: XmlParser): void;
+    private initInnerObjects;
+}

package/src/rt/RemoteDataviewHeader.d.ts

@@ -0,0 +1,14 @@
+import { DataviewHeaderBase } from "./DataviewHeaderBase";
+import { Task } from "../tasks/Task";
+import { Record } from "../data/Record";
+export declare class RemoteDataviewHeader extends DataviewHeaderBase {
+    private _table;
+    private _lastFetchRecPos;
+    constructor(task: Task);
+    protected setAttribute(attribute: string, valueStr: string): void;
+    getLinkedRecord(curRec: Record): Promise<boolean>;
+    private copyLinkFldToRec;
+    private initRec;
+    getLastFetchedDbPos(): string;
+    SetReturnValue(ret: boolean, recompute: boolean): Promise<void>;
+}

package/src/rt/ResultValue.d.ts

@@ -0,0 +1,7 @@
+import { IResultValue } from "./IResultValue";
+import { StorageAttribute } from "@magic-xpa/utils";
+export declare class ResultValue implements IResultValue {
+    Value: string;
+    Type: StorageAttribute;
+    SetResultValue(result: string, type: StorageAttribute): void;
+}

package/src/rt/TableCache.d.ts

@@ -0,0 +1,29 @@
+import { List } from "@magic-xpa/mscorelib";
+import { Key } from "../data/Key";
+import { FieldsTableExt as FieldsTable } from "../data/FieldsTable";
+import { Record } from "../data/Record";
+import { Boundary } from "./Boundary";
+export declare class TableCache {
+    private _keys;
+    private _records;
+    private _currSortDir;
+    private _currSortKey;
+    FldsTab: FieldsTable;
+    private _isLoaded;
+    private _tableIdent;
+    private _tableUId;
+    constructor(tableId: string);
+    SetTableIdent(ident: string): void;
+    FillData(): void;
+    private FillAttributes;
+    private InitInnerObjects;
+    GetTableUniqueId(): string;
+    GetTableCommonIdentifier(): string;
+    GetCurrSortKey(): number;
+    GetKeyById(keyId: number): Key;
+    private Load;
+    SortTable(sortKeyId: number, sortDir: string): Promise<void>;
+    Fetch(loc: List<Boundary>): Record;
+    private static validateRec;
+    protected ReverseVector(array: Object[]): void;
+}

package/src/rt/TableCacheManager.d.ts

@@ -0,0 +1,10 @@
+import { TableCache } from './TableCache';
+export declare class TableCacheManager {
+    private _tables;
+    static Instance: TableCacheManager;
+    private constructor();
+    GetTableById(tableUId: string): TableCache;
+    TableExists(tableUId: string): boolean;
+    InsertTable(table: TableCache): boolean;
+    LoadTable(tableUId: string): Promise<void>;
+}

package/src/rt/Transaction.d.ts

@@ -0,0 +1,23 @@
+import { Task } from "../tasks/Task";
+import { TaskBase } from "../tasks/TaskBase";
+export declare class Transaction {
+    private _transId;
+    private _afterTransRetry;
+    private _transBegin;
+    Opened: boolean;
+    OwnerTask: Task;
+    constructor(task: TaskBase, setTransId: string);
+    isOwner(task: Task): boolean;
+    close(): void;
+    open(): void;
+    isOpened(): boolean;
+    setAfterRetry(val: string): void;
+    getAfterRetry(): boolean;
+    getAfterRetry(recovery: string): boolean;
+    private getAfterRetry_0;
+    private getAfterRetry_1;
+    getLevel(): string;
+    setTransBegin(val: string): void;
+    getTransId(): string;
+    setOwnerTask(task: Task): void;
+}

package/src/security/UserDetails.d.ts

@@ -0,0 +1,16 @@
+import { XmlParser } from '@magic-xpa/utils';
+export declare class UserDetails {
+    private static _instance;
+    UserName: string;
+    UserID: string;
+    UserInfo: string;
+    Password: string;
+    IsLoggedIn: boolean;
+    private setIsLoggedIn;
+    getIsLoggedIn(): boolean;
+    private setUserID;
+    static get Instance(): UserDetails;
+    constructor();
+    fillData(parser: XmlParser): void;
+    private initElements;
+}

package/src/tasks/IMGDataCollection.d.ts

@@ -0,0 +1,26 @@
+import { List, StringBuilder } from "@magic-xpa/mscorelib";
+import { IMGDataTable, ITask, MgFormBase } from "@magic-xpa/gui";
+import { MGData } from "./MGData";
+import { TaskBase } from "./TaskBase";
+import { IClientCommand } from "../commands/IClientCommand";
+import { CommandsTable } from "../CommandsTable";
+import { Expression } from "../exp/Expression";
+export interface IMGDataCollection extends IMGDataTable {
+    currMgdID: number;
+    StartupMgData: MGData;
+    getMGData(idx: number): MGData;
+    getTaskIdById(taskId: string): string;
+    getSize(): number;
+    getMGData(idx: number): MGData;
+    startTasksIteration(): void;
+    getNextTask(): ITask;
+    GetTopMostForms(): List<MgFormBase>;
+    getCurrMGData(): MGData;
+    GetMGDataForStartupProgram(): MGData;
+    getTriggeredTasks(triggeringTask: TaskBase): List<TaskBase>;
+    getAvailableIdx(): number;
+    addMGData(mgd: MGData, idx: number, isStartup: boolean): void;
+    buildXML(message: StringBuilder, serializeTasks: boolean): void;
+    processRecovery(): void;
+    execRequestWithSubformRecordCycle(cmdsToServer: CommandsTable, cmdToServer: IClientCommand, exp: Expression): Promise<void>;
+}

package/src/tasks/MGData.d.ts

@@ -0,0 +1,63 @@
+import { HandlersTable } from "../rt/HandlersTable";
+import { ICommandsTable } from "../ICommandsTable";
+import { Task } from "./Task";
+import { OpeningTaskDetails } from "./TaskBase";
+import { XmlParser } from "@magic-xpa/utils";
+import { List, StringBuilder } from "@magic-xpa/mscorelib";
+import { TaskDefinitionId } from "@magic-xpa/gui";
+import { EventHandler } from "../event/EventHandler";
+export declare class MGData {
+    private _expHandlers;
+    private _id;
+    private _parent;
+    private _mprgTab;
+    private _tasksTab;
+    private _timerHandlers;
+    private _timersStarted;
+    private forceModal;
+    CmdsToClient: ICommandsTable;
+    CmdsToServer: ICommandsTable;
+    IsModal: boolean;
+    IsAborting: boolean;
+    get ForceModal(): boolean;
+    constructor(toClient: ICommandsTable, toServer: ICommandsTable, id: number, parent: MGData, isModal: boolean);
+    constructor(toClient: ICommandsTable, toServer: ICommandsTable, id: number, parent: MGData, isModal: boolean, forceModal: boolean);
+    private constructor_0;
+    private constructor_1;
+    GetId(): number;
+    AlreadyMovedToFirstControl(): boolean;
+    StartTimers(): void;
+    fillData(openingTaskDetails: OpeningTaskDetails, parser: XmlParser): Promise<void>;
+    private initInnerObjects;
+    private insertDataView;
+    addTask(newTask: Task): void;
+    removeTask(task: Task): void;
+    getTasksCount(): number;
+    getTask(taskId: string): Task;
+    getTask(idx: number): Task;
+    private getTask_0;
+    private getTask_1;
+    buildXML(message: StringBuilder, serializeTasks: boolean): Promise<void>;
+    getFirstTask(): Task;
+    getMainProg(ctlIdx: number): Task;
+    getNextMainProg(ctlIdx: number): Task;
+    clientTransactionCacheExists(): boolean;
+    serverTransactionCacheExists(): boolean;
+    getTaskByTaskDefinitionID(taskDefinitionID: TaskDefinitionId): Task;
+    getTimerHandlers(): HandlersTable;
+    addTimerHandler(handler: EventHandler): void;
+    removeTimerHandler(task: Task): void;
+    removeExpressionHandler(task: Task): void;
+    getExpHandlers(): HandlersTable;
+    addExpHandler(handler: EventHandler, idx: number): void;
+    changeTimers(oldTimers: List<number>, newTimers: List<number>): void;
+    private fillEventsQueue;
+    private initEvents;
+    isMainWindow(): boolean;
+    getParentMGdata(): MGData;
+    abort(): void;
+    copyUnframedCmds(): void;
+    getValidAncestor(): MGData;
+    getMaxCtlIdx(): number;
+    fillGlobalParams(parser: XmlParser): void;
+}

package/src/tasks/MGDataCollection.d.ts

@@ -0,0 +1,42 @@
+import { List, StringBuilder } from "@magic-xpa/mscorelib";
+import { ITask, MgFormBase } from "@magic-xpa/gui";
+import { MGData } from "./MGData";
+import { Task } from "./Task";
+import { IMGDataCollection } from "./IMGDataCollection";
+import { CommandsTable } from "../CommandsTable";
+import { IClientCommand } from "../commands/IClientCommand";
+import { Expression } from "../exp/Expression";
+export declare class MGDataCollection implements IMGDataCollection {
+    private static _instance;
+    private _mgDataTab;
+    private _iteratorMgdIdx;
+    private _iteratorTaskIdx;
+    currMgdID: number;
+    StartupMgData: MGData;
+    private _lastRouteSentToServer;
+    constructor();
+    GetTaskByID(id: string): ITask;
+    static get Instance(): MGDataCollection;
+    addMGData(mgd: MGData, idx: number, isStartup: boolean): Promise<void>;
+    getMGData(idx: number): MGData;
+    getAvailableIdx(): number;
+    getMgDataIdx(mgd: MGData): number;
+    deleteMGDataTree(index: number): void;
+    getCurrMGData(): MGData;
+    GetMainProgByCtlIdx(contextIDOrCtlIdx: any, ctlIdx?: number): Task;
+    private GetMainProgByCtlIdx_0;
+    private GetMainProgByCtlIdx_1;
+    startTasksIteration(): void;
+    getNextTask(): ITask;
+    buildXML(message: StringBuilder, serializeTasks: boolean): Promise<void>;
+    getSize(): number;
+    processRecovery(): Promise<void>;
+    getTriggeredTasks(triggeringTask: Task): List<Task>;
+    GetTasks(p: (obj: Task) => boolean): List<Task>;
+    getTaskIdById(taskId: string): string;
+    GetTopMostForms(): List<MgFormBase>;
+    GetMGDataForStartupProgram(): MGData;
+    execRequestWithSubformRecordCycle(cmdsToServer: CommandsTable, cmdToServer: IClientCommand, exp: Expression): Promise<void>;
+    cleanDoSubformPrefixSuffix(): void;
+    execAllSubformRecordCycle(): Promise<void>;
+}

package/src/tasks/RCTimer.d.ts

@@ -0,0 +1,13 @@
+import { MgTimer } from '@magic-xpa/gui';
+import { MGData } from './MGData';
+export declare class RCTimer extends MgTimer {
+    private _mgData;
+    private _isIdle;
+    get TimerIntervalMiliSeconds(): number;
+    set IsIdleTimer(value: boolean);
+    get IsIdleTimer(): boolean;
+    constructor(mgData: MGData, milliseconds: number, isIdle: boolean);
+    GetMgdata(): MGData;
+    static StopTimer(mgData: MGData, milliseconds: number, isIdle: boolean): void;
+    static StopAll(mgData: MGData): void;
+}

package/src/tasks/RemoteTaskService.d.ts

@@ -0,0 +1,16 @@
+import { TaskServiceBase } from './TaskServiceBase';
+import { DataviewManagerBase } from '../data/DataviewManagerBase';
+import { ReturnResult } from '../util/ReturnResult';
+import { Task } from './Task';
+export declare class RemoteTaskService extends TaskServiceBase {
+    constructor();
+    GetTaskTag(defaultValue: string): string;
+    GetDataviewManagerForVirtuals(task: Task): DataviewManagerBase;
+    PrepareTask(task: Task): ReturnResult;
+    GetEventTaskId(originalTaskId: string): string;
+    ShouldEvaluatePropertyLocally(propId: number): boolean;
+    InitTaskPrefixExecutedFlag(task: Task): void;
+    RemoveRecomputes(parentTask: Task): void;
+    GetOwnerTransactionTask(task: Task): Task;
+    static PreparePropMainDisplay(task: Task): Promise<ReturnResult>;
+}