declare namespace OS { /** * This namespace is dedicated to everything related to the * global system settings */ namespace setting { /** * User setting type definition * * @export * @interface UserSettingType */ interface UserSettingType { /** * User full name * * @type {string} * @memberof UserSettingType */ name: string; /** * User name * * @type {string} * @memberof UserSettingType */ username: string; /** * User id * * @type {number} * @memberof UserSettingType */ id: number; /** * User groups * * @type {{ [index: number]: string }} * @memberof UserSettingType */ group?: { [index: number]: string; }; [propName: string]: any; } /** * Virtual desktop setting data type * * @export * @interface DesktopSettingType */ interface DesktopSettingType { /** * Desktop VFS path * * @type {string} * @memberof DesktopSettingType */ path: string; /** * Desktop menu, can be added automatically by applications * * @type {GUI.BasicItemType[]} * @memberof DesktopSettingType */ menu: GUI.BasicItemType[]; /** * Show desktop hidden files * * @type {boolean} * @memberof DesktopSettingType */ showhidden: boolean; [propName: string]: any; } /** * Wallpaper setting data type * * @export * @interface WPSettingType */ interface WPSettingType { /** * Repeat wallpaper: * - `repeat` * - `repeat-x` * - `repeat-y` * - `no-repeat` * * @type {string} * @memberof WPSettingType */ repeat: string; /** * Wallpaper size * - `contain` * - `cover` * - `auto` * * @type {string} * @memberof WPSettingType */ size: string; /** * VFS path to the wallpaper image * * @type {string} * @memberof WPSettingType */ url: string; } /** * Theme setting data type * * @export * @interface ThemeSettingType */ interface ThemeSettingType { /** * Theme name, this value is used for looking * theme file in system asset * * @type {string} * @memberof ThemeSettingType */ name: string; /** * Theme user-friendly text * * @type {string} * @memberof ThemeSettingType */ text: string; } /** * Appearance setting data type * * @export * @interface AppearanceSettingType */ interface AppearanceSettingType { /** * Current theme name * * @type {string} * @memberof AppearanceSettingType */ theme: string; /** * All themes available in the system * * @type {ThemeSettingType[]} * @memberof AppearanceSettingType */ themes: ThemeSettingType[]; /** * Current wallpaper setting * * @type {WPSettingType} * @memberof AppearanceSettingType */ wp: WPSettingType; /** * All wallpapers available in the system * * @type {string[]} * @memberof AppearanceSettingType */ wps: string[]; } /** * VFS Mount points setting data type * * @export * @interface VFSMountPointSettingType */ interface VFSMountPointSettingType { /** * Path to the mount point * * @type {string} * @memberof VFSMountPointSettingType */ path: string; /** * User friendly mount point name * * @type {string} * @memberof VFSMountPointSettingType */ text: string; [propName: string]: any; } /** * VFS setting data type * * @export * @interface VFSSettingType */ interface VFSSettingType { /** * mount points setting * * @type {VFSMountPointSettingType[]} * @memberof VFSSettingType */ mountpoints: VFSMountPointSettingType[]; [propName: string]: any; } /** * Global system setting data type * * @export * @interface SystemSettingType */ interface SystemSettingType { /** * System error report URL * * @type {string} * @memberof SystemSettingType */ error_report: string; /** * Current system locale e.g. `en_GB` * * @type {string} * @memberof SystemSettingType */ locale: string; /** * System menus * * @type {API.PackageMetaType[]} * @memberof API.PackageMetaType */ menu: API.PackageMetaType[]; /** * Packages meta-data * * @type {{ [index: string]: API.PackageMetaType }} * @memberof SystemSettingType */ packages: { [index: string]: API.PackageMetaType; }; /** * Path to the installed packages * * @type {{ * user: string; * system: string; * }} * @memberof SystemSettingType */ pkgpaths: { /** * User specific packages install location * * @type {string} */ user: string; /** * System packages install location * * @type {string} */ system: string; }; /** * Package repositories setting. * This configuration is used by [[MarketPlace]] * for package management * * @type {{ * text: string; * url: string; * }[]} * @memberof SystemSettingType */ repositories: { /** * Repository name * * @type {string} */ text: string; /** * Repository uri * * @type {string} */ url: string; }[]; /** * Startup applications and services * * @type {{ * apps: string[]; * services: string[]; * }} * @memberof SystemSettingType */ startup: { /** * List of application names * * @type {string[]} */ apps: string[]; /** * List of service names * * @type {string[]} */ services: string[]; /** * List of pinned applications * * @type {string[]} */ pinned: string[]; }; } /** * User settings */ var user: UserSettingType; /** * Application settings */ var applications: GenericObject; /** * Desktop settings */ var desktop: DesktopSettingType; /** * Appearance settings */ var appearance: AppearanceSettingType; /** * VFS settings */ var VFS: VFSSettingType; /** * System settings */ var system: SystemSettingType; } /** * Reset the system settings to default values * * @export */ function resetSetting(): void; /** * Apply the input parameter object to system settings. * This object could be an object loaded from * setting JSON file saved on the server. * * @export * @param {*} conf */ function systemSetting(conf: any): void; } declare namespace OS { namespace API { /** * Simple Virtual Database (VDB) application API. * * This API abstracts and provides a standard way to * connect to a server-side relational database (e.g. sqlite). * * Each user when connected has their own database previously * created. All VDB operations related to that user will be * performed on this database. * * The creation of user database need to be managed by the server-side API. * The VDB API assumes that the database already exist. All operations * is performed in tables level * * @export * @class DB */ class DB { /** * A table name on the user's database * * @private * @type {string} * @memberof DB */ private table; /** *Creates an instance of DB. * @param {string} table table name * @memberof DB */ constructor(table: string); /** * Save data to the current table. The input * data must conform to the table record format. * * On the server side, if the table doest not * exist yet, it should be created automatically * by inferring the data structure of the input * object * * @param {GenericObject} d data object represents a current table record * @returns {Promise} * @memberof DB */ save(d: GenericObject): Promise; /** * delete record(s) from the current table by * a conditional object * * @param {*} c conditional object, c can be: * * * a `number`: the operation will delete the record with `id = c` * * a `string`: The SQL string condition that selects record to delete * * a conditional object represents a SQL condition statement as an object, * example: `pid = 10 AND cid = 2` is represented by: * * ```typescript * { * exp: { * "and": { * pid: 10, * cid: 2 * } * } * ``` * * @returns {Promise} * @memberof DB */ delete(c: GenericObject | number | string): Promise; /** * Get a record in the table by its primary key * * @param {number} id the primary key value * @returns {Promise>} Promise on returned record data * @memberof DB */ get(id: number): Promise>; /** * Find records by a condition * * @param {GenericObject} cond conditional object * * a conditional object represents a SQL condition statement as an object, * example: `pid = 10 AND cid = 2 ORDER BY date DESC` is represented by: * * ```typescript * { * exp: { * "and": { * pid: 10, * cid: 2 * } * }, * order: { * date: "DESC" * } * } * ``` * @returns {Promise[]>} * @memberof DB */ find(cond: GenericObject): Promise[]>; } } } /// declare namespace OS { /** * This namespace is dedicated to application and service definition. * When an application is loaded, its prototype definition will be * inserted to this namespace for reuse lately */ namespace application { /** * Abstract prototype of all AntOS applications. * Any new application definition should extend * this prototype * * @export * @abstract * @class BaseApplication * @extends {BaseModel} */ abstract class BaseApplication extends BaseModel { /** * Placeholder of all settings specific to the application. * The settings stored in this object will be saved to system * setting when logout and can be reused in the next login session * * @type {GenericObject} * @memberof BaseApplication */ setting: GenericObject; /** * Hotkeys (shortcuts) defined for this application * * @protected * @type {GUI.ShortcutType} * @memberof BaseApplication */ protected keycomb: GUI.ShortcutType; /** * Reference to the system dock * * @type {GUI.tag.AppDockTag} * @memberof BaseApplication */ sysdock: GUI.tag.AppDockTag; /** * Reference to the system application menu located * on the system panel * * @type {GUI.tag.MenuTag} * @memberof BaseApplication */ appmenu: GUI.tag.MenuTag; /** *Creates an instance of BaseApplication. * @param {string} name application name * @param {AppArgumentsType[]} args application arguments * @memberof BaseApplication */ constructor(name: string, args: AppArgumentsType[]); /** * Init the application, this function is called when the * application process is created and docked in the application * dock. * * The application UI will be rendered after the execution * of this function. * * @returns {void} * @memberof BaseApplication */ init(): void; /** * Render the application UI by first loading its scheme * and then mount this scheme to the DOM tree * * @protected * @returns {void} * @memberof BaseApplication */ protected loadScheme(): void; /** * API function to perform an heavy task. * This function will trigger the global `loading` * event at the beginning of the task, and the `loaded` * event after finishing the task * * @protected * @param {Promise} promise the promise on a task to be performed * @returns {Promise} * @memberof BaseApplication */ protected load(promise: Promise): Promise; /** * Bind a hotkey to the application, this function * is used to define application keyboard shortcut * * @protected * @param {string} k the hotkey to bind, should be in the following * format: `[ALT|SHIFT|CTRL|META]-KEY`, e.g. `CTRL-S` * @param {(e: JQuery.KeyboardEventBase) => void} f the callback function * @returns {void} * @memberof BaseApplication */ protected bindKey(k: string, f: (e: JQuery.KeyboardEventBase) => void): void; /** * Update the application local from the system * locale or application specific locale configuration * * @private * @param {string} name locale name e.g. `en_GB` * @returns {void} * @memberof BaseApplication */ protected updateLocale(name: string): void; /** * Execute the callback subscribed to a * keyboard shortcut * * @param {string} fnk meta or modifier key e.g. `CTRL`, `ALT`, `SHIFT` or `META` * @param {string} c a regular key * @param {JQuery.KeyDownEvent} e JQuery keyboard event * @returns {boolean} return whether the shortcut is executed * @memberof BaseApplication */ shortcut(fnk: string, c: string, e: JQuery.KeyDownEvent): boolean; /** * Apply a setting to the application * * @protected * @param {string} k the setting name * @memberof BaseApplication */ protected applySetting(k: string): void; /** * Apply all settings to the application * * @protected * @memberof BaseApplication */ protected applyAllSetting(): void; /** * Set a setting value to the application setting * registry * * @protected * @param {string} k setting name * @param {*} v setting value * @returns {void} * @memberof BaseApplication */ protected registry(k: string, v: any): void; /** * Show the appliation * * @returns {void} * @memberof BaseApplication */ show(): void; /** * Blur the application * * @returns {void} * @memberof BaseApplication */ blur(): void; /** * Hide the application * * @returns {void} * @memberof BaseApplication */ hide(): void; /** * Maximize or restore the application window size * and its position * * @returns {void} * @memberof BaseApplication */ toggle(): void; /** * Get the application title * * @returns {(string| FormattedString)} * @memberof BaseApplication */ title(): string | FormattedString; /** * Function called when the application exit. * If the input exit event is prevented, the application * process will not be killed * * * @protected * @param {BaseEvent} evt exit event * @memberof BaseApplication */ protected onexit(evt: BaseEvent): void; /** * Get the application meta-data * * @returns {API.PackageMetaType} * @memberof BaseApplication */ meta(): API.PackageMetaType; /** * Base menu definition. This function * returns the based menu definition of all applications. * Other application specific menu entries * should be defined in [[menu]] function * * @protected * @returns {GUI.BasicItemType[]} * @memberof BaseApplication */ protected baseMenu(): GUI.BasicItemType[]; /** * The main application entry that is called after * the application UI is rendered. This application * must be implemented by all subclasses * * @abstract * @memberof BaseApplication */ abstract main(): void; /** * Application specific menu definition * * @protected * @returns {GUI.BasicItemType[]} * @memberof BaseApplication */ protected menu(): GUI.BasicItemType[]; /** * The cleanup function that is called by [[onexit]] function. * Application need to override this function to perform some * specific task before exiting or to prevent the application * to be exited * * @protected * @param {BaseEvent} e * @memberof BaseApplication */ protected cleanup(e: BaseEvent): void; } } } declare namespace OS { namespace API { /** * Observable entry type definition * * @export * @interface ObservableEntryType */ interface ObservableEntryType { /** * A Set of callbacks that should be called only once. * These callbacks will be removed after the first * occurrence of the corresponding event * * @memberof ObservableEntryType */ one: Set<(d: any) => void>; /** * A Set of callbacks that should be called * every time the corresponding event is triggered * * @memberof ObservableEntryType */ many: Set<(d: any) => void>; } /** * Announcement listener type definition * * @export * @interface AnnouncerListenerType */ interface AnnouncerListenerType { [index: number]: { /** * The event name * * @type {string} */ e: string; /** * The event callback * */ f: (d: any) => void; }[]; } /** * This class is the based class used in AntOS event * announcement system. * It implements the observer pattern using simple * subscribe/publish mechanism * @export * @class Announcer */ class Announcer { /** * The observable object that stores event name * and its corresponding callback in [[ObservableEntryType]] * * @type {GenericObject} * @memberof Announcer */ observable: GenericObject; /** * Enable/disable the announcer * * @type {boolean} * @memberof Announcer */ enable: boolean; /** *Creates an instance of Announcer. * @memberof Announcer */ constructor(); /** * Disable the announcer, when this function is called * all events and their callbacks will be removed * * @returns * @memberof Announcer */ disable(): boolean; /** * Subscribe to an event, the callback will be called * every time the corresponding event is trigged * * @param {string} evtName event name * @param {(d: any) => void} callback The corresponding callback * @returns {void} * @memberof Announcer */ on(evtName: string, callback: (d: any) => void): void; /** * Subscribe to an event, the callback will * be called only once and then removed from the announcer * * @param {string} evtName event name * @param {(d: any) => void} callback the corresponding callback * @returns {void} * @memberof Announcer */ one(evtName: string, callback: (d: any) => void): void; /** * Unsubscribe the callback from an event * * @param {string} evtName event name * @param {(d: any) => void} [callback] the callback to be unsubscribed. * When the `callback` is `*`, all callbacks related to `evtName` will be * removed * @memberof Announcer */ off(evtName: string, callback?: (d: any) => void): void; /** * Trigger an event * * @param {string} evtName event name * @param {*} data data object that will be send to all related callback * @returns {void} * @memberof Announcer */ trigger(evtName: string, data: any): void; } } /** * This namespace defines every thing related to the system announcement. * * The system announcement provides a global way to communicate between * processes (applications/services) using the subscribe/publish * mechanism */ namespace announcer { /** * The global announcer object that manages global events * and callbacks */ var observable: API.Announcer; /** * This variable is used to allocate the `id` of all messages * passing between publishers and subscribers in the * system announcement */ var quota: 0; /** * Placeholder of all global events listeners */ var listeners: API.AnnouncerListenerType; /** * Subscribe to a global event * * @export * @param {string} e event name * @param {(d: any) => void} f event callback * @param {GUI.BaseModel} a the process (Application/service) related to the callback */ function on(e: string, f: (d: any) => void, a: BaseModel): void; /** * Trigger a global event * * @export * @param {string} e event name * @param {*} d data passing to all related callback */ function trigger(e: string, d: any): void; /** * Report system fail. This will trigger the global `fail` * event * * @export * @param {(string | FormattedString)} m message string * @param {Error} e error to be reported */ function osfail(m: string | FormattedString, e: Error): void; /** * Report system error. This will trigger the global `error` * event * * @export * @param {(string | FormattedString)} m message string * @param {Error} e error to be reported */ function oserror(m: string | FormattedString, e: Error): void; /** * Trigger system notification (`info` event) * * @export * @param {(string | FormattedString)} m notification message */ function osinfo(m: string | FormattedString): void; /** * trigger a specific global event * * @export * @param {string} e event name * @param {*} d event data */ function ostrigger(e: string, d: any): void; /** * Unregister a process (application/service) from * the global announcement system * * @export * @param {GUI.BaseModel} app reference to the process * @returns {void} */ function unregister(app: BaseModel): void; /** * Allocate message id * * @export * @returns {number} */ function getMID(): number; } } /// declare namespace OS { /** * Application argument type definition * * @export * @interface AppArgumentsType */ interface AppArgumentsType { /** * File type to be open by the app * * @type {string} * @memberof AppArgumentsType */ type?: string; /** * File path to be opened * * @type {string} * @memberof AppArgumentsType */ path: string; /** * Any other object */ [propName: string]: any; } /** * Enum definition of different model types * * @export * @enum {number} */ enum ModelType { /** * Applications */ Application = 0, /** * Services */ Service = 1, /** * Sub-window such as dialogs */ SubWindow = 2 } /** * Base AntOS event definition * * @export * @class BaseEvent */ class BaseEvent { /** * The event name placeholder * * @type {string} * @memberof BaseEvent */ name: string; /** * Placeholder indicates whether the event is forced to * be happen * * @private * @type {boolean} * @memberof BaseEvent */ private force; /** * Placeholder indicates whether the event is prevented. * This value has not effect if `force` is set to `true` * * @type {boolean} * @memberof BaseEvent */ prevent: boolean; /** *Creates an instance of BaseEvent. * @param {string} name event name * @param {boolean} force indicates whether the event is forced * @memberof BaseEvent */ constructor(name: string, force: boolean); /** * Prevent the current event. This function * has no effect if `force` is set to true * * @memberof BaseEvent */ preventDefault(): void; } /** * The root model of all applications, dialogs or services * in the system * * @export * @abstract * @class BaseModel */ abstract class BaseModel { /** * The class name * * @type {string} * @memberof BaseModel */ name: string; /** * The argument of the model * * @type {AppArgumentsType[]} * @memberof BaseModel */ args: AppArgumentsType[]; /** * Each model has its own local announcement system * to handle all local events inside that model. * * This observable object is propagate to all the * UI elements ([[AFXTag]]) inside the model * * @protected * @type {API.Announcer} * @memberof BaseModel */ protected _observable: API.Announcer; /** * Reference to the core API namespace * * @protected * @type {typeof API} * @memberof BaseModel */ protected _api: typeof API; /** * Reference to the core GUI namespace * * @protected * @type {typeof GUI} * @memberof BaseModel */ protected _gui: typeof GUI; /** * Reference to the model's dialog * * @type {GUI.BaseDialog} * @memberof BaseModel */ dialog: GUI.BaseDialog; /** * The HTML element ID of the virtual desktop * * @protected * @type {string} * @memberof BaseModel */ protected host: string; /** * The process number of the current model. * For sub-window this number is the number * of the parent window * * @type {number} * @memberof BaseModel */ pid: number; /** * Reference the DOM element of the UI scheme belong to * this model * * @type {HTMLElement} * @memberof BaseModel */ scheme: HTMLElement; /** * Reference to the system setting * * @protected * @type {typeof setting} * @memberof BaseModel */ protected systemsetting: typeof setting; /** * Placeholder for the process creation timestamp * * @type {number} * @memberof BaseModel */ birth: number; /** * Different model type * * @static * @type {ModelType} * @memberof BaseModel */ static type: ModelType; /** * Allow singleton on this model * * @static * @type {boolean} * @memberof BaseModel */ static singleton: boolean; /** * The javascript or css files that the model depends on. All dependencies * will be loaded before the model is rendered * * @static * @type {string[]} list of VFS paths of dependencies * @memberof BaseModel */ static dependencies: string[]; /** * Reference to the CSS Element of the model * * @static * @type {(HTMLElement | string)} * @memberof BaseModel */ static style: HTMLElement | string; /** * Place holder for model meta-data * * @static * @type {API.PackageMetaType} * @memberof BaseModel */ static meta: API.PackageMetaType; /** *Creates an instance of BaseModel. * @param {string} name class name * @param {AppArgumentsType[]} args arguments * @memberof BaseModel */ constructor(name: string, args: AppArgumentsType[]); /** * Getter: get the local announcer object * * @readonly * @type {API.Announcer} * @memberof BaseModel */ get observable(): API.Announcer; /** * Update the model locale * * @protected * @param {string} name * @memberof BaseModel */ protected updateLocale(name: string): void; /** * Render the model's UI * * @protected * @param {string} p VFS path to the UI scheme definition * @returns {void} * @memberof BaseModel */ protected render(p: string): void; /** * Exit the model * * @param {boolean} force set this value to `true` will bypass the prevented exit event by user * @returns {void} * @memberof BaseModel */ quit(force: boolean): void; /** * Model meta data, need to be implemented by * subclasses * * @abstract * @returns {API.PackageMetaType} * @memberof BaseModel */ abstract meta(): API.PackageMetaType; /** * VFS path to the model asset * * @returns {string} * @memberof BaseModel */ path(): string; /** * Execute a server side script and get back the result * * @protected * @param {GenericObject} cmd execution indication, should be: * * ``` * { * path?: string, // VFS path to the server side script * code: string, // or server side code to be executed * parameters: any // the parameters of the server side execution * } * ``` * * @returns {Promise} * @memberof BaseModel */ protected call(cmd: GenericObject): Promise; /** * Connect to the server side api using a websocket connection * * Server side script can be execute inside the stream by writing * data in JSON format with the following interface * * ``` * { * path?: string, // VFS path to the server side script * code: string, // or server side code to be executed * parameters: any // the parameters of the server side execution * } * ``` * * @protected * @returns {Promise} * @memberof BaseModel */ protected stream(): Promise; /** * Init the model before UI rendering * * @abstract * @memberof BaseModel */ abstract init(): void; /** * Main entry point after UI rendering * * @abstract * @memberof BaseModel */ abstract main(): void; /** * Show the model * * @abstract * @memberof BaseModel */ abstract show(): void; /** * Hide the model * * @abstract * @memberof BaseModel */ abstract hide(): void; /** * Function called when the model exits * * @protected * @abstract * @param {BaseEvent} e exit event * @memberof BaseModel */ protected abstract onexit(e: BaseEvent): void; /** * subscribe once to a local event * * @protected * @param {string} e name of the event * @param {(d: any) => void} f event callback * @returns {void} * @memberof BaseModel */ protected one(e: string, f: (d: any) => void): void; /** * Subscribe to a local event * * @protected * @param {string} e event name * @param {(d: any) => void} f event callback * @returns {void} * @memberof BaseModel */ protected on(e: string, f: (d: any) => void): void; /** * Unsubscribe an event * * @protected * @param {string} e event name or `*` (all events) * @param {(d: any) => void} [f] callback to be unsubscribed, can be `undefined` * @returns {void} * @memberof BaseModel */ protected off(e: string, f?: (d: any) => void): void; /** * trigger a local event * * @protected * @param {string} e event name * @param {*} [d] event data * @returns {void} * @memberof BaseModel */ trigger(e: string, d?: any): void; /** * subscribe to an event on the global announcement system * * @protected * @param {string} e event name * @param {(d: any) => void} f event callback * @returns {void} * @memberof BaseModel */ subscribe(e: string, f: (d: any) => void): void; /** * Open a dialog * * @param {(GUI.BaseDialog | string)} d a dialog object or a dialog class name * @param {GenericObject} [data] input data of the dialog, refer to each * dialog definition for the format of the input data * @returns {Promise} A promise on the callback data of the dialog, refer * to each dialog definition for the format of the callback data * @memberof BaseModel */ openDialog(d: GUI.BaseDialog | string, data?: GenericObject): Promise; /** * Open a [[YesNoDialog]] to confirm a task * * @protected * @param {GenericObject} data [[YesNoDialog]] input data * @returns {Promise} * @memberof BaseModel */ protected ask(data: GenericObject): Promise; /** * Trigger a global event * * @protected * @param {string} t event name * @param {(string | FormattedString)} m event message * @param {Error} [e] error object if any * @returns {void} * @memberof BaseModel */ protected publish(t: string, m: string | FormattedString, e?: Error): void; /** * Publish a global notification * * @param {(string | FormattedString)} m notification string * @returns {void} * @memberof BaseModel */ notify(m: string | FormattedString): void; /** * Publish a global warning * * @param {(string | FormattedString)} m warning string * @returns {void} * @memberof BaseModel */ warn(m: string | FormattedString): void; /** * Report a global error * * @param {(string | FormattedString)} m error message * @param {Error} [e] error object if any * @returns * @memberof BaseModel */ error(m: string | FormattedString, e?: Error): void; /** * Report a global fail event * * @param {string} m fail message * @param {Error} [e] error object if any * @returns * @memberof BaseModel */ fail(m: string, e?: Error): void; /** * Throw an error inside the model * * @returns {Error} * @memberof BaseModel */ throwe(): Error; /** * Update the model, this will update all its UI elements * * @returns {void} * @memberof BaseModel */ update(): void; /** * Find a HTMLElement in the UI of the model * using the `data-id` attribute of the element * * @protected * @param {string} id * @returns {HTMLElement} * @memberof BaseModel */ protected find(id: string): HTMLElement; /** * Select all DOM Element inside the UI of the model * using JQuery selector * * @protected * @param {string} sel * @returns {HTMLElement} * @memberof BaseModel */ protected select(sel: string): JQuery; } } /// declare namespace OS { namespace application { /** * Services are processes that run in the background and * are waken up in certain circumstances such as by global * events or user interactions. * * Each service takes an entry in the system tray menu * located on the system panel. This menu entry is used * to access to service visual contents such as: options, * task performing based on user interaction, etc. * * Services are singleton processes, there is only * one process of a service at a time * * @export * @abstract * @class BaseService * @extends {BaseModel} */ abstract class BaseService extends BaseModel { /** * The service icon shown in the system tray * * @type {string} * @memberof BaseService */ icon: string; /** * CSS class of the service icon shown in the system tray * * @type {string} * @memberof BaseService */ iconclass: string; /** * Text of the service shown in the system tray * * @type {string} * @memberof BaseService */ text: string; /** * Reference to the menu entry DOM element attached * to the service * * @type {HTMLElement} * @memberof BaseService */ domel: HTMLElement; /** * Reference to the timer that periodically executes the callback * defined in [[watch]]. * * @private * @type {number} * @memberof BaseService */ private timer; /** * Reference to the system tray menu * * @type {HTMLElement} * @memberof BaseService */ holder: HTMLElement; /** * Placeholder for service select callback * * @memberof BaseService */ onmenuselect: (d: OS.GUI.TagEventType) => void; /** *Creates an instance of BaseService. * @param {string} name service class name * @param {AppArgumentsType[]} args service arguments * @memberof BaseService */ constructor(name: string, args: AppArgumentsType[]); /** * Do nothing * * @memberof BaseService */ hide(): void; /** * Init the service before attaching it to * the system tray: event subscribe, scheme * loading. * * Should be implemented by all subclasses * * @abstract * @memberof BaseService */ abstract init(): void; /** * Refresh the service menu entry in the * system tray * * @memberof BaseService */ update(): void; /** * Get the service meta-data * * @returns {API.PackageMetaType} * @memberof BaseService */ meta(): API.PackageMetaType; /** * Attach the service to a menu element * such as the system tray menu * * @param {HTMLElement} h * @memberof BaseService */ attach(h: HTMLElement): void; /** * Set the callback that will be called periodically * after a period of time. * * Each service should only have at most one watcher * * @protected * @param {number} t period time in seconds * @param {() => void} f callback function * @returns {number} * @memberof BaseService */ protected watch(t: number, f: () => void): number; /** * This function is called when the service * is exited * * @protected * @param {BaseEvent} evt exit event * @returns * @memberof BaseService */ protected onexit(evt: BaseEvent): JQuery; /** * Do nothing * * @memberof BaseService */ main(): void; /** * Do nothing * * @memberof BaseService */ show(): void; /** * Awake the service, this function is usually called when * the system tray menu entry attached to the service is * selected. * * This function should be implemented by all subclasses * * @abstract * @param {GUI.TagEventType} e * @memberof BaseService */ abstract awake(e: GUI.TagEventType): void; /** * Do nothing * * @protected * @param {BaseEvent} evt * @memberof BaseService */ protected cleanup(evt: BaseEvent): void; } } } declare namespace OS { /** * This namespace dedicated to all operations related to system * process management */ namespace PM { /** * A process is either an instance of an application or a service */ type ProcessType = application.BaseApplication | application.BaseService; /** * Alias to all classes that extends [[BaseModel]] */ type ModelTypeClass = { new (args: AppArgumentsType[]): T; }; /** * Process id allocator, when a new process is created, the value of * this variable is increased */ var pidalloc: number; /** * All running processes is stored in this variables */ var processes: GenericObject; /** * Create a new process of application or service * * @export * @param {string} app class name string * @param {ProcessTypeClass} cls prototype class * @param {GUI.AppArgumentsType[]} [args] process arguments * @returns {Promise} a promise on the created process */ function createProcess(app: string, cls: ModelTypeClass, args?: AppArgumentsType[]): Promise; /** * Get the reference to a process using its id * * @export * @param {number} pid * @returns {BaseModel} */ function appByPid(pid: number): BaseModel; /** * Kill a process * * @export * @param {OS.GUI.BaseModel} app reference to the process * @returns {void} */ function kill(app: BaseModel): void; /** * Kill all process of an application or service * * @export * @param {string} app process class name * @param {boolean} force force exit all process * @returns {void} */ function killAll(app: string, force: boolean): void; } } /// declare namespace OS { /** * This namespace is dedicated to all APIs related to AntOS UI system, * these API are called AFX APIs which handle: * - The mouse and keyboard interaction with the UI system * - UI rendering * - Custom tags definition * - Load/unload system, applications and services UI * - System dialogs definition */ namespace GUI { /** * AntOS keyboard shortcut type definition * * @export * @interface ShortcutType */ interface ShortcutType { /** * Placeholder for all shortcut callbacks, example: * ```typescript * fn_193462204.c = function() {..} * // this function will be called when the hotkey `ALT-C` is triggered * // fn_${"ALT".hash()} is fn_193462204 * ``` * * @memberof ShortcutType */ [propName: string]: GenericObject<(e: JQuery.KeyDownEvent) => void>; } /** * Basic item type definition which is usually used by some UI element * such as list view, tree view, menu and grid view * * * @export * @interface BasicItemType */ interface BasicItemType { /** * Item text * * @type {(string | FormattedString)} * @memberof BasicItemType */ text: string | FormattedString; /** * Item children, usually used by tree view or menu item * This property is keep for compatibility purposes only. * Otherwise, the [[nodes]] property should be used * * @type {BasicItemType[]} * @memberof BasicItemType */ children?: BasicItemType[]; /** * Item children, usually used by tree view or menu item * * @type {BasicItemType[]} * @memberof BasicItemType */ nodes?: BasicItemType[]; [propName: string]: any; } /** * Element id of the virtual desktop, used by JQuery */ var workspace: string; /** * Indicate whether the system is in fullscreen mode */ var fullscreen: boolean; /** * Reference to the current system dialog, only one dialog * is allowed at a time. A dialog may have sub dialog */ var dialog: BaseDialog; /** * Convert an application html scheme to * UI elements, then insert this UI scheme to the DOM tree. * * This function renders the UI of the application before calling the * application's [[main]] function * * @export * @param {string} html html scheme string * @param {BaseModel} app reference to the target application * @param {(Element | string)} parent * The parent HTML element where the application is rendered. * This is usually the reference to the virtual desktop element. */ function htmlToScheme(html: string, app: BaseModel, parent: Element | string): void; /** * Load an application scheme file then render * it with [[htmlToScheme]] * * @export * @param {string} path VFS path to the scheme file * @param {BaseModel} app the target application * @param {(HTMLElement | string)} parent The parent HTML element where the application is rendered. */ function loadScheme(path: string, app: BaseModel, parent: HTMLElement | string): void; /** * Clear the current system theme * * @export */ function clearTheme(): void; /** * Load a theme based on its name, then refresh the * system UI theme * * @export * @param {string} name name of the theme e.g. `antos_dark` * @param {boolean} force force to clear the system theme before applying the new one */ function loadTheme(name: string, force: boolean): void; /** * Open a system dialog. * * @export * @param {(BaseDialog | string)} d a dialog object or a dialog class name * @param {GenericObject} [data] input data of the dialog, refer to each * dialog definition for the format of the input data * @returns {Promise} A promise on the callback data of the dialog, refer * to each dialog definition for the format of the callback data */ function openDialog(d: string | BaseDialog, data: GenericObject): Promise; /** * Find a list of applications that support a specific mime * type in the system packages meta-data * * @export * @param {string} mime the mime type * @returns {API.PackageMetaType[]} */ function appsByMime(mime: string): API.PackageMetaType[]; /** * Find all applications that have services attached to it. * This function allows to collect all the services available * on the system. These services may or may not be running. * * @export * @returns {GenericObject} result in forme of: * `service_name:service-meta-data` key-value pairs */ function appsWithServices(): GenericObject; /** * Find an launch an application using input application argument * such as VFS file meta-data. * * Based on the input application argument, the function will try * to find all applications that is compatible with that argument. * Three cases possible: * - There is no application that can handle the argument, a message will * be notified to user. * - There is one application that can handle the argument, the application * will be launched with the argument * - There are many applications that can handle the arguments, a selection * dialog will be popped up and allows user to select an application to launch. * * @export * @param {AppArgumentsType} it application argument * @returns {void} */ function openWith(it: AppArgumentsType): void; /** * Kil all processes related to an application, reload the application * prototype definition and launch a new process of this application. * * This function is used only for debug purpose or used by * AntOSDK during in-browser application development * * @export * @param {string} app the application class name * @param {AppArgumentsType[]} args application arguments * @returns {void} */ function forceLaunch(app: string, args: AppArgumentsType[]): void; /** * Kill an running processes of an application, then * unregister the application prototype definition * from the [[application]] namespace. * * This process is similar to uninstall the application * from the current system state * * @export * @param {string} app */ function unloadApp(app: string): void; /** * Create a service process. * * Services are singleton processes, there is only * one process of a service at a time * * @export * @param {string} ph * @returns {Promise} */ function pushService(ph: string): Promise; /** * Synchronously start a list of services * * @export * @param {string[]} srvs list of service class names * @returns {Promise} */ function pushServices(srvs: string[]): Promise; /** * Launch an application with arguments * * @export * @param {string} app application class name * @param {AppArgumentsType[]} args application arguments */ function launch(app: string, args: AppArgumentsType[]): Promise; /** * Dock an application to the system application dock * * @export * @param {BaseApplication} app reference to the application process * @param {API.PackageMetaType} meta Application meta-data * @returns {void} */ function dock(app: OS.application.BaseApplication, meta: API.PackageMetaType): void; /** * Toggle system fullscreen * * @export */ function toggleFullscreen(): void; /** * Remove an application process from the system application * dock. This action will also exit the process * * @export * @param {BaseApplication} app * @returns */ function undock(app: application.BaseApplication): void; /** * Attach a running service process to the system tray * * @export * @param {BaseService} srv reference to the running service process * @returns {void} */ function attachservice(srv: application.BaseService): void; /** * Detach a running process from the system tray * * @export * @param {BaseService} srv reference to the running service process * @returns {void} */ function detachservice(srv: application.BaseService): void; /** * Register a hot key and its handle in the * system shortcut * * @export * @param {string} k the hotkey e.g. `ALT-C` * @param {(e: JQuery.KeyPressEvent) => void} f handle function * @param {boolean} force force to rebind the hotkey * @returns {void} */ function bindKey(k: string, f: (e: JQuery.KeyDownEvent) => void, force?: boolean): void; /** * Load and apply system wallpaper from the setting object * * @export * @param {setting.WPSettingType} obj wallpaper setting object */ function wallpaper(obj?: setting.WPSettingType): void; /** * Refresh the virtual desktop * * @export */ function refreshDesktop(): void; /** * Show the login screen and perform the login operation. * * Once login successfully, the [[startAntOS]] will be called * * @export */ function login(): void; /** * Start AntOS after a successful login. * * This function performs the following operations: * * - System cleanup * - Apply system setting * - Load desktop wallpaper and the current theme from the system setting * - Load system package meta-data * - Load and apply system locale and language * * * @export * @param {*} conf */ function startAntOS(conf: any): void; /** * HTML schemes used by the system: * - The login screen scheme * - The workspace including: * - System panel * - Virtual desktop * - Context menu * - System tooltip */ const schemes: GenericObject; } } /** * Reference to the global this */ declare const Ant: typeof globalThis; /** * Extend the String prototype with some API * functions used by AntOS API * * @interface String */ interface String { /** * Simple string hash function * * @returns {number} * @memberof String */ hash(): number; /** * Parse the current string and convert it * to an object of type [[Version]] if the string * is in the format recognized by [[Version]], * e.g.: `1.0.1-a` * * @returns {OS.Version} * @memberof String */ __v(): OS.Version; /** * Convert the current string to base 64 string * * @returns {string} * @memberof String */ asBase64(): string; /** * Unescape all escaped characters on the * string using `\` * * @returns {string} * @memberof String */ unescape(): string; /** * Escape the current string using backslash * * @returns {string} * @memberof String */ escape(): string; /** * Convert the current string to uint8 array * * @returns {Uint8Array} * @memberof String */ asUint8Array(): Uint8Array; /** * Format the current using input parameters. * The current string should be a formatted string * in the following form: * * ```typescript * "example string: {0} and {1}".format("hello", "world") * // return "example string: hello and world" * ``` * * @param {...any[]} args * @returns {string} * @memberof String */ format(...args: any[]): string; /** * Create a [[FormattedString]] object using the current * string and the input parameters * * @param {...any[]} args * @returns {OS.FormattedString} * @memberof String */ f(...args: any[]): OS.FormattedString; /** * Check if the current string is translatable, if it * is the case, translate the string to the language specified * in the current system locale setting. * * A translatable string is a string in the following * form: `"__(example string)"` * * @returns {string} * @memberof String */ __(): string; /** * Translate current string to the language specified * by the system locale setting * * @returns {string} * @memberof String */ l(): string; /** * Trim left of a string by a mask string * * @param {string} arg specifies a sub-string to be removed * @returns {string} * @memberof String */ trimFromLeft(arg: string): string; /** * Trim right of a string by a mask string * * @param {string} arg specifies a sub-string to be removed * @returns {string} * @memberof String */ trimFromRight(arg: string): string; /** * Trim both left and right of a string by a mask string * * @param {string} arg specifies a sub-string to be removed * @returns {string} * @memberof String */ trimBy(arg: string): string; } /** * Extend the Data prototype with the * [[timestamp]] function * * @interface Date */ interface Date { /** * Return the timestamp of the current Date object * * @returns {number} * @memberof Date */ timestamp(): number; } /** * Generic key-value pair object interface * * @interface GenericObject * @template T */ interface GenericObject { [index: string]: T; } /** * Global function to create a [[FormattedString]] from * a formatted string and a list of parameters. Example * * ```typescript * __("hello {0}", world) // return a FormattedString object * ``` * * @param {...any[]} args * @returns {(OS.FormattedString | string)} */ declare function __(...args: any[]): OS.FormattedString | string; /** * This global function allow chaining stack trace from one error to * another. It is particular helping when tracking the source of * the error in promises chain which results in some obfuscated stack * traces as the stack resets on every new promise. * * @param {Error} e * @returns {Error} */ declare function __e(e: Error): Error; /** * This namespace is the main entry point of AntOS * API */ declare namespace OS { /** * Represent a translatable formatted string * * @export * @class FormattedString */ class FormattedString { /** * Format string in the following form * * ```typescript * "format string with {0} and {1}" * // {[0-9]} is the format pattern * ``` * * @type {string} * @memberof FormattedString */ fs: string; /** * The value of the format pattern represented * in [[fs]] * * @type {any[]} * @memberof FormattedString */ values: any[]; /** * Creates an instance of FormattedString. * @param {string} fs format string * @param {any[]} args input values of the format patterns * @memberof FormattedString */ constructor(fs: string, args: any[]); /** * Convert FormattedString to String * * @returns {string} * @memberof FormattedString */ toString(): string; /** * Translate the format string to the current system * locale language, format the string with values and * then converted it to normal `string` * * @returns {string} * @memberof FormattedString */ __(): string; /** * Return the hash number of the formatted string * * @returns {number} * @memberof FormattedString */ hash(): number; /** * Match the formatted string against a regular expression * a string pattern * * @param {(string | RegExp)} t string or regular expression * @returns {RegExpMatchArray} * @memberof FormattedString */ match(t: string | RegExp): RegExpMatchArray; /** * Convert the formatted string to Base^$ * * @returns {string} * @memberof FormattedString */ asBase64(): string; /** * Un escape the formatted string * * @returns {string} * @memberof FormattedString */ unescape(): string; /** * Escape the formatted string * * @returns {string} * @memberof FormattedString */ escape(): string; /** * Convert the formatted string to uint8 array * * @returns {Uint8Array} * @memberof FormattedString */ asUint8Array(): Uint8Array; /** * Input values for the format string * * @param {...any[]} args * @memberof FormattedString */ format(...args: any[]): void; } /** * This class represents the Version number format used by AntOS. A typical * AntOS version number is in the following format: * * ``` * [major_number].[minor_number].[patch]-[branch] * * e.g.: 1.2.3-r means that: * - version major number is 1 * - version minor number is 2 * - patch version is 3 * - the current branch is release `r` * ``` * * @export * @class Version */ class Version { /** * The version string * * @type {string} * @memberof Version */ string: string; /** * The current branch * - 1: `a` - alpha branch * - 2: `b` - beta branch * - 3: `r` - release branch * * @private * @type {number} * @memberof Version */ private branch; /** * Version major number * * @type {number} * @memberof Version */ major: number; /** * Version minor number * * @type {number} * @memberof Version */ minor: number; /** * Version patch number * * @type {number} * @memberof Version */ patch: number; /** *Creates an instance of Version. * @param {string} string string represents the version * @memberof Version */ constructor(string: string); /** * Compare the current version with another version. * * The comparison priority is `branch>major>minor>patch`. * * For the branch, the priority is `r>b>a` * * @param {(string | Version)} o version string or object * @returns {(0 | 1 | -1)} * Return 0 if the two versions are the same, 1 if * the current version is newer than the input version, * otherwise return -1 * @memberof Version */ compare(o: string | Version): 0 | 1 | -1; /** * Check if the current version is newer than * the input version * * @param {(string | Version)} o version string or object * @returns {boolean} * @memberof Version */ nt(o: string | Version): boolean; /** * Check if the current version is older than * the input version * * @param {(string | Version)} o version string or object * @returns {boolean} * @memberof Version */ ot(o: string | Version): boolean; /** * Return itself * * @returns {Version} * @memberof Version */ __v(): Version; /** * Convert Version object to string * * @returns {string} * @memberof Version */ toString(): string; } /** * Variable represents the current AntOS version, it * is an instance of [[Version]] */ const VERSION: Version; /** * Register a model prototype to the system namespace. * There are two types of model to be registered, if the model * is of type [[SubWindow]], its prototype will be registered * in the [[dialogs]] namespace, otherwise, if the model type * is [[Application]] or [[Service]], its prototype will be * registered in the [[application]] namespace. * * When a model is loaded in the system, its prototype is registered * for later uses * * @export * @param {string} name class name * @param {*} x the corresponding class * @returns {*} */ function register(name: string, x: PM.ModelTypeClass): void; /** * This function cleans up the entire system and * makes sure the system is in a new and clean session. * It performs the following operations: * * - Kill all running processes * - Unregister all global events and reset the global * announcement system * - Clear the current theme * - Reset process manager and all system settings * * @export */ function cleanup(): void; /** * Booting up AntOS. This function checks whether the user * is successfully logged in, then call [[startAntOS]], otherwise * it shows the login screen * * @export */ function boot(): void; /** * Placeholder for all the callbacks that are called when the system * exits. These callbacks are useful when an application or service wants * to perform a particular task before shuting down the system */ const cleanupHandles: { [index: string]: () => void; }; /** * Perform the system shutdown operation. This function calls all * clean up handles in [[cleanupHandles]], then save the system setting * before exiting * * @export */ function exit(): void; /** * Register a callback to the system [[cleanupHandles]] * * @export * @param {string} n callback string name * @param {() => void} f the callback handle * @returns */ function onexit(n: string, f: () => void): () => void; /** * The namespace API is dedicated to the definition of the core system APIs * used by AntOS and its applications. The following core APIs are defined: * * - The AntOS announcement system * - Virtual File system * - Virtual Database * - Low-level REST based client-server communication * - Dependencies management * - System utilities * * These APIs are considered as middle-ware that abstracts the client-server * communication and provide the application layer with a standardized APIs * for file/database access, system events handling (announcement), automatic * dependencies resolving, etc. */ namespace API { /** * AntOS package meta-data type definition * * @export * @interface PackageMetaType */ interface PackageMetaType { /** * The application class name, if the package has only services * this property is ignored and [[pkgname]] should be specified * * @type {string} * @memberof PackageMetaType */ app?: string; /** * Package name, in case of [[app]] being undefined, this property * need to be specified * * @type {string} * @memberof PackageMetaType */ pkgname?: string; /** * Package category * * @type {string} * @memberof PackageMetaType */ category: string; /** * Package description string * * @type {string} * @memberof PackageMetaType */ description: string; /** * List of services that is attached to the * package * * @type {string[]} * @memberof PackageMetaType */ services?: string[]; /** * CSS icon class of the package * * @type {string} * @memberof PackageMetaType */ iconclass?: string; /** * VFS application icon path * * @type {string} * @memberof PackageMetaType */ icon?: string; /** * Package information * * @type {{ * author: string; * email: string; * [propName: string]: any; * }} * @memberof PackageMetaType */ info: { /** * Author of the package * * @type {string} */ author: string; /** * Author's email * * @type {string} */ email: string; [propName: string]: any; }; /** * Application-specific locale definition. When the system locale changes, * translatable texts inside the application will be first translated using * the locale dictionary defined in the package meta-data. If no translation * found, the system locale dictionary is used instead. * * A local dictionary definition should be in the following format: * * ```typescript * { * [locale_name: string]: { * [origin_string]: string // translation string * } * } * ``` * * Example of locale dictionaries: * * ```typescript * { * "en_GB": { * "Cancel": "Cancel", * "Modify": "Modify" * }, * "fr_FR": { * "Cancel": "Annuler", * "Modify": "Modifier" * } * } * ``` * * @type {{ [index: string]: GenericObject }} locale dictionaries * @memberof PackageMetaType */ locales: { [index: string]: GenericObject; }; /** * Mime types supported by the packages, regular expression can be used * to specified a range of mimes in common * * @type {string[]} * @memberof PackageMetaType */ mimes: string[]; /** * Package (application) name * * @type {string} * @memberof PackageMetaType */ name: string; /** * VFS path to package installation location * * @type {string} * @memberof PackageMetaType */ path: string; /** * Package version, should be in a format conforming * to the version definition in [[Version]] class * * @type {string} * @memberof PackageMetaType */ version: string; /** * Package dependencies, each entry is in the following format * * `package_name@version` * * Example: * * ```json * [ * "File@0.1.5-b" * ] * ``` * * @type {string[]} * @memberof PackageMetaType */ dependencies: string[]; [propName: string]: any; } /** * Placeholder to store all loaded shared libraries. Once * a shared library is firstly loaded, its identity will be * stored in this variable. Based on this information, in * the next use of the library, the system knows that the * library is already loaded and ready to use. * * A shared library can be a javascript or a CSS file. */ const shared: GenericObject; /** * Placeholder for all global search handles registered to the system. * These callbacks will be called when user performs the search operation * in the spotlight UI. * * Applications can define their own search handle to provide the spotlight UI * with additional search results * */ const searchHandle: GenericObject<(text: string) => any[]>; /** * Placeholder of the current system locale dictionary, the system uses * this dictionary to translate all translatable texts to the current * locale language */ var lang: GenericObject; /** * Re-export the system announcement [[getMID]] function to the * core API * * @export * @returns {number} */ function mid(): number; /** * REST-based API. * * Perform a POST request to the server. Data exchanged * is in `application/json` * * @export * @param {string} p the server URI * @param {*} d data object that will be converted to JSON * @returns {Promise} a promise on the result data */ function post(p: string, d: any): Promise; /** * REST-based API. * * Perform a GET request and read back the data in * `ArrayBuffer` (binary) format. This is useful for * binary data reading * * @export * @param {string} p resource URI * @returns {Promise} a promise on the returned binary data */ function blob(p: string): Promise; /** * REST-based API. * * Send file to server * * @export * @param {string} p resource URI * @param {string} d VFS path of the destination file * @returns {Promise} */ function upload(p: string, d: string): Promise; /** * REST-based API. * * Download a file * * @export * @param {string} name file name * @param {*} b file content */ function saveblob(name: string, b: any): void; /** * Helper function to trigger the global `loading` * event. This event should be triggered in the * beginning of a heavy task * * @export * @param {number} q message id, see [[mid]] * @param {string} p message string */ function loading(q: number, p: string): void; /** * Helper function to trigger the global `loaded` * event: This event should be triggered in the * end of a heavy task that has previously triggered * the `loading` event * * @export * @param {number} q the message id of the corresponding `loading` event * @param {string} p the message string * @param {string} m message status (`OK` of `FAIL`) */ function loaded(q: number, p: string, m: string): void; /** * Perform an REST GET request * * @export * @param {string} p the URI of the request * @param {string} [t=undefined] the response data type: * - jsonp: the response is an json object * - script: the response is a javascript code * - xm, html: the response is a XML/HTML object * - text: plain text * @returns {Promise} a Promise on the requested data */ function get(p: string, t?: string): Promise; /** * REST-based API * * Perform a GET operation and executed the returned * content as javascript * * @export * @param {string} p URI resource * @returns {Promise} promise on the executed content */ function script(p: string): Promise; /** * REST-based API * * Get the content of a global asset resource stored * in `os://resources/` * * @export * @param {string} r relative path to the resource * @returns {Promise} promise on the returned content */ function resource(r: string): Promise; /** * Helper function to verify whether a shared library * is loaded and ready to use * * @export * @param {string} l path to the library * @returns {boolean} */ function libready(l: string): boolean; /** * Load a shared library if not ready * * @export * @param {string} l VFS path to the library * @param {string} force force reload library * @returns {Promise} a promise on the result data */ function requires(l: string, force?: boolean): Promise; /** * Synchronously load a list of shared libraries * * @export * @param {string[]} libs list of shared libraries * @returns {Promise} */ function require(libs: string[]): Promise; /** * The namespace packages is dedicated to all package management * related APIs. */ namespace packages { /** * Fetch the package meta-data from the server * * @export * @returns {Promise} Promise on a [[RequestResult]]. * A success request result should contain a list of [[PackageMetaType]] */ function fetch(): Promise; /** * Request the server to regenerate the package * caches * * @export * @returns {Promise} */ function cache(): Promise; } /** * Save the current user setting * * @export * @returns {Promise} promise on a [[RequestResult]] */ function setting(): Promise; /** * An apigateway allows client side to execute a custom server-side * script and get back the result. This gateway is particularly * useful in case of performing a task that is not provided by the core * API * * @export * @param {GenericObject} d execution indication, provided only when ws is `false` * otherwise, `d` should be written directly to the websocket stream as JSON object. * Two possible formats of `d`: * ```text * execute an server-side script file: * * { * path: [VFS path], * parameters: [parameters of the server-side script] * } * * or, execute directly a snippet of server-side script: * * { code: [server-side script code snippet as string] } * * ``` * * @param {boolean} ws flag indicate whether to use websocket for the connection * to the gateway API. In case of streaming data, the websocket is preferred * @returns {Promise} a promise on the result object (any) */ function apigateway(d: GenericObject, ws: boolean): Promise; /** * Perform the global search operation when user enter * text in spotlight. * * This function will call all the search handles stored * in [[searchHandle]] and build the search result based * on output of these handle * * @export * @param {string} text text to search * @returns {any[]} */ function search(text: string): any[]; /** * Register a search handle to the global [[searchHandle]] * * @export * @param {string} name handle name string * @param {(text: string) => any[]} fn search handle */ function onsearch(name: string, fn: (text: string) => any[]): void; /** * Set the current system locale: This function will * find and load the locale dictionary definition file in the * system asset resource, then trigger the global event * `systemlocalechange` to translated all translatable text * to the target language * * @export * @param {string} name locale name, e.g. `en_GB` * @returns {Promise} */ function setLocale(name: string): Promise; /** * Return an error Object: AntOS use this function to * collect information (stack trace) from user reported * error. * * @export * @param {(string | FormattedString)} n error string * @returns {Error} */ function throwe(n: string | FormattedString): Error; /** * Set value to the system clipboard * * @export * @param {string} v clipboard value * @returns {boolean} */ function setClipboard(v: string): boolean; /** * Get the clipboard data * * @export * @returns {Promise} Promise on the clipboard data */ function getClipboard(): Promise; /** * A switcher object is a special object in which * each object's property is a boolean option. All object's * properties are mutual exclusive. It means that when a property * is set to true, all other properties will be reset to false. * * Example: * * ```typescript * let view = API.switcher("tree", "list", "icon") * view.tree = true // view.list = false and view.icon = false * view.list = true // view.tree = false and view.icon = false * ``` * * @export * @returns {*} */ function switcher(...args: string[]): any; } } declare namespace OS { namespace GUI { /** * the SubWindow class is the abstract prototype of all * modal windows or dialogs definition in AntOS * * @export * @abstract * @class SubWindow * @extends {BaseModel} */ abstract class SubWindow extends BaseModel { /** * Placeholder indicates whether the sub window is in * modal mode. This value is reserver for future use * * @type {boolean} * @memberof SubWindow */ modal: boolean; /** * Reference to the parent of the current sub-window * * @type {(BaseModel | typeof GUI)} * @memberof SubWindow */ parent: BaseModel | typeof GUI; /** *Creates an instance of SubWindow. * @param {string} name SubWindow (class) name * @memberof SubWindow */ constructor(name: string); /** * Exit the sub-window * * @returns {void} * @memberof SubWindow */ quit(): void; /** * Init the sub-window, this function is called * on creation of the sub-window object. It is used * to render the sub-window UI. * * Need to be implemented by subclasses * * @abstract * @memberof SubWindow */ abstract init(): void; /** * Main entry point after rendering of the sub-window * * @abstract * @memberof SubWindow */ abstract main(): void; /** * Return the parent meta-data of the current * sub-window * * @returns {API.PackageMetaType} * @memberof SubWindow */ meta(): API.PackageMetaType; /** * Show the sub-window * * @memberof SubWindow */ show(): void; /** * Hide the sub-window * * @returns {void} * @memberof SubWindow */ hide(): void; } /** * Abstract prototype of all AntOS dialogs widget * * @export * @abstract * @class BaseDialog * @extends {SubWindow} */ abstract class BaseDialog extends SubWindow { /** * Placeholder for the dialog callback on exit * * @memberof BaseDialog */ handle: (d: any) => void; /** * Placeholder of the dialog input data * * @type {GenericObject} * @memberof BaseDialog */ data: GenericObject; /** *Creates an instance of BaseDialog. * @param {string} name Dialog (class) name * @memberof BaseDialog */ constructor(name: string); /** * Function called when dialog exits * * @protected * @param {BaseEvent} _e * @returns {void} * @memberof BaseDialog */ protected onexit(_e: BaseEvent): void; } /** * A basic dialog renders a dialog widget using the UI * scheme provided in it constructor or defined in its * class variable `scheme` * * @export * @class BasicDialog * @extends {BaseDialog} */ class BasicDialog extends BaseDialog { /** * Placeholder for the UI scheme to be rendered. This can * be either the string definition of the scheme or * the VFS file handle of the scheme file * * @protected * @type {(string | OS.API.VFS.BaseFileHandle)} * @memberof BasicDialog */ protected markup: string | OS.API.VFS.BaseFileHandle; /** * If the `markup` variable is not provided, then * the [[init]] function will find the scheme definition * in this class variable * * @static * @type {string} * @memberof BasicDialog */ static scheme: string; /** *Creates an instance of BasicDialog. * @param {string} name dialog name * @param {(string | OS.API.VFS.BaseFileHandle)} [markup] UI scheme definition * @memberof BasicDialog */ constructor(name: string, markup?: string | OS.API.VFS.BaseFileHandle); /** * Render the dialog using the UI scheme provided by either * the `markup` instance variable or the `scheme` class variable * * @returns {void} * @memberof BasicDialog */ init(): void; /** * Main entry point for the dialog * * @memberof BasicDialog */ main(): void; } /** * The namespace `dialogs` is dedicated to all Dialog definition * in AntOS */ namespace dialogs { /** * Simple prompt dialog to get user input text. * The input data of the dialog: * * ```typescript * { * title: string, // window title * label: string, // label text * value: string, // user input text * type: string // input type: text or password * } * ``` * * The data passing from the dialog to the callback function is * in the string text of the user input value * * @export * @class PromptDialog * @extends {BasicDialog} */ class PromptDialog extends BasicDialog { /** *Creates an instance of PromptDialog. * @memberof PromptDialog */ constructor(); /** * Main entry point * * @memberof PromptDialog */ main(): void; } /** * A text dialog is similar to a [[PromptDialog]] nut allows * user to input multi-line text. * * Refer to [[PromptDialog]] for the definition of input and callback data * of the dialog * * @export * @class TextDialog * @extends {BasicDialog} */ class TextDialog extends BasicDialog { /** *Creates an instance of TextDialog. * @memberof TextDialog */ constructor(); /** * Main entry point * * @memberof TextDialog */ main(): void; } /** * A Calendar dialog allows user to select a date * * Input data: * * ```typescript * { * title: string // window title * } * ``` * * @export * @class CalendarDialog * @extends {BasicDialog} */ class CalendarDialog extends BasicDialog { /** * Creates an instance of CalendarDialog. * * Callback data: a Date object represent the selected date * * * @memberof CalendarDialog */ constructor(); /** * * * @memberof CalendarDialog */ main(): void; } /** * Color picker dialog * * Input data: * * ```typescript * { * title: string // window title * } * ``` * Callback data: [[ColorType]] object * * @export * @class ColorPickerDialog * @extends {BasicDialog} */ class ColorPickerDialog extends BasicDialog { /** *Creates an instance of ColorPickerDialog. * @memberof ColorPickerDialog */ constructor(); /** * * * @memberof ColorPickerDialog */ main(): void; } /** * Show key-value pair of the input object * * Input data: * * ```typescript * { * title: string, // window title * [propName:string]: any * } * ``` * * No data for callback * * @export * @class InfoDialog * @extends {BasicDialog} */ class InfoDialog extends BasicDialog { /** *Creates an instance of InfoDialog. * @memberof InfoDialog */ constructor(); /** * * * @memberof InfoDialog */ main(): void; } /** * A simple confirm dialog * * Input data: * * ```typescript * { * title: string, // window title * icon?: string, // label icon * iconclass?: string, // label iconclass * text: string // label text * } * ``` * * Callback data: `boolean` * * @export * @class YesNoDialog * @extends {BasicDialog} */ class YesNoDialog extends BasicDialog { /** *Creates an instance of YesNoDialog. * @memberof YesNoDialog */ constructor(); /** * Main entry point * * @memberof YesNoDialog */ main(): void; } /** * A selection dialog provide user with a list of options to * select. * * Input data: * * ```typescript * { * title: string, // window title * data: * { * text: string, * [propName:string]: any * } [] // list data * ``` * * Callback data: the selected data in the input list * * @export * @class SelectionDialog * @extends {BasicDialog} */ class SelectionDialog extends BasicDialog { /** *Creates an instance of SelectionDialog. * @memberof SelectionDialog */ constructor(); /** * Main entry * * @memberof SelectionDialog */ main(): void; } /** * An About dialog is dedicated to show the parent * application meta-data * * Input data: no * * Callback data: no * * @export * @class AboutDialog * @extends {BasicDialog} */ class AboutDialog extends BasicDialog { /** *Creates an instance of AboutDialog. * @memberof AboutDialog */ constructor(); /** * Main entry point * * @returns {void} * @memberof AboutDialog */ main(): void; } /** * File dialog allows user to select a file/folder * * Input data: * * ```typescript * { * title: string, // window title * root?: string, // the root path folder of the file view * type?: "file"|"dir"|"app", // file type to be selected * mimes?: string[], // mime types of file to be selected * hidden?: boolean, // show/hide hidden file * file?: string // file name * * } * ``` * * Callback data: * * ```typescript * { * file: string, // selected file path * name: string // user input file name * } * ``` * * @export * @class FileDialog * @extends {BasicDialog} */ class FileDialog extends BasicDialog { /** *Creates an instance of FileDialog. * @memberof FileDialog */ constructor(); /** * Store the last opened directory * * @static * @type {string} * @memberof FileDialog */ static last_opened: string; /** * * * @returns {void} * @memberof FileDialog */ main(): void; } /** * Generic & dynamic key-value dialog. The content * of the dialog consist of an array of label and input elements * which are generated based on the input model * * The input data of the dialog should be: * * ```typescript * { * title: string, // window title * model: { * [propName:string]: string * }, * data: { * [propName:string]: string * }, * allow_empty: boolean * } * ``` * Where: * - keys of `model` are data fields, each key correspond to an input element * - values of `model` are description texts of fields, each value correspond to a label text * - data is the input data object in the format of model (optional) * * ``` * Example: * { * title: "Greeting", * model: { * name: "Your name", * email: "Your email" * }, * allow_empty: false * } *``` * The data passing from the dialog to the callback function is * the user input data corresponding to the input model * * Example of callback data for the above model: * * ``` * { * name: "John Doe", * email: "jd@mail.com" * } * ``` * * @export * @class MultiInputDialog * @extends {BasicDialog} */ class MultiInputDialog extends BasicDialog { /** * References to all the input fields in the * dialog * * @private * @type {HTMLElement[]} * @memberof MultiInputDialog */ private inputs; /** *Creates an instance of MultiInputDialog. * @memberof MultiInputDialog */ constructor(); /** * Generate the scheme before rendering * * @memberof MultiInputDialog */ init(): void; /** * Main entry point * * @memberof MultiInputDialog */ main(): void; } /** * Generic dynamic key-value dialog * * Allow user to input any data key-value based object: * * { * [prop:string]: string; * } * * @export * @class KeyValueDialog * @extends {BasicDialog} */ class KeyValueDialog extends BasicDialog { /** * Reference to the form container * * @private * @type {HTMLDivElement} * @memberof KeyValueDialog */ private container; /** * Creates an instance of KeyValueDialog. * @memberof KeyValueDialog */ constructor(); /** * Main entry point * * @memberof KeyValueDialog */ main(): void; /** * Add new input key-value field to the dialog * * @private * @memberof KeyValueDialog */ private addField; } } } } declare namespace OS { namespace API { /** * Interface for user login data * * @export * @interface UserLoginType */ interface UserLoginType { /** * The user credential * * @type {string} * @memberof UserLoginType */ username: string; /** * The user password * * @type {string} * @memberof UserLoginType */ password: string; } /** * Interface for a command sent to * server side package manage, it contains two field: * * @export * @interface PackageCommandType */ interface PackageCommandType { /** * Command name, should be: `init`, `cache`, `install`, * `uninstall` or `list` * * @type {string} * @memberof PackageCommandType */ command: string; /** * Parameter object of each command * * @type {GenericObject} * @memberof PackageCommandType */ args: GenericObject; } /** * * Interface for basic request result returned * from the server-side. A valid server-side response should * be in the following format * ```json * { * "error": boolean or string_err, * "result": JSON result object * } * ``` * * @export * @interface RequestResult */ interface RequestResult { /** * Indicate whether the response is error * * @type {(boolean | string)} * @memberof RequestResult */ error: boolean | string; /** * The response result, this value must be * set when `error` is false * * @type {(string * | boolean * | GenericObject * | any[] * | FileInfoType * | FileInfoType[] * | setting.UserSettingType)} * @memberof RequestResult */ result: string | boolean | GenericObject | any[] | FileInfoType | FileInfoType[] | setting.UserSettingType; } /** * The host name of the server-side */ var HOST: string; /** * The base URI of the server-side API */ var BASE_URI: string; /** * The base REST URI of the server-side API */ var REST: string; /** * The namespace `handle` contains some low level API to * communicate with the server side API. It is the only * API layer that communicate directly with the server. * To make AntOS compatible with any server side API, * all exported variable unctions defined in the `handle` * namespace should be re-implemented */ namespace handle { /** * Base URI for reading content of VFS file */ var get: string; /** * Base URI for VFS file sharing */ var shared: string; /** * Send a request to the server-side API for a directory scanning * operation * * @export * @param {string} p a VFS file path e.g. home://test/ * @returns {Promise} A promise on a [[RequestResult]] * which contains an error or a list of FileInfoType */ function scandir(p: string): Promise; /** * * Send a request to the server-side API for directory creation * * @export * @param {string} p VFS path of the directory to be created * @returns {Promise} A promise on a RequestResult * which contains an error or true on success */ function mkdir(p: string): Promise; /** * Send a request to the server-side API for sharing/unsharing a VFS file, * once shared a VFS file will be publicly visible by everyone * * @export * @param {string} p VFS file path to be shared * @param {boolean} pub flag: share (true) or unshare (false) * @returns {Promise} A promise on a RequestResult * which contains an error or true on success */ function sharefile(p: string, pub: boolean): Promise; /** * Get VFS file meta-data * * @export * @param {string} p VFS file path * @returns {Promise} A promise on a [[RequestResult]] * which contains an error or an object of FileInfoType */ function fileinfo(p: string): Promise; /** * Read a VFS file content. There are many ways a VFS file can be read: * - Read as a raw text content * - Read as a javascript file, in this case the content of the * file will be executed * - Read as JSON object * * @export * @param {string} p path of the VFS file * @param {string} t return data type: * - jsonp: the response is an json object * - script: the response is a javascript code * - xml, html: the response is a XML/HTML object * - text: plain text * * @returns {Promise} A promise on a [[RequestResult]] * which contains an error or an object of [[FileInfoType]] */ function readfile(p: string, t: string): Promise; /** * Move a file to another location on server-side * * @export * @param {string} s VFS source file path * @param {string} d VFS destination file path * @returns {Promise} A promise on a [[RequestResult]] * which contains an error or a success response */ function move(s: string, d: string): Promise; /** * Delete a VFS file on the server-side * * @export * @param {string} p VFS file path * @returns {Promise} A promise on a [[RequestResult]] * which contains an error or a success response */ function remove(p: string): Promise; /** * Read the file as binary data * * @export * @param {string} p VFS file to be read * @returns {Promise} a Promise on an array buffer */ function fileblob(p: string): Promise; /** * Send a command to the serverside package manager * * @export * @param {PackageCommandType} d a package command of type PackageCommandType * @returns {Promise} a promise on a [[RequestResult]] */ function packages(d: PackageCommandType): Promise; /** * Upload file to the server via VFS interface * * @export * @param {string} d VFS destination directory path * @returns {Promise} a promise on a [[RequestResult]] */ function upload(d: string): Promise; /** * Write Base 64 encoded data to a VFS file * * @export * @param {string} p path to the VFS file * @param {string} d file data encoded in Base 64 * @returns {Promise} a promise on a [[RequestResult]] */ function write(p: string, d: string): Promise; /** * An apigateway allows client side to execute a custom server-side * script and get back the result. This gateway is particularly * useful in case of performing a task that is not provided by the core * API * * @export * @param {GenericObject} d execution indication, provided only when ws is `false` * otherwise, `d` should be written directly to the websocket stream as JSON object. * Two possible formats of `d`: * ```text * execute an server-side script file: * * { * path: [VFS path], * parameters: [parameters of the server-side script] * } * * or, execute directly a snippet of server-side script: * * { code: [server-side script code snippet as string] } * * ``` * * @param {boolean} ws flag indicate whether to use websocket for the connection * to the gateway API. In case of streaming data, the websocket is preferred * @returns {Promise} a promise on the result object (any) */ function apigateway(d: GenericObject, ws: boolean): Promise; /** * Check if a user is logged in * * @export * @returns {Promise} a promise on a [[RequestResult]] that * contains an error or a [[UserSettingType]] object */ function auth(): Promise; /** * Perform a login operation * * @export * @param {UserLoginType} d user data [[UserLoginType]] * @returns {Promise} a promise on a [[RequestResult]] that * contains an error or a [[UserSettingType]] object */ function login(d: UserLoginType): Promise; /** * Perform a logout operation * * @export * @returns {Promise} a promise on a [[RequestResult]] */ function logout(): Promise; /** * Save the current user settings * * @export * @returns {Promise} a promise on a [[RequestResult]] */ function setting(): Promise; /** * This is the low level function of AntOS VDB API. * It requests the server API to perform some simple * SQL query. * * @export * @param {string} cmd action to perform: save, delete, get, select * @param {GenericObject} d data object of the request based on each action: * - save: * ``` * { table: "table name", data: [record data object]} * ``` * - get: * ``` * { table: "table name", id: [record id]} * ``` * - delete: * ``` * { table: "table name", id: [record id]} * or * { table: "table name", cond: [conditional object]} * ``` * - select: * ``` * { table: "table name", cond: [conditional object]} * ``` * @returns {Promise} a promise of [[RequestResult]] on the * query data * * A conditional object represents a SQL condition statement as an object, * example: `pid = 10 AND cid = 2 ORDER BY date DESC` * ``` * { * exp: { * "and": { * pid: 10, * cid: 2 * } * }, * order: { * date: "DESC" * } * } * ``` */ function dbquery(cmd: string, d: GenericObject): Promise; } } } declare type VFSFileHandleClass = { new (...args: any[]): OS.API.VFS.BaseFileHandle; }; interface String { /** * Convert a string to VFS file handle. * * This function will create a file handle object from the string * with the help of [[VFS.findHandles]] * * @returns {OS.API.VFS.BaseFileHandle} * @memberof String */ asFileHandle(): OS.API.VFS.BaseFileHandle; } declare namespace OS { namespace API { /** * User permission data type * * @export * @interface UserPermissionType */ interface UserPermissionType { read: boolean; write: boolean; exec: boolean; } /** * VFS file meta-data data type * * @export * @interface FileInfoType */ interface FileInfoType { /** * File mime type * * @type {string} * @memberof FileInfoType */ mime: string; /** * File size * * @type {number} * @memberof FileInfoType */ size: number; /** * File name * * @type {string} * @memberof FileInfoType */ name: string; /** * File path * * @type {string} * @memberof FileInfoType */ path: string; /** * File type: * - `file` * - `dir` * - `app` * * @type {string} * @memberof FileInfoType */ type: string; /** * File permission * * @type {{ * group: UserPermissionType; * owner: UserPermissionType; * other: UserPermissionType; * }} * @memberof FileInfoType */ perm?: { /** * Group permission * * @type {UserPermissionType} */ group: UserPermissionType; /** * Owner permission * * @type {UserPermissionType} */ owner: UserPermissionType; /** * Other permission * * @type {UserPermissionType} */ other: UserPermissionType; }; /** * Creation time * * @type {string} * @memberof FileInfoType */ ctime?: string; /** * Modification time * * @type {string} * @memberof FileInfoType */ mtime?: string; /** * Group id * * @type {number} * @memberof FileInfoType */ gid?: number; /** * User id * * @type {number} * @memberof FileInfoType */ uid?: number; [propName: string]: any; } /** * This namespace is dedicated to all APIs related to * AntOS Virtual File System (VFS) */ namespace VFS { /** * Placeholder stores VFS file protocol patterns and its attached file handle class. * */ const handles: GenericObject; /** * Register a protocol to a handle class * * @export * @param {string} protos VFS protocol pattern * @param {VFSFileHandleClass} cls handle class */ function register(protos: string, cls: VFSFileHandleClass): void; /** * Looking for a attached file handle class of a string protocol * * When converting a string to file handle, the system will look * for a protocol pattern in the string, if the protocol found, * its attached handle class (found in [[VFS.handles]]) will be * used to initialize a file handle object from the string * * ```typescript * "home://data/test.txt".asFileHandle() // -> an instance of RemoteFileHandle * ``` * @export * @param {string} proto protocol string * @returns {VFSFileHandleClass[]} */ function findHandles(proto: string): VFSFileHandleClass[]; /** * Abstract prototype of all all VFS file handle definition. * * This prototype provides a standardized interface to access * to different underlay file systems such as remote file, * cloud file (Dropbox, Google drive, etc.), URL or memory-based file * * @export * @abstract * @class BaseFileHandle */ abstract class BaseFileHandle { /** * Flag indicates whether the file is dirty * * @type {boolean} * @memberof BaseFileHandle */ dirty: boolean; /** * Once read, file content will be cached in this placeholder * * @type {*} * @memberof BaseFileHandle */ cache: any; /** * Flag indicated whether the file meta-data is loaded * * @type {boolean} * @memberof BaseFileHandle */ ready: boolean; /** * File path * * @type {string} * @memberof BaseFileHandle */ path: string; /** * File protocol e.g: * - `os://` * - `home://` * * @type {string} * @memberof BaseFileHandle */ protocol: string; /** * List of path segments * * @type {string[]} * @memberof BaseFileHandle */ genealogy: string[]; /** * File base name * * @type {string} * @memberof BaseFileHandle */ basename: string; /** * Once loaded, [[ready]] will be set to true and * file meta-data will be stored in this place holder * * @type {FileInfoType} * @memberof BaseFileHandle */ info: FileInfoType; /** * File extension * * @type {string} * @memberof BaseFileHandle */ ext: string; /** * * File type * @type {string} * @memberof BaseFileHandle */ type: string; /** *Creates an instance of BaseFileHandle. * @param {string} path file path * @memberof BaseFileHandle */ constructor(path: string); /** * Set a file path to the current file handle * * @param {string} p * @returns {void} * @memberof BaseFileHandle */ setPath(p: string): void; /** * Getter: Get the file basename * Setter: set the file name * * @returns {string} * @memberof BaseFileHandle */ get filename(): string; set filename(v: string); /** * Set data to the file cache * * @param {*} v data object * @returns {BaseFileHandle} * @memberof BaseFileHandle */ setCache(v: any): BaseFileHandle; /** * Return the object itself * * @returns {BaseFileHandle} * @memberof BaseFileHandle */ asFileHandle(): BaseFileHandle; /** * Check whether the current file is the root of the file tree * * @returns {boolean} * @memberof BaseFileHandle */ isRoot(): boolean; /** * Check whether the current file is a hidden file * * @returns {boolean} * @memberof BaseFileHandle */ isHidden(): boolean; /** * Get hash number of the current file path * * @returns {number} * @memberof BaseFileHandle */ hash(): number; /** * Convert the current file cache to Base64 * * @protected * @param {string} t type of the file cache: * - `object` * - `mime type` * @returns {(Promise)} promise on the converted data * @memberof BaseFileHandle */ protected b64(t: string): Promise; /** * Get the parent file handle of the current file * * @returns {BaseFileHandle} * @memberof BaseFileHandle */ parent(): BaseFileHandle; /** * Load the file meta-data before performing * any task * * @returns {Promise} a promise on file meta-data * @memberof BaseFileHandle */ onready(): Promise; /** * Public read operation * * This function calls the [[_rd]] function to perform the operation. * * If the current file is a directory, then the operation * will return the meta-data of all files inside of the directory. * Otherwise, file content will be returned * * @param {string} t data type * - jsonp: the response is an json object * - script: the response is a javascript code * - xml, html: the response is a XML/HTML object * - text: plain text * - binary * * @returns {Promise} a promise on the file content * @memberof BaseFileHandle */ read(t?: string): Promise; /** * Write the file cache to the actual file * * This function calls the [[_wr]] function to perform the operation * * @param {string} t data type * - `base64` * - `object` * - `mime type` * * @returns {Promise} promise on the operation result * @memberof BaseFileHandle */ write(t: string): Promise; /** * Sub-directory creation * * This function calls the [[_mk]] function to perform the operation * * @param {string} d sub directory name * @returns {Promise} promise on the operation result * @memberof BaseFileHandle */ mk(d: string): Promise; /** * Delete the file * * This function calls the [[_rm]] function to perform the operation * * @returns {Promise} promise on the operation result * @memberof BaseFileHandle */ remove(): Promise; /** * Upload a file to the current directory * * Only work when the current file is a directory * * This function calls the [[_up]] function to perform the operation * * @returns {Promise} promise on the operation result * @memberof BaseFileHandle */ upload(): Promise; /** * Share the file by publish it. * * Only work with file * * This function calls the [[_pub]] function to perform the operation * * @returns {Promise} promise on operation result * @memberof BaseFileHandle */ publish(): Promise; /** * Download the file. * * Only work with file * * This function calls the [[_down]] function to perform the operation * * @returns {Promise} Promise on the operation result * @memberof BaseFileHandle */ download(): Promise; /** * Move the current file to another location * * This function calls the [[_mv]] function to perform the operation * * @param {string} d destination location * @returns {Promise} promise on the operation result * @memberof BaseFileHandle */ move(d: string): Promise; /** * Execute the current file. * * This action depends on each file protocol * * This function calls the [[_exec]] function to perform the operation * * @returns {Promise} * @memberof BaseFileHandle */ execute(): Promise; /** * Get an accessible link to the file * that can be accessed from the browser * * @returns {string} * @memberof BaseFileHandle */ getlink(): string; /** * Helper function returns a promise on unsupported action * * @param {string} t action name * @returns {Promise} * @memberof BaseFileHandle */ protected unsupported(t: string): Promise; /** * Low level protocol-specific read operation * * This function should be overridden on the file handle class * that supports the operation * * @protected * @param {string} t data type, see [[read]] * @returns {Promise} * @memberof BaseFileHandle */ protected _rd(t: string): Promise; /** * Low level protocol-specific write operation * * This function should be overridden by the file handle class * that supports the operation * * @protected * @param {string} t data type, see [[write]] * @param {*} [d] * @returns {Promise} * @memberof BaseFileHandle */ protected _wr(t: string, d?: any): Promise; /** * Low level protocol-specific sub-directory creation * * This function should be overridden by the file handle class * that supports the operation * * @protected * @param {string} d sub directory name * @returns {Promise} * @memberof BaseFileHandle */ protected _mk(d: string): Promise; /** * Low level protocol-specific delete operation * * This function should be overridden by the file handle class * that supports the operation * * @returns {Promise} * @memberof BaseFileHandle */ protected _rm(): Promise; /** * Low level protocol-specific move operation * * This function should be overridden by the file handle class * that supports the operation * * @protected * @param {string} d * @returns {Promise} * @memberof BaseFileHandle */ protected _mv(d: string): Promise; /** * Low level protocol-specific upload operation * * This function should be overridden by the file handle class * that supports the operation * * @returns {Promise} * @memberof BaseFileHandle */ protected _up(): Promise; /** * Low level protocol-specific download operation * * This function should be overridden by the file handle class * that supports the operation * * @returns {Promise} * @memberof BaseFileHandle */ protected _down(): Promise; /** * Low level protocol-specific execute operation * * This function should be overridden by the file handle class * that supports the operation * * @returns {Promise} * @memberof BaseFileHandle */ protected _exec(): Promise; /** * Low level protocol-specific share operation * * This function should be overridden by the file handle class * that supports the operation * * @returns {Promise} * @memberof BaseFileHandle */ protected _pub(): Promise; /** * Read the current file meta-data * * should be implemented by subclasses * * @abstract * @returns {Promise} * @memberof BaseFileHandle */ abstract meta(): Promise; } /** * Remote file handle allows to perform file operation * on AntOS remote server files. Its protocol is defined * by the following pattern: * * ``` * ^(home|desktop|os|Untitled)$ * ``` * * @class RemoteFileHandle * @extends {BaseFileHandle} */ class RemoteFileHandle extends BaseFileHandle { /** *Creates an instance of RemoteFileHandle. * @param {string} path file path * @memberof RemoteFileHandle */ constructor(path: string); /** * Read remote file meta-data * * @returns {Promise} * @memberof RemoteFileHandle */ meta(): Promise; /** * Remote file access link * * @returns {string} * @memberof RemoteFileHandle */ getlink(): string; /** * Read remote file content. * * If the current file is a directory, then the operation * will return the meta-data of all files inside of the directory. * Otherwise, file content will be returned * * @protected * @param {string} t data type see [[read]] * @returns {Promise} * @memberof RemoteFileHandle */ protected _rd(t: string): Promise; /** * Write file cache to the remote file * * @protected * @param {string} t data type see [[write]] * @returns {Promise} * @memberof RemoteFileHandle */ protected _wr(t: string): Promise; /** * Create sub directory * * Only work on directory file handle * * @protected * @param {string} d sub directory name * @returns {Promise} * @memberof RemoteFileHandle */ protected _mk(d: string): Promise; /** * Delete file/folder * * @protected * @returns {Promise} * @memberof RemoteFileHandle */ protected _rm(): Promise; /** * Move file/folder * * @protected * @param {string} d * @returns {Promise} * @memberof RemoteFileHandle */ protected _mv(d: string): Promise; /** * Upload a file * * Only work with directory file handle * * @protected * @returns {Promise} * @memberof RemoteFileHandle */ protected _up(): Promise; /** * Download a file * * only work with file * * @protected * @returns {Promise} * @memberof RemoteFileHandle */ protected _down(): Promise; /** * Publish a file * * @protected * @returns {Promise} * @memberof RemoteFileHandle */ protected _pub(): Promise; } /** * Package file is remote file ([[RemoteFileHandle]]) located either in * the local user packages location or system packages * location, it should be in the following format: * * ``` * pkg://PKG_NAME/path/to/file * * ``` * * The system will locale the package name PKG_NAME either in the system domain * or in user domain and return the correct path to the package * * @export * @class PackageFileHandle * @extends {RemoteFileHandle} */ class PackageFileHandle extends RemoteFileHandle { /** *Creates an instance of PackageFileHandle. * @param {string} pkg_path package path in string * @memberof PackageFileHandle */ constructor(pkg_path: string); } /** * Application file is an AntOS special file allowing to * refer to an application as a regular file. Its protocol * pattern is defined as: * * ```typescript * "^app$" // e.g. app://Setting * ``` * * @class ApplicationHandle * @extends {BaseFileHandle} */ class ApplicationHandle extends BaseFileHandle { /** *Creates an instance of ApplicationHandle. * @param {string} path file path * @memberof ApplicationHandle */ constructor(path: string); /** * Read application meta-data * * @returns {Promise} * @memberof ApplicationHandle */ meta(): Promise; /** * If the current file is root (e.g. `app://`), the operation * will return all system packages meta-data. * * Otherwise, an error will be thrown * * @protected * @param {string} t * @returns {Promise} * @memberof ApplicationHandle */ protected _rd(t: string): Promise; } /** * A buffer file handle represents a virtual file that is stored * on the system memory. Its protocol pattern is defined as: * * ```typescript * "^mem$" // e.g. mem://test.txt * ``` * * @class BufferFileHandle * @extends {BaseFileHandle} */ class BufferFileHandle extends BaseFileHandle { /** *Creates an instance of BufferFileHandle. * @param {string} path file path * @param {string} mime file mime-type * @param {*} data file data * @memberof BufferFileHandle */ constructor(path: string, mime: string, data: any); /** * Read the file meta-data * * @returns {Promise} * @memberof BufferFileHandle */ meta(): Promise; /** * Read file content stored in the file cached * * @protected * @param {string} t data type see [[read]] * @returns {Promise} * @memberof BufferFileHandle */ protected _rd(t: string): Promise; /** * Write data to the file cache * * @protected * @param {string} t data type, see [[write]] * @param {*} d data * @returns {Promise} * @memberof BufferFileHandle */ protected _wr(t: string, d: any): Promise; /** * Download the buffer file * * @protected * @returns {Promise} * @memberof BufferFileHandle */ protected _down(): Promise; } /** * URL file handle represents a HTTP/HTTPs link url * as an AntOS VFS file handle. Its protocol is defined as * * ``` * ^(http|https|ftp)$ * ``` * * @class URLFileHandle * @extends {BaseFileHandle} */ class URLFileHandle extends BaseFileHandle { /** *Creates an instance of URLFileHandle. * @param {string} path * @memberof URLFileHandle */ constructor(path: string); /** * Read file meta-data * * @returns {Promise} * @memberof URLFileHandle */ meta(): Promise; /** * Read URL content * * @protected * @param {string} t data type see [[read]] * @returns {Promise} * @memberof URLFileHandle */ protected _rd(t: string): Promise; } /** * Shared file handle represents all AntOS shared file. * Its protocol is defined as: * * ``` * ^shared$ * ``` * * @class SharedFileHandle * @extends {API.VFS.BaseFileHandle} */ class SharedFileHandle extends API.VFS.BaseFileHandle { /** *Creates an instance of SharedFileHandle. * @param {string} path file path * @memberof SharedFileHandle */ constructor(path: string); /** * Read file meta-data * * @returns {Promise} * @memberof SharedFileHandle */ meta(): Promise; /** * Read file content * * @protected * @param {string} t data type, see [[read]] * @returns {Promise} * @memberof SharedFileHandle */ protected _rd(t: string): Promise; /** * write data to shared file * * @protected * @param {string} t data type, see [[write]] * @param {string} d file data * @returns {Promise} * @memberof SharedFileHandle */ protected _wr(t: string, d: string): Promise; /** * Un-publish the file * * @protected * @returns {Promise} * @memberof SharedFileHandle */ protected _rm(): Promise; /** * Download shared file * * @protected * @returns {Promise} * @memberof SharedFileHandle */ protected _down(): Promise; /** * Un publish the file * * @protected * @returns {Promise} * @memberof SharedFileHandle */ protected _pub(): Promise; } /**Utilities global functions */ /** * Read a file content from a zip archive * * The content type should be: * - base64 : the result will be a string, the binary in a base64 form. * - text (or string): the result will be an unicode string. * - binarystring: the result will be a string in “binary” form, using 1 byte per char (2 bytes). * - array: the result will be an Array of bytes (numbers between 0 and 255). * - uint8array : the result will be a Uint8Array. This requires a compatible browser. * - arraybuffer : the result will be a ArrayBuffer. This requires a compatible browser. * - blob : the result will be a Blob. This requires a compatible browser. * * If file_name is not specified, the first file_name in the zip archive will be read * @export * @param {string} file zip file * @param {string} type content type to read * @param {string} [file_name] the file should be read from the zip archive * @return {*} {Promise} */ function readFileFromZip(file: string, type: string, file_name?: string): Promise; /** * Cat all files to a single out-put * * @export * @param {string[]} list list of VFS files * @param {string} data input data string that will be cat to the files content * @param {string} join_by join on files content by this string * @return {*} {Promise} */ function cat(list: string[], data: string, join_by?: string): Promise; /** * Read all files content on the list * * @export * @param {string[]} list list of VFS files * @param {GenericObject[]} contents content array * @return {void} */ function read_files(list: string[]): Promise[]>; /** * Copy files to a folder * * @export * @param {string[]} files list of files * @param {string} to destination folder * @return {*} {Promise} */ function copy(files: string[], to: string): Promise; /** * Create a zip archive from a folder * * @export * @param {string} src source file/folder * @param {string} dest destination archive * @return {*} {Promise} */ function mkar(src: string, dest: string): Promise; /** * Create a list of directories * * @export * @param {string[]} list of directories to be created * @param {boolen} sync sync/async of directory creation * @return {*} {Promise} */ function mkdirAll(list: string[], sync?: boolean): Promise; /** * * * @export Extract a zip fle * @param {string} zfile zip file to extract * @param {(zip:any) => Promise} [dest_callback] a callback to get extraction destination * @return {*} {Promise} */ function extractZip(zfile: string | API.VFS.BaseFileHandle, dest_callback: (zip: any) => Promise): Promise; /** * Make files from a set of template files * * @export * @param {Array} list mapping paths between templates files and created files * @param {string} path files destination * @param {(data: string) => string} callback: pre-processing files content before writing to destination files * @return {*} {Promise} */ function mktpl(list: Array, path: string, callback: (data: string) => string): Promise; } } } declare namespace OS { namespace GUI { namespace tag { /** * A tile layout organize it child elements * in a fixed horizontal or vertical direction. * * The size of each child element is attributed based * on its configuration of automatically based on the * remaining space in the layout * * * @export * @class TileLayoutTag * @extends {AFXTag} */ class TileLayoutTag extends AFXTag { /** *C reates an instance of TileLayoutTag. * @memberof TileLayoutTag */ constructor(); /** * Do nothing * * @protected * @memberof TileLayoutTag */ protected init(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof TileLayoutTag */ protected reload(d?: any): void; /** * Setter: Set the name of the tile container, should be: `hbox` or `vbox` * * Getter: Get the name of the tile container * * @memberof TileLayoutTag */ set name(v: string); get name(): string; /** * Setter: * * SET the layout direction, should be: * - `row`: horizontal direction * - `column`: vertical direction * * Getter: * * Get layout direction * * @memberof TileLayoutTag */ set dir(v: "row" | "column"); get dir(): "row" | "column"; /** * Mount the element * * @protected * @returns {void} * @memberof TileLayoutTag */ protected mount(): void; /** * re-organize the layout * * @returns {void} * @memberof TileLayoutTag */ calibrate(): void; /** * Organize the layout in horizontal direction, only work when * the layout direction set to horizontal * * @private * @returns {void} * @memberof TileLayoutTag */ private hcalibrate; /** * Organize the layout in vertical direction, only work when * the layout direction set to vertical * * @private * @returns {void} * @memberof TileLayoutTag */ private vcalibrate; /** * Layout definition * * @returns * @memberof TileLayoutTag */ layout(): { el: string; ref: string; }[]; } /** * A HBox organize its child elements in horizontal direction * * @export * @class HBoxTag * @extends {TileLayoutTag} */ class HBoxTag extends TileLayoutTag { /** * Creates an instance of HBoxTag. * @memberof HBoxTag */ constructor(); /** * Mount the tag * * @protected * @memberof HBoxTag */ protected mount(): void; } /** * A VBox organize its child elements in vertical direction * * @export * @class VBoxTag * @extends {TileLayoutTag} */ class VBoxTag extends TileLayoutTag { /** *Creates an instance of VBoxTag. * @memberof VBoxTag */ constructor(); /** * Mount the tag * * @protected * @memberof VBoxTag */ protected mount(): void; } } } } /// declare namespace OS { namespace GUI { namespace tag { /** * A `resizer` tag is basically used to dynamically resize an element using mouse. * It is usually put inside a [[TileLayoutTag]] an can be attached to any element. Example: * * The resizer tag in the following example will be attached to the first `afx-vbox`, * and allows to resize this element using mouse * * ```xml * * ... * * ... * * ``` * * @export * @class ResizerTag * @extends {AFXTag} */ class ResizerTag extends AFXTag { /** * Reference to the element that this tag is attached to * * @private * @type {*} * @memberof ResizerTag */ private _resizable_el; /** * Reference to the resize event callback * * @private * @type {TagEventCallback} * @memberof ResizerTag */ private _onresize; /** * Reference to the parent tag of the current tag. * The parent tag should be an instance of a [[TileLayoutTag]] * such as [[VBoxTag]] or [[HBoxTag]] * * @private * @type {*} * @memberof ResizerTag */ private _parent; /** * Placeholder of the minimum value that * the attached element can be resized * * @private * @type {number} * @memberof ResizerTag */ private _minsize; /** *Creates an instance of ResizerTag. * @memberof ResizerTag */ constructor(); /** * Set the properties of the tag to default values * * @protected * @memberof ResizerTag */ protected init(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof ResizerTag */ protected reload(d?: any): void; /** * Setter: * * Set resize direction, two possible values: * - `hz` - horizontal direction, resize by width * - `ve` - vertical direction, resize by height * * Getter: * * Get the resize direction * * @memberof ResizerTag */ set dir(v: string); get dir(): string; /** * Getter : Check whether the resizer should attach to its next or previous element * * Setter: if `v=true` select next element as attached element of the resizer, otherwise * select the previous element * @readonly * @type {boolean} * @memberof ResizerTag */ get attachnext(): boolean; set attachnext(v: boolean); /** * Setter: * - set the resize event callback * * Getter: * - get the resize event callback * * @memberof ResizerTag */ set onelresize(v: TagEventCallback); get onelresize(): TagEventCallback; /** * Mount the tag to the DOM tree * * @protected * @memberof ResizerTag */ protected mount(): void; /** * Enable draggable on the element * * @private * @memberof ResizerTag */ private make_draggable; /** * Resize the attached element in the horizontal direction (width) * * @private * @param {JQuery.MouseEventBase} e JQuery mouse event * @returns {void} * @memberof ResizerTag */ private horizontalResize; /** * Resize the attached element in the vertical direction (height) * * @protected * @param {JQuery.MouseEventBase} e JQuery mouse event * @returns {void} * @memberof ResizerTag */ protected verticalResize(e: JQuery.MouseEventBase): void; /** * Layout definition of the tag, empty layout * * @protected * @returns {TagLayoutType[]} * @memberof ResizerTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * Definition of system file view widget * * @export * @class FileViewTag * @extends {AFXTag} */ class FileViewTag extends AFXTag { /** * placeholder for file select event callback * * @private * @type {TagEventCallback} * @memberof FileViewTag */ private _onfileselect; /** * placeholder for file open event callback * * @private * @type {TagEventCallback} * @memberof FileViewTag */ private _onfileopen; /** * Reference to the currently selected file meta-data * * @private * @type {API.FileInfoType} * @memberof FileViewTag */ private _selectedFile; /** * Data placeholder of the current working directory * * @private * @type {API.FileInfoType[]} * @memberof FileViewTag */ private _data; /** * The path of the current working directory * * @private * @type {string} * @memberof FileViewTag */ private _path; /** * Header definition of the widget grid view * * @private * @type {(GenericObject[])} * @memberof FileViewTag */ private _header; /** * placeholder for the user-specified meta-data fetch function * * @private * @memberof FileViewTag */ private _fetch; /** *Creates an instance of FileViewTag. * @memberof FileViewTag */ constructor(); /** * Init the widget before mounting * * @protected * @memberof FileViewTag */ protected init(): void; /** * Update the current widget, do nothing * * @protected * @param {*} [d] * @memberof FileViewTag */ protected reload(d?: any): void; /** * set the function that allows to fetch file entries. * This handle function should return a promise on * an arry of [[API.FileInfoType]] * * @memberof FileViewTag */ set fetch(v: (p: string) => Promise); /** * set the callback handle for the file select event. * The parameter of the callback should be an object * of type [[TagEventType]] with the data type `T` is [[API.FileInfoType]] * * @memberof FileViewTag */ set onfileselect(e: TagEventCallback); /** set the callback handle for the file open event. * The parameter of the callback should be an object * of type [[TagEventType]] with the data type `T` is [[API.FileInfoType]] * * @memberof FileViewTag */ set onfileopen(e: TagEventCallback); /** * Setter: * * chang the view of the widget, there are three different views * - `icon` * - `list` * - `tree` * * Getter: * * Get the current view setting of the widget * * @memberof FileViewTag */ set view(v: string); get view(): string; /** * Setter: * * Turn on/off the changing current working directory feature * of the widget when a directory is double clicked. If enabled, * the widget will use the configured [[fetch]] function to query * the content of the selected directory * * Getter: * * check whether changing current working directory feature * is enabled * * @memberof FileViewTag */ set chdir(v: boolean); get chdir(): boolean; /** * Setter : Enable or disable the status bar of the widget * * Getter: Check whether the status bar is enabled * * @memberof FileViewTag */ set status(v: boolean); get status(): boolean; /** * Setter: * * Allow the widget to show or hide hidden file * * Getter: * * Check whether the hidden file should be shown in * the widget * * @memberof FileViewTag */ set showhidden(v: boolean); get showhidden(): boolean; /** * Get the current selected file * * @readonly * @type {API.FileInfoType} * @memberof FileViewTag */ get selectedFile(): API.FileInfoType; /** * Setter: * * Set the path of the current working directory. * When called the widget will refresh the current * working directory using the configured [[fetch]] * function * * Getter: * * Get the path of the current working directory * * @memberof FileViewTag */ set path(v: string); get path(): string; /** * Setter: Set the data of the current working directory * * Getter: Get the data of the current working directory * * @memberof FileViewTag */ set data(v: API.FileInfoType[]); get data(): API.FileInfoType[]; /** * Set the file drag and drop event handle. This allows application * to define custom behavior of the event * * @memberof FileViewTag */ set ondragndrop(v: TagEventCallback>); /** * Sort file by its type * * @private * @param {API.FileInfoType} a * @param {API.FileInfoType} b * @return {*} {number} * @memberof FileViewTag */ private sortByType; /** * sort file by its name * * @private * @param {API.FileInfoType} a first file meta-data * @param {API.FileInfoType} b second file meta-data * @returns {number} * @memberof FileViewTag */ private sortByName; /** * calibrate the widget layout * * @memberof FileViewTag */ calibrate(): void; /** * Refresh the list view of the widget. This function * is called when the view of the widget changed to `icon` * * @private * @memberof FileViewTag */ private refreshList; /** * Refresh the grid view of the widget, this function is called * when the view of the widget set to `list` * * @private * @memberof FileViewTag */ private refreshGrid; /** * Refresh the Treeview of the widget, this function is called * when the view of the widget set to `tree` * * @private * @memberof FileViewTag */ private refreshTree; /** * Create the tree data from the list of input * file meta-data * * @private * @param {API.FileInfoType[]} data list of file meta-data * @returns {TreeViewDataType[]} * @memberof FileViewTag */ private getTreeData; /** * Refresh data of the current widget view * * @private * @returns {void} * @memberof FileViewTag */ private refreshData; /** * Switch between three view options * * @private * @memberof FileViewTag */ private switchView; /** * This function triggers the file select event * * @private * @param {API.FileInfoType} e selected file meta-data * @memberof FileViewTag */ private fileselect; /** * This function triggers the file open event * * @private * @param {API.FileInfoType} e selected file meta-data * @memberof FileViewTag */ private filedbclick; /** * Mount the widget in the DOM tree * * @protected * @memberof FileViewTag */ protected mount(): void; /** * Layout definition of the widget * * @protected * @returns {TagLayoutType[]} * @memberof FileViewTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * Tree view data type definition * * @export * @interface TreeViewDataType */ interface TreeViewDataType { /** * The child nodes data of the current tree node * * @type {TreeViewDataType[]} * @memberof TreeViewDataType */ nodes?: TreeViewDataType[]; /** * Boolean indicates whether the current node is opened. * Only work when the current node is not a leaf node * * @type {boolean} * @memberof TreeViewDataType */ open?: boolean; /** * The node's path from the root node * * @type {string} * @memberof TreeViewDataType */ path?: string; /** * Indicates whether this node should be selected * * @type {boolean} * @memberof TreeViewDataType */ selected?: boolean; [propName: string]: any; } /** * Tree node event data type definition */ type TreeItemEventData = TagEventDataType; /** * Abstract prototype of a tree node. All tree node definition should * extend this class * * @class TreeViewItemPrototype * @extends {AFXTag} */ abstract class TreeViewItemPrototype extends AFXTag { /** * Node data placeholder * * @private * @type {TreeViewDataType} * @memberof TreeViewItemPrototype */ private _data; /** * Placeholder for the indent level of the current node from root node * * @private * @type {number} * @memberof TreeViewItemPrototype */ private _indent; /** * private event object used by current node event * * @private * @type {TagEventType} * @memberof TreeViewItemPrototype */ private _evt; /** * Reference to the root node * * @type {TreeViewTag} * @memberof TreeViewItemPrototype */ treeroot: TreeViewTag; /** * The tree path from the root node * * @type {string} * @memberof TreeViewItemPrototype */ treepath: string; /** * Reference to the parent node of the current node * * @type {TreeViewTag} * @memberof TreeViewItemPrototype */ parent: TreeViewTag; /** * Placeholder for the `fetch` function of the node. * This function is used to fetch the child nodes of the * current nodes. This function should return a promise on * a list of [[TreeViewDataType]] * * @memberof TreeViewItemPrototype */ fetch: (d: TreeViewItemPrototype) => Promise; /** *Creates an instance of TreeViewItemPrototype. * @memberof TreeViewItemPrototype */ constructor(); /** * Update the tree, this function * is used to refresh/expand/collapse the * current node based on the input parameter * * @protected * @param {*} p string indication, the value should be: * - `expand`: expand the current node * - `collapse`: collapse the current node * - other string: this string is considered as a tree path of a node. If this value * is the value of current node tree path, the node will be refreshed. Otherwise, nothing * happens * @returns {void} * @memberof TreeViewItemPrototype */ protected reload(p: any): void; /** * Setter: * * Set the data of the current node. This will trigger the * [[ondatachange]] function * * Getter: * * Get the current node's data * * @memberof TreeViewItemPrototype */ set data(v: TreeViewDataType); get data(): TreeViewDataType; /** * Setter: * * Select or unselect the current node. * This will trigger the item select event * on the tree root if the parameter is `true` * * Getter: * * Check whether the current node is selected * * @memberof TreeViewItemPrototype */ set selected(v: boolean); get selected(): boolean; /** * Setter: * * Refresh the current node and expands its sub tree. * This function only works if the current node is not * a leaf node * * Getter: * * Check whether the current node is expanded * * @memberof TreeViewItemPrototype */ set open(v: boolean); get open(): boolean; /** * Setter: Set the current indent level of this node from the root node * * Getter: Get the current indent level * * @type {number} * @memberof TreeViewItemPrototype */ get indent(): number; set indent(v: number); /** * Check whether the current node is not a leaf node * * @private * @returns {boolean} * @memberof TreeViewItemPrototype */ private is_folder; /** * Getter: Get the child nodes data of the current node * * Setter: Set the child nodes data of the current node * * @type {TreeViewDataType[]} * @memberof TreeViewItemPrototype */ get nodes(): TreeViewDataType[]; set nodes(nodes: TreeViewDataType[]); /** * Init the tag with default properties data * * @protected * @memberof TreeViewItemPrototype */ protected init(): void; /** * Mount the tag and bind basic events * * @protected * @memberof TreeViewItemPrototype */ protected mount(): void; /** * Layout definition of a node. This function * returns the definition of the base outer layout * of a node. Custom inner layout of the node should * be defined in the [[itemlayout]] function * * @protected * @returns {TagLayoutType[]} * @memberof TreeViewItemPrototype */ protected layout(): TagLayoutType[]; /** * This function need to be implemented by all subclasses * to define the inner layout of the node * * @protected * @abstract * @returns {TagLayoutType[]} * @memberof TreeViewItemPrototype */ protected abstract itemlayout(): TagLayoutType[]; /** * This function is called when the node data change. * It needs to be implemented on all subclasses of this * class * * @protected * @abstract * @memberof TreeViewItemPrototype */ protected abstract ondatachange(): void; } /** * SimpleTreeViewItem extends [[TreeViewItemPrototype]] and * define it inner layout using a [[LabelTag]] * * @export * @class SimpleTreeViewItem * @extends {TreeViewItemPrototype} */ class SimpleTreeViewItem extends TreeViewItemPrototype { /** *Creates an instance of SimpleTreeViewItem. * @memberof SimpleTreeViewItem */ constructor(); /** * Refresh the label when data changed * * @protected * @returns {void} * @memberof SimpleTreeViewItem */ protected ondatachange(): void; /** * Inner layout definition * * @protected * @returns * @memberof SimpleTreeViewItem */ protected itemlayout(): { el: string; ref: string; }[]; } /** * A tree view widget presents a hierarchical list of nodes. * * @export * @class TreeViewTag * @extends {AFXTag} */ class TreeViewTag extends AFXTag { /** * Reference to the selected node * * @private * @type {TreeViewItemPrototype} * @memberof TreeViewTag */ private _selectedItem; /** * Placeholder for tree select event handle * * @private * @type {TagEventCallback} * @memberof TreeViewTag */ private _ontreeselect; /** * Place holder for tree double click event handle * * @private * @type {TagEventCallback} * @memberof TreeViewTag */ private _ontreedbclick; /** * Placeholder for drag and drop event handle * * @private * @type {TagEventCallback>} * @memberof TreeViewTag */ private _ondragndrop; /** * Tree data placeholder * * @private * @type {TreeViewDataType} * @memberof TreeViewTag */ private _data; /** * Placeholder for private dragndrop mouse down event handle * * @private * @memberof TreeViewTag */ private _treemousedown; /** * Placeholder for private dragndrop mouse up event handle * * @private * @memberof TreeViewTag */ private _treemouseup; /** * Placeholder for private dragndrop mouse move event handle * * @private * @memberof TreeViewTag */ private _treemousemove; /** * Private data object passing between dragndrop mouse event * * @private * @type {{ from: TreeViewTag; to: TreeViewTag }} * @memberof TreeViewTag */ private _dnd; /** * Reference to parent tree of the current tree. * This value is undefined if the current tree is the root * * @type {TreeViewTag} * @memberof TreeViewTag */ parent: TreeViewTag; /** * Reference to the root tree, this value is undefined * if the curent tree is root * * @type {TreeViewTag} * @memberof TreeViewTag */ treeroot: TreeViewTag; /** * tree path of the current tree from the root * * @type {string} * @memberof TreeViewTag */ treepath: string; /** * Indent level of the current tree * * @type {number} * @memberof TreeViewTag */ indent: number; /** * Indicates whether the tree should be expanded * * @type {boolean} * @memberof TreeViewTag */ open: boolean; /** * Placeholder for the `fetch` function of the tree. * This function is used to fetch the child nodes of the * current tree. This function should return a promise on * a list of [[TreeViewDataType]] * * @memberof TreeViewItemPrototype */ fetch: (d: TreeViewItemPrototype) => Promise; /** *Creates an instance of TreeViewTag. * @memberof TreeViewTag */ constructor(); /** * Init the tree view before mounting: * * @protected * @memberof TreeViewTag */ protected init(): void; /** * Layout definition * * @protected * @returns {TagLayoutType[]} * @memberof TreeViewTag */ protected layout(): TagLayoutType[]; /** * Do nothing * * @protected * @param {*} [d] * @memberof TreeViewTag */ protected reload(d?: any): void; /** * Setter: Enable/disable drag and drop event on the tree * * Getter: Check whether the drag and drop event is enabled * * @memberof TreeViewTag */ set dragndrop(v: boolean); get dragndrop(): boolean; /** * Set the tree select event handle * * @memberof TreeViewTag */ set ontreeselect(v: TagEventCallback); /** * Set the tree double click event handle * * @memberof TreeViewTag */ set ontreedbclick(v: TagEventCallback); /** * Setter: * * Set the default tag name of the tree node. * If there is no tag name in the node data, * this value will be used when creating node. * * Defaut to `afx-tree-view-item` * * Getter: * * Get the default node tag name * * @memberof TreeViewTag */ set itemtag(v: string); get itemtag(): string; /** * Unselect the selected element in the tree * * @memberof TreeViewTag */ unselect(): void; /** * Setter: Set the selected node using its DOM element * * Getter: Get the DOM element of the selected node * * @type {TreeViewItemPrototype} * @memberof TreeViewTag */ get selectedItem(): TreeViewItemPrototype; set selectedItem(v: TreeViewItemPrototype); /** * Expand all nodes in the tree * * @returns {void} * @memberof TreeViewTag */ expandAll(): void; /** * Collapse all nodes in the tree * * @returns {void} * @memberof TreeViewTag */ collapseAll(): void; /** * This function will trigger the tree select or tree double click * event * * @param {TagEventType} e * @returns {void} * @memberof TreeViewTag */ itemclick(e: TagEventType): void; /** * Check whether the current tree is a root tree * * @returns {boolean} * @memberof TreeViewTag */ is_root(): boolean; /** * Check whether the current tree tag is a leaf * * @returns {boolean} * @memberof TreeViewTag */ is_leaf(): boolean; /** * Set drag and drop event handle * * @memberof TreeViewTag */ set ondragndrop(v: TagEventCallback>); /** * Setter: * * Set the tree data. This operation will create * all tree node elements of the current tree * * Getter: * * Get the tree data * * @memberof TreeViewTag */ set data(v: TreeViewDataType); get data(): TreeViewDataType; /** * Mount the tree view * * @protected * @memberof TreeViewTag */ protected mount(): void; } } } } declare namespace OS { namespace GUI { /** * Tab container data type definition * * @export * @interface TabContainerTabType */ interface TabContainerTabType { /** * Reference to the DOM element of the current container * * @type {HTMLElement} * @memberof TabContainerTabType */ container: HTMLElement; [propName: string]: any; } namespace tag { /** * A tab container allows to attach each tab on a [[TabBarTag]] * with a container widget. The attached container widget should be * composed inside a [[HBoxTag]] * * The tab bar in a tab container can be configured to display tabs * in horizontal (row) or vertical (column) order. Default to vertical order * * Once a tab is selected, its attached container will be shown * * @export * @class TabContainerTag * @extends {AFXTag} */ class TabContainerTag extends AFXTag { /** * Reference to the currently selected tab DOM element * * @private * @type {TabContainerTabType} * @memberof TabContainerTag */ private _selectedTab; /** * Placeholder of the tab select event handle * * @private * @type {TagEventCallback} * @memberof TabContainerTag */ private _ontabselect; /** *Creates an instance of TabContainerTag. * @memberof TabContainerTag */ constructor(); /** * Init the tab bar direction to vertical (column) * * @protected * @memberof TabContainerTag */ protected init(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof TabContainerTag */ protected reload(d?: any): void; /** * Set the tab select event handle * * @memberof TabContainerTag */ set ontabselect(f: TagEventCallback); /** * Get all tab items in the container * * @readonly * @type {TabContainerTabType[]} * @memberof TabContainerTag */ get tabs(): TabContainerTabType[]; /** * Select a tab by its index * * @memberof TabContainerTag */ set selectedIndex(i: number); /** * Setter: * * Set the tab bar direction: * - `row`: horizontal direction * - `column`: vertical direction * * Getter: * * Get the tab bar direction * * @memberof TabContainerTag */ set dir(v: "row" | "column"); get dir(): "row" | "column"; /** * Setter: * * Select a tab using the its tab data type. * This will show the attached container to the tab * * Getter: * * Get the tab data of the currently selected Tab * * @memberof TabContainerTag */ set selectedTab(v: TabContainerTabType); get selectedTab(): TabContainerTabType; /** * Set the tab bar width, this function only * works when the tab bar direction is set to * `row` * * @memberof TabContainerTag */ set tabbarwidth(v: number); /** * Set the tab bar height, this function only works * when the tab bar direction is set to `column` * * @memberof TabContainerTag */ set tabbarheight(v: number); /** * Add a new tab with container to the container * * item should be in the following format: * * ```ts * { * text: string, * icon?: string, * iconclass?: string, * container: HTMLElement * } * ``` * * @param {GenericObject} item tab descriptor * @param {boolean} insert insert the tab content to the container ? * @returns {ListViewItemTag} the tab DOM element * @memberof TabContainerTag */ addTab(item: GenericObject, insert: boolean): ListViewItemTag; /** * Remove a tab from the container * * @param {ListViewItemTag} tab the tab item to be removed * @memberof TabContainerTag */ removeTab(tab: ListViewItemTag): void; /** * Mount the tag and bind basic events * * @protected * @memberof TabContainerTag */ protected mount(): void; /** * calibrate the tab container * * @memberof TabContainerTag */ calibrate(): void; /** * Layout definition * * @protected * @returns {TagLayoutType[]} * @memberof TabContainerTag */ protected layout(): TagLayoutType[]; } } } } /// declare namespace OS { namespace GUI { namespace tag { /** * This tag define a basic button and its behavior * * @export * @class ButtonTag * @extends {AFXTag} */ class ButtonTag extends AFXTag { /** * Variable hold the button click callback handle * * @private * @type {TagEventCallback} * @memberof ButtonTag */ private _onbtclick; /** * Custom user data * * @type {GenericObject} * @memberof ButtonTag */ data: GenericObject; /** *Creates an instance of ButtonTag. * @memberof ButtonTag */ constructor(); /** * Set the click callback handle for the target button * * @memberof ButtonTag */ set onbtclick(v: TagEventCallback); /** * Set the path to the button icon, the path should be * a VFS file path * * @memberof ButtonTag */ set icon(v: string); /** * Set the icon class to the button, this property * allows to style the button icon using CSS * * @memberof ButtonTag */ set iconclass(v: string); /** * Setter: Set the text of the button * * Getter: Get the current button test * * @memberof ButtonTag */ set text(v: string | FormattedString); get text(): string | FormattedString; /** * Setter: Enable or disable the button * * Getter: Get the `enable` property of the button * * @memberof ButtonTag */ set enable(v: boolean); get enable(): boolean; /** * Setter: set or remove the attribute `selected` of the button * * Getter: check whether the attribute `selected` of the button is set * * @memberof ButtonTag */ set selected(v: boolean); get selected(): boolean; /** * Setter: activate or deactivate the toggle mode of the button * * Getter: Check whether the button is in toggle mode * * @memberof ButtonTag */ set toggle(v: boolean); get toggle(): boolean; /** * Mount the tag * * @protected * @memberof ButtonTag */ protected mount(): void; /** * Init the tag before mounting * * @protected * @memberof ButtonTag */ protected init(): void; /** * Re-calibrate the button, do nothing in this tag * * @protected * @memberof ButtonTag */ protected calibrate(): void; /** * Update the current tag, do nothing in this tag * * @param {*} [d] * @memberof ButtonTag */ reload(d?: any): void; /** * Button layout definition * * @protected * @returns {TagLayoutType[]} * @memberof ButtonTag */ protected layout(): TagLayoutType[]; } } } } /** * Extend the Array interface with some * property needed by AFX API * * @interface Array * @template T */ interface Array { /** * Reference to a DOM element created by AFX API, * this property is used by some AFX tags to refer * to its child element in it data object * * @type {GenericObject} * @memberof Array */ domel?: GenericObject; } declare namespace OS { namespace GUI { namespace tag { /** * A grid Row is a simple element that * contains a group of grid cell * * @export * @class GridRowTag * @extends {AFXTag} */ class GridRowTag extends AFXTag { /** * Data placeholder for a collection of cell data * * @type {GenericObject[]} * @memberof GridRowTag */ data: GenericObject[]; /** *Creates an instance of GridRowTag. * @memberof GridRowTag */ constructor(); /** * Mount the tag, do nothing * * @protected * @memberof GridRowTag */ protected mount(): void; /** * Init the tag before mounting: reset the data placeholder * * @protected * @memberof GridRowTag */ protected init(): void; /** * Empty layout * * @protected * @returns {TagLayoutType[]} * @memberof GridRowTag */ protected layout(): TagLayoutType[]; /** * This function does nothing in this tag * * @protected * @memberof GridRowTag */ protected calibrate(): void; /** * This function does nothing in this tag * * @protected * @param {*} [d] * @memberof GridRowTag */ protected reload(d?: any): void; } /** * Event data used by grid cell */ type CellEventData = TagEventDataType; /** * Prototype of any grid cell, custom grid cell * definition should extend and implement this * abstract prototype * * @export * @abstract * @class GridCellPrototype * @extends {AFXTag} */ abstract class GridCellPrototype extends AFXTag { /** * placeholder for cell selected event callback * * @private * @type {TagEventCallback} * @memberof GridCellPrototype */ private _oncellselect; /** * placeholder for cell double click event callback * * @private * @type {TagEventCallback} * @memberof GridCellPrototype */ private _oncelldbclick; /** * Data placeholder of the current cell * * @private * @type {GenericObject} * @memberof GridCellPrototype */ private _data; /** *Creates an instance of GridCellPrototype. * @memberof GridCellPrototype */ constructor(); /** * Set the cell selected event callback * * @memberof GridCellPrototype */ set oncellselect(v: TagEventCallback); /** * Set the cell double click event callback * * @memberof GridCellPrototype */ set oncelldbclick(v: TagEventCallback); /** * Setter: * * Set the data of the cell, this will trigger * the [[ondatachange]] function * * Getter: * * Get the current cell data placeholder * * @memberof GridCellPrototype */ set data(v: GenericObject); get data(): GenericObject; /** * Setter: * * Set/unset the current cell as selected. * This will trigger the [[cellselect]] * event * * Getter: * * Check whether the current cell is selected * * @memberof GridCellPrototype */ set selected(v: boolean); get selected(): boolean; /** * Update the current cell. This will * reset the cell data * * @protected * @param {*} d * @memberof GridCellPrototype */ protected reload(d: any): void; /** * Mount the current cell to the grid * * @protected * @memberof GridCellPrototype */ protected mount(): void; /** * This function triggers the cell select * event * * @private * @param {TagEventType} e * @param {boolean} flag * @returns {void} * @memberof GridCellPrototype */ private cellselect; /** * Abstract function called when the cell data changed. * This should be implemented by subclasses * * @protected * @abstract * @memberof GridCellPrototype */ protected abstract ondatachange(): void; } /** * Simple grid cell defines a grid cell with * an [[LabelTag]] as it cell layout * * @export * @class SimpleGridCellTag * @extends {GridCellPrototype} */ class SimpleGridCellTag extends GridCellPrototype { /** *Creates an instance of SimpleGridCellTag. * @memberof SimpleGridCellTag */ constructor(); /** * Reset the label of the cell with its data * * @protected * @memberof SimpleGridCellTag */ protected ondatachange(): void; /** * This function do nothing in this tag * * @protected * @memberof SimpleGridCellTag */ protected init(): void; /** * This function do nothing in this tag * * @protected * @memberof SimpleGridCellTag */ protected calibrate(): void; /** * The layout of the cell with a simple [[LabelTag]] * * @returns * @memberof SimpleGridCellTag */ layout(): { el: string; ref: string; }[]; } /** * A Grid contains a header and a collection grid rows * which has the same number of cells as the number of * the header elements * * @export * @class GridViewTag * @extends {AFXTag} */ class GridViewTag extends AFXTag { /** * Grid header definition * * @private * @type {GenericObject[]} * @memberof GridViewTag */ private _header; /** * Grid rows data placeholder * * @private * @type {GenericObject[][]} * @memberof GridViewTag */ private _rows; /** * Reference to the current selected row DOM element * * @private * @type {GridRowTag} * @memberof GridViewTag */ private _selectedRow; /** * A collection of selected grid rows DOM element * * @private * @type {GridRowTag[]} * @memberof GridViewTag */ private _selectedRows; /** * Reference to the current selected cell * * @private * @type {GridCellPrototype} * @memberof GridViewTag */ private _selectedCell; /** * Cell select event callback placeholder * * @private * @type {TagEventCallback} * @memberof GridViewTag */ private _oncellselect; /** * Row select event callback placeholder * * @private * @type {TagEventCallback} * @memberof GridViewTag */ private _onrowselect; /** * Cell double click event callback placeholder * * @private * @type {TagEventCallback} * @memberof GridViewTag */ private _oncelldbclick; /** * Creates an instance of GridViewTag. * @memberof GridViewTag */ constructor(); /** * Init the grid view before mounting. * Reset all the placeholders to default values * * @protected * @memberof GridViewTag */ protected init(): void; /** * This function does nothing * * @protected * @param {*} [d] * @memberof GridViewTag */ protected reload(d?: any): void; /** * set the cell select event callback * * @memberof GridViewTag */ set oncellselect(v: TagEventCallback); /** * set the row select event callback * * @memberof GridViewTag */ set onrowselect(v: TagEventCallback); /** * set the cell double click event callback * * @memberof GridViewTag */ set oncelldbclick(v: TagEventCallback); /** * Setter: set the tag name of the header cells * * Getter: get the grid header tag name * * @memberof GridViewTag */ set headeritem(v: string); get headeritem(): string; /** * Setter: set the tag name of the grid cell * * Getter: get the tag name of the grid cell * * @memberof GridViewTag */ set cellitem(v: string); get cellitem(): string; /** * Setter: set the header data * * Getter: get the header data placeholder * * @type {GenericObject[]} * @memberof GridViewTag */ get header(): GenericObject[]; set header(v: GenericObject[]); /** * Get all the selected rows * * @readonly * @type {GridRowTag[]} * @memberof GridViewTag */ get selectedRows(): GridRowTag[]; /** * Get the latest selected row * * @readonly * @type {GridRowTag} * @memberof GridViewTag */ get selectedRow(): GridRowTag; /** * Get the current selected cell * * @readonly * @type {GridCellPrototype} * @memberof GridViewTag */ get selectedCell(): GridCellPrototype; /** * Setter: set the rows data * * Getter: get the rows data * * @memberof GridViewTag */ set rows(rows: GenericObject[][]); get rows(): GenericObject[][]; /** * Setter: activate deactivate multi-select * * Getter: check whether the `multiselect` option is activated * * @memberof GridViewTag */ set multiselect(v: boolean); get multiselect(): boolean; /** * Set and Get the resizable attribute * * This allows to enable/disable column resize feature * * @memberof GridViewTag */ set resizable(v: boolean); get resizable(): boolean; /** * Delete a grid rows * * @param {GridRowTag} row row DOM element * @returns {void} * @memberof GridViewTag */ delete(row: GridRowTag): void; /** * Push a row to the grid * * @param {GenericObject[]} row list of cell data * @param {boolean} flag indicates where the row is add to beginning or end * of the row * @memberof GridViewTags */ push(row: GenericObject[], flag: boolean): void; /** * Unshift a row to the grid * * @param {GenericObject[]} row list of cell data in the row * @memberof GridViewTag */ unshift(row: GenericObject[]): void; /** * This function triggers the cell select event * * @private * @param {TagEventType} e event contains cell event data * @param {boolean} flag indicates whether the event is double clicked * @returns {void} * @memberof GridViewTag */ private cellselect; /** * This function triggers the row select event, a cell select * event will also trigger this event * * @param {TagEventType} e * @returns {void} * @memberof GridViewTag */ private rowselect; /** * Check whether the grid has header * * @private * @returns {boolean} * @memberof GridViewTag */ private has_header; /** * Calibrate the grid * * @protected * @memberof GridViewTag */ protected calibrate(): void; /** * Recalculate the size of each header cell, changing * in header cell size will also resize the entire * related column * * @private * @returns {void} * @memberof GridViewTag */ private calibrate_header; /** * Mount the grid view tag * * @protected * @returns {void} * @memberof GridViewTag */ protected mount(): void; /** * Layout definition of the grid view * * @protected * @returns {TagLayoutType[]} * @memberof GridViewTag */ protected layout(): TagLayoutType[]; } } } } /// declare namespace OS { namespace GUI { namespace tag { /** * Menu event data interface definition */ type MenuEventData = TagEventDataType; /** * This class defines the abstract prototype of an menu entry. * Any implementation of menu entry tag should extend this class * * @export * @abstract * @class MenuEntryTag * @extends {AFXTag} */ abstract class MenuEntryTag extends AFXTag { /** * Data placeholder of the menu entry * * @private * @type {GenericObject} * @memberof MenuEntryTag */ private _data; /** * placeholder of `menu entry select` event handle * * @private * @type {TagEventCallback} * @memberof MenuEntryTag */ private _onmenuselect; /** * placeholder of `sub-menu entry select event` handle * * @private * @type {TagEventCallback} * @memberof MenuEntryTag */ private _onchildselect; /** * Reference to the parent menu entry of current one * * @type {MenuEntryTag} * @memberof MenuEntryTag */ parent: MenuEntryTag; /** * Reference to the root menu entry * * @type {MenuTag} * @memberof MenuEntryTag */ root: MenuTag; /** *Creates an instance of MenuEntryTag. * @memberof MenuEntryTag */ constructor(); /** * Init the tag before mounting * * @protected * @memberof MenuEntryTag */ protected init(): void; /** * Set the `menu entry select` event handle * * @memberof MenuEntryTag */ set onmenuselect(v: TagEventCallback); /** * Setter: Set the `sub menu entry select` event handle * * Getter: get the current `sub menu entry select` event handle * * @memberof MenuEntryTag */ set onchildselect(v: TagEventCallback); get onchildselect(): TagEventCallback; /** * Setter: Set data to the entry * * Getter: Get data of the current menu entry * * @memberof MenuEntryTag */ set data(data: GenericObject); get data(): GenericObject; /** * Check whether the current menu entry has sub-menu * * @protected * @returns {boolean} * @memberof MenuEntryTag */ protected has_nodes(): boolean; /** * Check whether the current menu entry is the root entry * * @protected * @returns * @memberof MenuEntryTag */ protected is_root(): boolean; /** * Layout definition of the menu entry * This function define the outer layout of the menu entry. * Custom inner layout of each item implementation should * be defined in [[itemlayout]] * @protected * @returns {TagLayoutType[]} * @memberof MenuEntryTag */ protected layout(): TagLayoutType[]; /** * Setter: Set the sub-menu data * * Getter: Get the sub-menu data * * @memberof MenuEntryTag */ set nodes(v: GenericObject[]); get nodes(): GenericObject[]; /** * Bind some base event to the menu entry * * @protected * @memberof MenuEntryTag */ protected mount(): void; /** * Hide the sub-menu of the current menu entry * * @private * @returns {void} * @memberof MenuEntryTag */ private submenuoff; /** * This function trigger two event: * - the `onmenuselect` event on the current entry * - the `onchildselect` event on the parent of the current entry * * @protected * @param {JQuery.ClickEvent} e * @memberof MenuEntryTag */ protected select(e: JQuery.ClickEvent): void; /** * custom inner layout of a menu entry * * @protected * @abstract * @returns {TagLayoutType[]} * @memberof MenuEntryTag */ protected abstract itemlayout(): TagLayoutType[]; } /** * This class extends the [[MenuEntryTag]] prototype. It inner layout is * defined with the following elements: * - a [[SwitchTag]] acts as checker or radio * - a [[LabelTag]] to display the content of the menu entry * - a `span` element that display the keyboard shortcut of the entry * * @class SimpleMenuEntryTag * @extends {MenuEntryTag} */ class SimpleMenuEntryTag extends MenuEntryTag { /** *Creates an instance of SimpleMenuEntryTag. * @memberof SimpleMenuEntryTag */ constructor(); /** * Reset some properties to default value * * @protected * @memberof SimpleMenuEntryTag */ protected init(): void; /** * Do nothing * * @protected * @memberof SimpleMenuEntryTag */ protected calibrate(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof SimpleMenuEntryTag */ protected reload(d?: any): void; /** * Setter: Turn on/off the checker feature of the menu entry * * Getter: Check whether the checker feature is enabled on this menu entry * * @memberof SimpleMenuEntryTag */ set switch(v: boolean); get switch(): boolean; /** * Setter: Turn on/off the radio feature of the menu entry * * Getter: Check whether the radio feature is enabled * * @memberof SimpleMenuEntryTag */ set radio(v: boolean); get radio(): boolean; /** * Setter: * * Toggle the switch on the menu entry, this setter * only works when the `checker` or `radio` feature is * enabled * * Getter: * * Check whether the switch is turned on * * @memberof SimpleMenuEntryTag */ set checked(v: boolean); get checked(): boolean; /** * Set the label icon using a VFS path * * @memberof SimpleMenuEntryTag */ set icon(v: string); /** * Set the label CSS icon class * * @memberof SimpleMenuEntryTag */ set iconclass(v: string); /** * Set the label text * * @memberof SimpleMenuEntryTag */ set text(v: string); /** * Set the keyboard shortcut text * * @memberof SimpleMenuEntryTag */ set shortcut(v: string); /** * Uncheck all sub-menu items of the current menu entry * that have the radio feature enabled * * @returns {void} * @memberof SimpleMenuEntryTag */ protected reset_radio(): void; /** * Mount the current tag * * @protected * @memberof SimpleMenuEntryTag */ protected mount(): void; /** * Trigger the onmenuselect and onchildselect events * * @protected * @param {JQuery.ClickEvent} e Mouse click event * @returns {void} * @memberof SimpleMenuEntryTag */ protected select(e: JQuery.ClickEvent): void; /** * Inner item layout of the menu entry * * @returns * @memberof SimpleMenuEntryTag */ itemlayout(): ({ el: string; ref: string; class?: undefined; } | { el: string; class: string; ref: string; })[]; } /** * A menu tag contains a collection of menu entries in which each * entry maybe a leaf entry or may contain a submenu * * @export * @class MenuTag * @extends {AFXTag} */ class MenuTag extends AFXTag { /** * Reference to the parent menu entry of the current value. * This value is `undefined` in case of the current menu is * the root menu * * @type {MenuEntryTag} * @memberof MenuTag */ parent: MenuEntryTag; /** * Reference to the root menu * * @type {MenuTag} * @memberof MenuTag */ root: MenuTag; /** * The `pid` of the application that attached to this menu. * This value is optional * * @type {number} * @memberof MenuTag */ pid?: number; /** * placeholder for menu select event handle * * @private * @type {TagEventCallback} * @memberof MenuTag */ private _onmenuselect; /** * Menu data placeholder * * @private * @type {GenericObject[]} * @memberof MenuTag */ private _items; /** *Creates an instance of MenuTag. * @memberof MenuTag */ constructor(); /** * Reset some properties to default value * * @protected * @memberof MenuTag */ protected init(): void; /** * Do nothing * * @protected * @memberof MenuTag */ protected calibrate(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof MenuTag */ protected reload(d?: any): void; /** * Setter: Set the menu items data * * Getter: Get menu items data * * @memberof MenuTag */ set items(data: GenericObject[]); get items(): GenericObject[]; /** * Setter: Set whether the current menu is a context menu * * Getter: Check whether the current menu is a context menu * * @memberof MenuTag */ set context(v: boolean); get context(): boolean; /** * Set menu select event handle * * @memberof MenuTag */ set onmenuselect(v: TagEventCallback); /** * Setter: * * Set the default tag name of the menu item. * If the tag is not specified in an item data, * this value will be used * * Getter: * * Get the default menu entry tag name * * @memberof MenuTag */ set contentag(v: string); get contentag(): string; /** * Get the reference to the function that triggers * the menu select event * * @readonly * @type {TagEventCallback} * @memberof MenuTag */ get onmenuitemselect(): TagEventCallback; /** * This function triggers the menu select event * * @private * @param {TagEventType} e * @memberof MenuTag */ private handleselect; /** * Show the current menu. This function is called * only if the current menu is a context menu * * @param {JQuery.MouseEventBase} e JQuery mouse event * @returns {void} * @memberof MenuTag */ show(e: JQuery.MouseEventBase): void; /** * Test whether the current menu is the root menu * * @private * @returns {boolean} * @memberof MenuTag */ private is_root; /** * Mount the menu tag and bind some basic events * * @protected * @returns {void} * @memberof MenuTag */ protected mount(): void; /** * Add a menu entry to the beginning of the current * menu * * @param {GenericObject} item menu entry data * @memberof MenuTag */ unshift(item: GenericObject): void; /** * Delete a menu entry * * @param {MenuEntryTag} item reference to the DOM element of an menu entry * @memberof MenuTag */ delete(item: MenuEntryTag): void; /** * Add an menu entry to the beginning or end of the menu * * @param {GenericObject} item menu entry data * @param {boolean} flag indicates whether the entry should be added to the beginning of the menu * @returns {MenuEntryTag} * @memberof MenuTag */ push(item: GenericObject, flag: boolean): MenuEntryTag; /** * Menu tag layout definition * * @returns * @memberof MenuTag */ layout(): { el: string; ref: string; children: ({ el: string; class: string; ref?: undefined; } | { el: string; ref: string; class?: undefined; })[]; }[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * A WindowTag represents a virtual window element * used by AntOS applications and dialogs. * * @export * @class WindowTag * @extends {AFXTag} */ class WindowTag extends AFXTag { /** * The element ID of the virtual desktop element * * @type {string} * @memberof WindowTag */ desktop: string; /** * Window width placeholder * * @private * @type {number} * @memberof WindowTag */ private _width; /** * Window height placeholder * * @private * @type {number} * @memberof WindowTag */ private _height; /** * Placeholder indicates whether the current window is shown * * @private * @type {boolean} * @memberof WindowTag */ private _shown; /** * Placeholder indicates whether the current window is maximized * * @private * @type {boolean} * @memberof WindowTag */ private _isMaxi; /** * This placeholder stores the latest offset of the current window. * * @private * @type {GenericObject} * @memberof WindowTag */ private _history; /** * This placeholder stores the offset of the virtual desktop element * * @private * @type {GenericObject} * @memberof WindowTag */ private _desktop_pos; /** * Creates an instance of WindowTag. * @memberof WindowTag */ constructor(); /** * Init window tag * - `shown`: false * - `isMaxi`: false * - `minimizable`: false * - `resizable`: true * - `apptitle`: Untitled * * @protected * @memberof WindowTag */ protected init(): void; /** * Do nothing * * @protected * @memberof WindowTag */ protected calibrate(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof WindowTag */ protected reload(d?: any): void; /** * Setter: Set the window width * * Getter: Get the window width * * @memberof WindowTag */ set width(v: number); get width(): number; /** * Setter: Set the window height * * Getter: Get the window height * * @memberof WindowTag */ set height(v: number); get height(): number; /** * Setter: enable/disable window minimizable * * getter: Check whether the window is minimizable * * @memberof WindowTag */ set minimizable(v: boolean); get minimizable(): boolean; /** * Setter: enable/disable widow resizable * * Getter: Check whether the current window is resizable * * @memberof WindowTag */ set resizable(v: boolean); get resizable(): boolean; /** * Setter: Set the window title * * Getter: Get window title * * @memberof WindowTag */ set apptitle(v: string | FormattedString); get apptitle(): string | FormattedString; /** * Resize all the children of the window based on its width and height * * @private * @memberof WindowTag */ private resize; /** * Mount the window tag and bind basic events * * @protected * @returns {void} * @memberof WindowTag */ protected mount(): void; /** * Set the window size * * @private * @param {GenericObject} o format: `{ w: window_width, h: window_height }` * @returns {void} * @memberof WindowTag */ private setsize; /** * Enable to drag window on the virtual desktop * * @private * @memberof WindowTag */ private enable_dragging; /** * Enable window resize, this only works if the window * is resizable * * @private * @memberof WindowTag */ private enable_resize; /** * Maximize the window or restore its previous width, height, * and position * * @private * @returns {void} * @memberof WindowTag */ private toggle_window; /** * Layout definition of the window tag * * @protected * @returns {TagLayoutType[]} * @memberof WindowTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * Tag event data type definition */ type TabEventData = TagEventDataType; /** * a TabBar allows to control a collection of tabs * * @export * @class TabBarTag * @extends {AFXTag} */ export class TabBarTag extends AFXTag { /** * Placeholder of currently selected tab index * * @private * @type {number} * @memberof TabBarTag */ private _selected; /** * Placeholder of tab close event handle * * @private * @memberof TabBarTag */ private _ontabclose; /** * Placeholder of tab select event handle * * @private * @type {TagEventCallback} * @memberof TabBarTag */ private _ontabselect; /** *Creates an instance of TabBarTag. * @memberof TabBarTag */ constructor(); /** * Init the tag * * @protected * @memberof TabBarTag */ protected init(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof TabBarTag */ protected reload(d?: any): void; /** * Setter: Enable/disable a tab to be closed * * Getter: Check whether tabs can be closed * * @memberof TabBarTag */ set closable(v: boolean); get closable(): boolean; /** * Add a tab in the end of the tab bar * * @param {GenericObject} item tab data * @memberof TabBarTag */ push(item: GenericObject): ListViewItemTag; /** * Delete a tab * * @param {ListViewItemTag} el reference to DOM element of a tab * @memberof TabBarTag */ delete(el: ListViewItemTag): void; /** * Add a tab to the beginning of the tab bar * * @param {GenericObject} item tab data * @memberof TabBarTag */ unshift(item: GenericObject): ListViewItemTag; /** * Setter: Set tabs data * * Getter: Get all tabs data * * @memberof TabBarTag */ set items(v: GenericObject[]); get items(): GenericObject[]; /** * Setter: Select a tab by its index * * Getter: Get the currently selected tab * * @memberof TabBarTag */ set selected(v: number | number[]); get selected(): number | number[]; /** * Set the tab close event handle * * @memberof TabBarTag */ set ontabclose(v: (e: TagEventType) => boolean); /** * Set the tab select event handle * * @memberof TabBarTag */ set ontabselect(v: TagEventCallback); /** * Mount the tab bar and bind some basic events * * @protected * @memberof TabBarTag */ protected mount(): void; /** * TabBar layout definition * * @protected * @returns {TagLayoutType[]} * @memberof TabBarTag */ protected layout(): TagLayoutType[]; } export {}; } } } declare namespace OS { namespace GUI { namespace tag { /** * A simple number sinner tag * * @export * @class NSpinnerTag * @extends {AFXTag} */ class NSpinnerTag extends AFXTag { /** * Placeholder for value change event handle * * @private * @type {TagEventCallback} * @memberof NSpinnerTag */ private _onchange; /** * Placeholder for the spinner data * * @private * @type {number} * @memberof NSpinnerTag */ private _value; /** * Place holder for the spinner step * * @type {number} * @memberof NSpinnerTag */ step: number; /** *Creates an instance of NSpinnerTag. * @memberof NSpinnerTag */ constructor(); /** * Init the spinner value to `0` and step to `1` * * @protected * @memberof NSpinnerTag */ protected init(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof NSpinnerTag */ protected reload(d?: any): void; /** * Set the value change event handle * * @memberof NSpinnerTag */ set onvaluechange(f: TagEventCallback); /** * Mount the tag and bind basic events * * @protected * @memberof NSpinnerTag */ protected mount(): void; /** * Calibrate the layout of the spinner * * @memberof NSpinnerTag */ calibrate(): void; /** * Setter: Set the spinner value * * Getter: Get the spinner value * * @memberof NSpinnerTag */ set value(v: number); get value(): number; /** * Spinner layout definition * * @protected * @returns {TagLayoutType[]} * @memberof NSpinnerTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { /** * * Interface for an application dock item * * @export * @interface AppDockItemType */ interface AppDockItemType { /** * Reference to the application process represented * by the dock item * * @type {application.BaseApplication} * @memberof AppDockItemType */ app: application.BaseApplication; /** * Reference to the DOM element of * the owner dock item * * @type {AFXTag} * @memberof AppDockItemType */ domel?: AFXTag; [propName: string]: any; } namespace tag { /** * This class define the AntOS system application dock tag * * @export * @class AppDockTag * @extends {AFXTag} */ class AppDockTag extends AFXTag { /** * variable holds the application select event * callback handle * * @private * @type {TagEventCallback} * @memberof AppDockTag */ private _onappselect; /** * Items data of the dock * * @private * @type {AppDockItemType[]} * @memberof AppDockTag */ private _items; /** * Reference to the currently select application * process in the dock * * @private * @type {AppDockItemType} * @memberof AppDockTag */ private _selectedItem; /** *Creates an instance of AppDockTag. * @memberof AppDockTag */ constructor(); /** * Implementation of the abstract function: Update the current tag. * It do nothing for this tag * * @protected * @param {*} [d] * @memberof AppDockTag */ protected reload(d?: any): void; /** * Init the tag before mounting * * @protected * @memberof AppDockTag */ protected init(): void; /** * The tag layout, it is empty on creation but elements will * be added automatically to it in operation * * @protected * @returns {TagLayoutType[]} * @memberof AppDockTag */ protected layout(): TagLayoutType[]; /** * getter to get the dock items * * @readonly * @type {AppDockItemType[]} * @memberof AppDockTag */ get items(): AppDockItemType[]; /** * Setter: * * set the selected application in the dock * this will trigger two event: * - `focus`: on the selected application * - `blur`: on all other applications on the dock * * Getter: * * Get the current selected application * on the dock * * @memberof AppDockTag */ set selectedApp(v: application.BaseApplication); get selectedApp(): application.BaseApplication; /** * Get selected item of the dock * * @readonly * @type {AppDockItemType} * @memberof AppDockTag */ get selectedItem(): AppDockItemType; /** * When a new application process is created, this function * will be called to add new application entry to the dock. * The added application will becomes the current selected * application * * @param {AppDockItemType} item an application dock item entry * @memberof AppDockTag */ newapp(item: AppDockItemType): void; /** * Delete and application entry from the dock. * This function will be called when an application * is exit * * @param {BaseApplication} a the application to be removed from the dock * @memberof AppDockTag */ removeapp(a: application.BaseApplication): void; /** * Mount the current dock tag * * @protected * @memberof AppDockTag */ protected mount(): void; } } } } declare namespace OS { namespace GUI { namespace tag { /** * Tag that define system calendar widget * * @export * @class CalendarTag * @extends {AFXTag} */ class CalendarTag extends AFXTag { /** * The current selected day * * @private * @type {number} * @memberof CalendarTag */ private _day; /** * The current selected month * * @private * @type {number} * @memberof CalendarTag */ private _month; /** * The current selected year * * @private * @type {number} * @memberof CalendarTag */ private _year; /** * The current selected date object * * @private * @type {Date} * @memberof CalendarTag */ private _selectedDate; /** * placeholder for date select event callback * * @private * @type {TagEventCallback} * @memberof CalendarTag */ private _ondateselect; /** *Creates an instance of CalendarTag. * @memberof CalendarTag */ constructor(); /** * Init the tag before mounting * * @protected * @memberof CalendarTag */ protected init(): void; /** * Update the current tag, doing nothing in this tag * * @protected * @param {*} [d] any data object * @memberof CalendarTag */ protected reload(d?: any): void; /** * Get the current selected date in the widget * * @readonly * @type {Date} * @memberof CalendarTag */ get selectedDate(): Date; /** * Set the date select event callback handle for the widget * * @memberof CalendarTag */ set ondateselect(v: TagEventCallback); /** * Mount the current widget to the DOM tree * * @protected * @memberof CalendarTag */ protected mount(): void; /** * This function triggers the date select event * * @private * @param {TagEventType} e AFX tag event data [[TagEventType]] * @returns {void} * @memberof CalendarTag */ private dateselect; /** * Calibrate the layout of the tag * * @protected * @memberof CalendarTag */ protected calibrate(): void; /** * Display the previous month of the current month * * @private * @memberof CalendarTag */ private prevmonth; /** * Display the next month of the current month * * @private * @returns * @memberof CalendarTag */ private nextmonth; /** * Visualize the calendar base on input date * * @private * @param {Date} date * @memberof CalendarTag */ private calendar; /** * Layout definition of the widget * * @protected * @returns {TagLayoutType[]} * @memberof CalendarTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * A float list is a list of items in which each * item can be moved (drag and drop) freely * * @export * @class FloatListTag * @extends {ListViewTag} */ class FloatListTag extends ListViewTag { /** * Update the current tag, do nothing * * @protected * @param {*} [d] * @memberof FloatListTag */ protected reload(d?: any): void; /** * Variable that hold the onready callback of * the tag. This callback will be called after * the tag is mounted * * @private * @memberof FloatListTag */ private _onready; /** *Creates an instance of FloatListTag. * @memberof FloatListTag */ constructor(); /** * set the onready callback function to the tag. * This callback will be called after * the tag is mounted * * @memberof FloatListTag */ set onready(v: (e: FloatListTag) => void); /** * Setter: * * Set the direction of the list item layout. * Two directions are available: * - `vertical` * - `horizontal` * * This setter acts as a DOM attribute * * Getter: * * Get the currently set direction of list * item layout * * @memberof FloatListTag */ set dir(v: string); get dir(): string; /** * Disable the dropdown option in this list * * @memberof FloatListTag */ set dropdown(v: boolean); /** * Disable the list buttons configuration in this * list * * @memberof FloatListTag */ set buttons(v: GenericObject[]); /** * Disable the `showlist` behavior in this list * * @protected * @param {*} e * @memberof FloatListTag */ protected showlist(e: any): void; /** * Disable the `dropoff` behavior in this list * * @protected * @param {*} e * @memberof FloatListTag */ protected dropoff(e: any): void; /** * Function called when the data of the list * is changed * * @protected * @memberof FloatListTag */ protected ondatachange(): void; /** * Mount the list to the DOM tree * * @protected * @returns {void} * @memberof FloatListTag */ protected mount(): void; /** * Push an element to the list * * @param {GenericObject} v an element data * @returns * @memberof FloatListTag */ push(v: GenericObject): ListViewItemTag; /** * Enable drag and drop on the list * * @private * @param {ListViewItemTag} el the list item DOM element * @memberof FloatListTag */ private enable_drag; /** * Calibrate the view of the list * * @memberof FloatListTag */ calibrate(): void; } } } } declare namespace OS { namespace GUI { /** * Color type used by AFX API * * @export * @interface ColorType */ interface ColorType { /** * Red chanel * * @type {number} * @memberof ColorType */ r: number; /** * Green chanel * * @type {number} * @memberof ColorType */ g: number; /** * Blue chanel * * @type {number} * @memberof ColorType */ b: number; /** * Alpha chanel * * @type {number} * @memberof ColorType */ a?: number; /** * color text in CSS format * * @type {string} * @memberof ColorType */ text?: string; /** * Color in hex format * * @type {string} * @memberof ColorType */ hex?: string; } namespace tag { /** * Class definition of Color picker widget * * @export * @class ColorPickerTag * @extends {AFXTag} */ class ColorPickerTag extends AFXTag { /** * The current selected color object * * @private * @type {ColorType} * @memberof ColorPickerTag */ private _selectedColor; /** * placeholder for the color select event callback * * @private * @type {TagEventCallback} * @memberof ColorPickerTag */ private _oncolorselect; /** * Creates an instance of ColorPickerTag. * @memberof ColorPickerTag */ constructor(); /** * Init tag before mounting, do nothing * * @protected * @memberof ColorPickerTag */ protected init(): void; /** * Reload tag, do nothing * * @protected * @param {*} [d] * @memberof ColorPickerTag */ protected reload(d?: any): void; /** * Get selected color value * * @readonly * @type {ColorType} * @memberof ColorPickerTag */ get selectedColor(): ColorType; /** * Set the color select event handle * * @memberof ColorPickerTag */ set oncolorselect(v: TagEventCallback); /** * Mount the widget to DOM tree * * @protected * @memberof ColorPickerTag */ protected mount(): void; /** * Build the color palette * * @private * @memberof ColorPickerTag */ private build_palette; /** * layout definition of the widget * * @protected * @returns {TagLayoutType[]} * @memberof ColorPickerTag */ protected layout(): TagLayoutType[]; } } } } /// /** * * Extend the HTMLElement interface with some utility function need * by AFX API * * @interface HTMLElement */ interface HTMLElement { /** * Recursively update a tag and all its children * * @param {*} [d] data to send to all element in the DOM subtree * @memberof HTMLElement */ update(d?: any): void; /** * * AFX will automatically bind the context menu on an HTMLElement * if this function is defined on that element. The function should * define the content of the context menu and its action * * Once the context menu is bound to the element, all context menu handle * defined on any child of this element will be ignored. * * @param {JQuery.MouseEventBase} e a mouse event * @param {OS.GUI.tag.MenuTag} m The context menu element [[MenuTag]] * @memberof HTMLElement */ contextmenuHandle(e: JQuery.MouseEventBase, m: OS.GUI.tag.MenuTag): void; /** * Mount the element and all the children on its DOM subtree. This action * is performed in a top-down manner * * @memberof HTMLElement */ sync(): void; /** * * This action allows to generated all the DOM nodes defined by all AFX tags * in its hierarchy. * It performs two operations, one top-down operation to generate all the * necessary DOM nodes, another bottom-up operation to init all the AFX tag * in the current element DOM hierarchy * * @param {OS.API.Announcer} o an AntOS observable object * @memberof HTMLElement */ afxml(o: OS.API.Announcer): void; /** * Perform DOM generation ([[afxml]]) then mount ([[sync]]) all the * elements. * * @param {OS.API.Announcer} o an AntOS observable object * @param {boolean} [flag] indicates whether this is the top-most call of the operation * @memberof HTMLElement */ uify(o: OS.API.Announcer, flag?: boolean): void; /** * * * @type {*} * @memberof HTMLElement */ mozRequestFullScreen: any; /** * * * @type {*} * @memberof HTMLElement */ webkitRequestFullscreen: any; /** * * * @type {*} * @memberof HTMLElement */ msRequestFullscreen: any; } /** * * * @interface Document */ interface Document { mozCancelFullScreen: any; webkitExitFullscreen: any; cancelFullScreen: any; } declare namespace OS { namespace GUI { /** * [[TagLayoutType]] interface using by AFX tags to defined * its internal DOM hierarchy * * @export * @interface TagLayoutType */ interface TagLayoutType { /** * Element tag name * * @type {string} * @memberof TagLayoutType */ el: string; /** * Children layout of the current element * * @type {TagLayoutType[]} * @memberof TagLayoutType */ children?: TagLayoutType[]; /** * Reference name of the element used by AFX Tag * * @type {string} * @memberof TagLayoutType */ ref?: string; /** * CSS class of the element * * @type {string} * @memberof TagLayoutType */ class?: string; /** * this is the `data-id` attribute of the element, * can be query by the [[aid]] Tag API function. * Not to be confused with the DOM `id` attribute * * @type {(string | number)} * @memberof TagLayoutType */ id?: string | number; /** * Tooltip text of the element * * @type {(string | FormattedString)} * @memberof TagLayoutType */ tooltip?: string | FormattedString; /** * `data-width` of the element, not to be confused with * the `width` attribute of the DOM element * * @type {number|string} * @memberof TagLayoutType */ width?: number | string; /** ** `data-height` of the element, not to be confused with * the `height` attribute of the DOM element * * @type {number|string} * @memberof TagLayoutType */ height?: number | string; } /** * Data type for event issued by AFX tags * * @export * @interface TagEventDataType * @template T item template */ interface TagEventDataType { /** * Reference to the item involved in the event * * @type {T} * @memberof TagEventDataType */ item?: T; [propName: string]: any; } /** * Format of the event issued by AFX tags * * @export * @interface TagEventType * @template T data type */ interface TagEventType { /** * `data-id` of the tag that trigger the * event * * @type {(number | string)} * @memberof TagEventType */ id: number | string; /** * Data object of the event * * @type {T} * @memberof TagEventType */ data: T; } /** * Drag and Drop data type sent between mouse events * * @export * @interface DnDEventDataType * @template T */ interface DnDEventDataType { /** * Reference to the source DOM element * * @type {T} * @memberof DnDEventDataType */ from: T; /** * Reference to the target DOM element * * @type {T} * @memberof DnDEventDataType */ to: T; } /** * Tag event callback type */ type TagEventCallback = (e: TagEventType) => void; /** * Top most element z index value, start by 10 */ var zindex: number; /** * Base abstract class for tag implementation, any AFX tag should be * subclass of this class * * @export * @abstract * @class AFXTag * @extends {HTMLElement} */ abstract class AFXTag extends HTMLElement { /** * The announcer object of the tag * * @type {API.Announcer} * @memberof AFXTag */ observable: API.Announcer; /** * Reference to some of the tag's children * element. This reference object is built * based on the `ref` property found in the * tag layout [[TagLayoutType]] * * @protected * @type {GenericObject} * @memberof AFXTag */ protected refs: GenericObject; /** * boolean value indicated whether the tag * is already mounted in the DOM tree * * @protected * @type {boolean} * @memberof AFXTag */ protected _mounted: boolean; /** *Creates an instance of AFXTag. * @memberof AFXTag */ constructor(); /** * This function verifies if a property name of the input object * corresponds to a setter of the current tag. If this is the * case, it sets the value of that property to the setter * * @param {GenericObject} v input object * @memberof AFXTag */ set(v: GenericObject): void; /** * Setter to set the tooltip text to the current tag. * The text should be in the following format: * ```text * cr|cl|ct|cb: tooltip text * ``` * * @memberof AFXTag */ set tooltip(v: string); /** * * This function looking for a property name of the tag * in its prototype chain. The descriptor of the property * will be returned if it exists * * @private * @param {string} k the property name to be queried * @returns {PropertyDescriptor} the property descriptor or undefined * @memberof AFXTag */ private descriptor_of; /** * Setter: set the id of the tag in string or number * * Getter: get the id of the current tag * * @memberof AFXTag */ set aid(v: string | number); get aid(): string | number; /** * Implementation from HTMLElement interface, * this function mount the current tag hierarchy * * @returns {void} * @memberof AFXTag */ sync(): void; /** * Generate the DOM hierarchy of the current tag * * @param {API.Announcer} o observable object * @memberof AFXTag */ afxml(o: API.Announcer): void; /** * Update the current tag hierarchy * * @param {*} d any data object * @memberof AFXTag */ update(d: any): void; /** * Init the current tag, this function * is called before the [[mount]] function * * @protected * @abstract * @memberof AFXTag */ protected abstract init(): void; /** * Mount only the current tag * * @protected * @abstract * @memberof AFXTag */ protected abstract mount(): void; /** * Layout definition of a tag * * @protected * @abstract * @returns {TagLayoutType[]} tag layout object * @memberof AFXTag */ protected abstract layout(): TagLayoutType[]; /** * Update only the current tag, this function is * called by [[update]] before chaining the * update process to its children * * @protected * @abstract * @param {*} [d] * @memberof AFXTag */ protected abstract reload(d?: any): void; /** * This function is used to re-render the current * tag * * @protected * @memberof AFXTag */ protected calibrate(): void; /** * This function parses the input layout object * and generates all the elements defined by * the tag * * @private * @param {TagLayoutType} tag tag layout object * @returns {Element} the DOM element specified by the tag layout * @memberof AFXTag */ private mkui; /** * This function inserts or removes an attribute name * to/from the target element based on the input `flag`. * * @protected * @param {boolean} flag indicates whether the attribute name should be inserted o removed * @param {string} v the attribute name * @param {HTMLElement} [el] the target element * @memberof AFXTag */ protected attsw(flag: boolean, v: string, el?: HTMLElement): void; /** * Insert the attribute name to the target element * * @protected * @param {string} v the attribute name * @param {HTMLElement} [el] the target element * @memberof AFXTag */ protected atton(v: string, el?: HTMLElement): void; /** * Remove the attribute name from the target element * * @protected * @param {string} v attribute name * @param {HTMLElement} [el] the target element * @memberof AFXTag */ protected attoff(v: string, el?: HTMLElement): void; /** * Verify if the target element has an attribute name * * @protected * @param {string} v attribute name * @param {HTMLElement} [el] target element * @returns {boolean} * @memberof AFXTag */ protected hasattr(v: string, el?: HTMLElement): boolean; } /** * All the AFX tags are defined in this namespace, * these tags are defined as custom DOM elements and will be * stored in the `customElements` registry of the browser */ namespace tag { /** * Define an AFX tag as a custom element and add it to the * global `customElements` registry. If the tag is redefined, i.e. * the tag already exists, its behavior will be updated with the * new definition * * @export * @template T all classes that extends [[AFXTag]] * @param {string} name name of the tag * @param {{ new (): T }} cls the class that defines the tag * @returns {void} */ function define(name: string, cls: { new (): T; }): void; } } } declare namespace OS { namespace GUI { namespace tag { /** * A switch tag is basically used to visualize an boolean data value. * * @export * @class SwitchTag * @extends {AFXTag} */ class SwitchTag extends AFXTag { /** * Placeholder for the onchange event handle * * @private * @type {TagEventCallback} * @memberof SwitchTag */ private _onchange; /** * Setter: Turn on/off the switch * * Getter: Check whether the switch is turned on * * @memberof SwitchTag */ set swon(v: boolean); get swon(): boolean; /** * Setter: Enable the switch * * Getter: Check whether the switch is enabled * * @memberof SwitchTag */ set enable(v: boolean); get enable(): boolean; /** * Set the onchange event handle * * @memberof SwitchTag */ set onswchange(v: TagEventCallback); /** * Mount the tag and bind the click event to the switch * * @protected * @memberof SwitchTag */ protected mount(): void; /** * This function will turn the switch (on/off) * and trigger the onchange event * * @private * @param {JQuery.ClickEvent} e * @returns * @memberof SwitchTag */ private makechange; /** * Tag layout definition * * @protected * @returns * @memberof SwitchTag */ protected layout(): { el: string; ref: string; }[]; /** * Init the tag: * - switch is turn off * - switch is enabled * * @protected * @memberof SwitchTag */ protected init(): void; /** * Do nothing * * @protected * @memberof SwitchTag */ protected calibrate(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof SwitchTag */ protected reload(d?: any): void; } } } } declare namespace OS { namespace GUI { namespace tag { /** * List item event data type */ type ListItemEventData = TagEventDataType; /** * A list item represent the individual view of an item in the [[ListView]]. * This class is an abstract prototype class, implementation of any * list view item should extend it * * * @export * @abstract * @class ListViewItemTag * @extends {AFXTag} */ abstract class ListViewItemTag extends AFXTag { /** * Data placeholder for the list item * * @private * @type {GenericObject} * @memberof ListViewItemTag */ private _data; /** * placeholder for the item select event callback * * @private * @type {TagEventCallback} * @memberof ListViewItemTag */ private _onselect; /** * Context menu event callback handle * * @private * @type {TagEventCallback} * @memberof ListViewItemTag */ private _onctxmenu; /** * Click event callback placeholder * * @private * @type {TagEventCallback} * @memberof ListViewItemTag */ private _onclick; /** * Double click event callback handle * * @private * @type {TagEventCallback} * @memberof ListViewItemTag */ private _ondbclick; /** * Item close event callback placeholder * * @private * @type {TagEventCallback} * @memberof ListViewItemTag */ private _onclose; /** *Creates an instance of ListViewItemTag. * @memberof ListViewItemTag */ constructor(); /** * Setter: Turn on/off the `closable` feature of the list item * * Getter: Check whether the item is closable * * @memberof ListViewItemTag */ set closable(v: boolean); get closable(): boolean; /** * Set item select event handle * * @memberof ListViewItemTag */ set onitemselect(v: TagEventCallback); /** * Setter: select/unselect the current item * * Getter: Check whether the current item is selected * * @memberof ListViewItemTag */ set selected(v: boolean); get selected(): boolean; /** * Set the context menu event handle * * @memberof ListViewItemTag */ set onctxmenu(v: TagEventCallback); /** * Set the item click event handle * * @memberof ListViewItemTag */ set onitemclick(v: TagEventCallback); /** * Set the item double click event handle * * @memberof ListViewItemTag */ set onitemdbclick(v: TagEventCallback); /** * set the item close event handle * * @memberof ListViewItemTag */ set onitemclose(v: TagEventCallback); /** * Mount the tag and bind some events * * @protected * @memberof ListViewItemTag */ protected mount(): void; /** * Layout definition of the item tag. * This function define the outer layout of the item. * Custom inner layout of each item implementation should * be defined in [[itemlayout]] * * @protected * @returns {TagLayoutType[]} * @memberof ListViewItemTag */ protected layout(): TagLayoutType[]; /** * Setter: * * Set the data of the list item. This will * trigger the [[ondatachange]] function * * Getter: * * Get the data of the current list item * * @memberof ListViewItemTag */ set data(v: GenericObject); get data(): GenericObject; /** * Any subclass of this class should implement this * function to provide its custom item layout * * @protected * @abstract * @returns {TagLayoutType} * @memberof ListViewItemTag */ protected abstract itemlayout(): TagLayoutType; /** * This function is called when the item data is changed. * It should be implemented in all subclass of this class * * @protected * @abstract * @memberof ListViewItemTag */ protected abstract ondatachange(): void; } /** * The layout of a simple list item contains only a * AFX label * * @export * @class SimpleListItemTag * @extends {ListViewItemTag} */ class SimpleListItemTag extends ListViewItemTag { /** *Creates an instance of SimpleListItemTag. * @memberof SimpleListItemTag */ constructor(); /** * Reset some property to default * * @protected * @memberof SimpleListItemTag */ protected init(): void; /** * Do nothing * * @protected * @memberof SimpleListItemTag */ protected calibrate(): void; /** * Refresh the inner label when the item data * is changed * * @protected * @returns {void} * @memberof SimpleListItemTag */ protected ondatachange(): void; /** * Re-render the list item * * @protected * @memberof SimpleListItemTag */ protected reload(): void; /** * List item custom layout definition * * @protected * @returns {TagLayoutType} * @memberof SimpleListItemTag */ protected itemlayout(): TagLayoutType; } /** * This tag defines a traditional or a dropdown list widget. * It contains a collection of list items in which layout * of each item may be variable * * @export * @class ListViewTag * @extends {AFXTag} */ class ListViewTag extends AFXTag { /** * placeholder of list select event handle * * @private * @type {TagEventCallback} * @memberof ListViewTag */ private _onlistselect; /** * placeholder of list double click event handle * * @private * @type {TagEventCallback} * @memberof ListViewTag */ private _onlistdbclick; /** * placeholder of list drag and drop event handle * * @private * @type {TagEventCallback>} * @memberof ListViewTag */ private _ondragndrop; /** * placeholder of list item close event handle * * @private * @memberof ListViewTag */ private _onitemclose; /** * placeholder of drag and drop mouse down event handle * * @private * @memberof ListViewTag */ private _onmousedown; /** * placeholder of drag and drop mouse up event handle * * @private * @memberof ListViewTag */ private _onmouseup; /** * placeholder of drag and drop mouse move event handle * * @private * @memberof ListViewTag */ private _onmousemove; /** * Reference to the latest selected DOM item * * @private * @type {ListViewItemTag} * @memberof ListViewTag */ private _selectedItem; /** * A collection of selected items in the list. * The maximum size of this collection is 1 if * the [[multiselect]] feature is disabled * * @private * @type {ListViewItemTag[]} * @memberof ListViewTag */ private _selectedItems; /** * Data placeholder of the list * * @private * @type {GenericObject[]} * @memberof ListViewTag */ private _data; /** * Event data passing between mouse event when performing * drag and drop on the list * * @private * @type {{ from: ListViewItemTag; to: ListViewItemTag }} * @memberof ListViewTag */ private _dnd; /** *Creates an instance of ListViewTag. * @memberof ListViewTag */ constructor(); /** * Reset the tag's properties to the default values * * @protected * @memberof ListViewTag */ protected init(): void; /** * This function does nothing * * @protected * @param {*} [d] * @memberof ListViewTag */ protected reload(d?: any): void; /** * Setter: toggle between dropdown and traditional list * * Getter: Check whether the list is dropdown or traditional list * * @memberof ListViewTag */ set dropdown(v: boolean); /** * Set drag and drop event handle * * @memberof ListViewTag */ set ondragndrop(v: TagEventCallback>); /** * Set list select event handle * * @memberof ListViewTag */ set onlistselect(v: TagEventCallback); /** * Set double click event handle * * @memberof ListViewTag */ set onlistdbclick(v: TagEventCallback); /** * Set item close event handle * * @memberof ListViewTag */ set onitemclose(v: (e: TagEventType) => boolean); get dropdown(): boolean; /** * Setter: * * Set the default tag name of list's items. * If the tag name is not specified in the * data of a list item, this tag will be used * * Getter: * * Get the default tag name of list item * * @memberof ListViewTag */ set itemtag(v: string); get itemtag(): string; /** * Setter: * * Turn on/off of the `multiselect` feature * * Getter: * * Check whether multi-select is allowed * in this list * * @memberof ListViewTag */ set multiselect(v: boolean); get multiselect(): boolean; /** * Setter: Enable/disable drag and drop event in the list * * Getter: Check whether the drag and drop event is enabled * * @memberof ListViewTag */ set dragndrop(v: boolean); get dragndrop(): boolean; /** * Set the buttons layout of the list. * Button layout allows to add some custom * behaviors to the list. * * Each button data should define the [[onbtclick]] * event handle to specify the custom behavior * * When the list is configured as dropdown. The buttons * layout will be disabled * * Example of a button data: * * ``` * { * text: "Button text", * icon: "home://path/to/icon.png", * iconclass: "icon-class-name", * onbtclick: (e) => console.log(e) * } * ``` * * @memberof ListViewTag */ set buttons(v: GenericObject[]); /** * Getter: Get data of the list * * Setter: Set data to the list * * @type {GenericObject[]} * @memberof ListViewTag */ get data(): GenericObject[]; set data(data: GenericObject[]); /** * Do nothing * * @protected * @memberof ListViewTag */ protected ondatachange(): void; /** * Setter: Select list item(s) by their indexes * * Getter: Get the indexes of all selected items * * @memberof ListViewTag */ set selected(idx: number | number[]); /** * Get the latest selected item * * @readonly * @type {ListViewItemTag} * @memberof ListViewTag */ get selectedItem(): ListViewItemTag; /** * Get all the selected items * * @readonly * @type {ListViewItemTag[]} * @memberof ListViewTag */ get selectedItems(): ListViewItemTag[]; get selected(): number | number[]; /** * Add an item to the beginning of the list * * @param {GenericObject} item * @returns {ListViewItemTag} the added list item element * @memberof ListViewTag */ unshift(item: GenericObject): ListViewItemTag; /** * check whether the list has data * * @private * @param {GenericObject} v * @returns * @memberof ListViewTag */ private has_data; /** * Add an item to the beginning or end of the list * * @param {GenericObject} item list item data * @param {boolean} [flag] indicates whether to add the item in the beginning of the list * @returns {ListViewItemTag} the added list item element * @memberof ListViewTag */ push(item: GenericObject, flag?: boolean): ListViewItemTag; /** * Delete an item * * @param {ListViewItemTag} item item DOM element * @memberof ListViewTag */ delete(item: ListViewItemTag): void; /** * Select item next to the currently selected item. * If there is no item selected, the first item will * be selected * * @returns {void} * @memberof ListViewTag */ selectNext(): void; /** * Select the previous item in the list. * * @returns {void} * @memberof ListViewTag */ selectPrev(): void; /** * Unselect all the selected items in the list * * @returns {void} * @memberof ListViewTag */ unselect(): void; /** * This function triggers the click event on an item * * @private * @param {TagEventType} e tag event object * @param {boolean} flag indicates whether this is a double click event * @returns {void} * @memberof ListViewTag */ private iclick; /** * This function triggers the double click event on an item * * @private * @param {TagEventType} e tag event object * @returns * @memberof ListViewTag */ private idbclick; /** * This function triggers the list item select event * * @private * @param {TagEventType} e tag event object * @returns * @memberof ListViewTag */ private iselect; /** * Mount the tag and bind some basic event * * @protected * @returns {void} * @memberof ListViewTag */ protected mount(): void; /** * This function triggers the item close event * * @private * @param {TagEventType} e tag event object * @returns {void} * @memberof ListViewTag */ private iclose; /** * Show the dropdown list. * This function is called only when the list is a dropdown * list * * @protected * @param {*} e * @returns {void} * @memberof ListViewTag */ protected showlist(e: any): void; /** * Hide the dropdown list. * This function is called only when the list is a dropdown * list * * @protected * @param {*} e * @memberof ListViewTag */ protected dropoff(e: any): void; /** * calibrate the list layout * * @protected * @returns {void} * @memberof ListViewTag */ protected calibrate(): void; /** * List view layout definition * * @protected * @returns {TagLayoutType[]} * @memberof ListViewTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * This class defines basic AFX label tag. * A label contains a text and an icon (optional) * * @export * @class LabelTag * @extends {AFXTag} */ class LabelTag extends AFXTag { /** * placeholder of the text to be displayed * * @private * @type {(string | FormattedString)} * @memberof LabelTag */ private _text; /** *Creates an instance of LabelTag. * @memberof LabelTag */ constructor(); /** * this implementation does nothing in this tag * * @protected * @memberof LabelTag */ protected mount(): void; /** * Refresh the text in the label * * @protected * @param {*} d * @memberof LabelTag */ protected reload(d: any): void; /** * Reset to default some property value * * @protected * @memberof LabelTag */ protected init(): void; /** * This implementation of the function does nothing * * @protected * @memberof LabelTag */ protected calibrate(): void; /** * Set the VFS path of the label icon * * @memberof LabelTag */ set icon(v: string); /** * Set the CSS class of the label icon * * @memberof LabelTag */ set iconclass(v: string); /** * Setter: Set the text of the label * * Getter: Get the text displayed on the label * * @memberof LabelTag */ set text(v: string | FormattedString); get text(): string | FormattedString; /** * Lqbel layout definition * * @protected * @returns {TagLayoutType[]} * @memberof LabelTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * An overlay tag is a layout tag that alway stay on top of * the virtual desktop environment. Tile layout elements ([[VBoxTag]], [[HboxTag]]) * can be used inside this tag to compose elements * * @export * @class OverlayTag * @extends {AFXTag} */ class OverlayTag extends AFXTag { /** * Tag width placeholder * * @private * @type {string} * @memberof OverlayTag */ private _width; /** * Tag height place holder * * @private * @type {string} * @memberof OverlayTag */ private _height; /** *Creates an instance of OverlayTag. * @memberof OverlayTag */ constructor(); /** * Put the tag on top of the virtual desktop environment * * @protected * @memberof OverlayTag */ protected init(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof OverlayTag */ protected reload(d?: any): void; /** * Setter: * * Set the width of the tag, the tag width should be in form of: * `100px` of `80%` * * Getter: * * Get the tag width * * @memberof OverlayTag */ set width(v: string); get width(): string; /** * Setter: * * Set the tag height, the tag height should be in form of: * `100px` of `80%` * * Getter: * * Get the tag height * * @memberof OverlayTag */ set height(v: string); get height(): string; /** * Calibrate the element when mounting * * @protected * @returns {void} * @memberof OverlayTag */ protected mount(): void; /** * Calibrate the width and height of the tag * * @returns {void} * @memberof OverlayTag */ calibrate(): void; /** * Layout definition of the tag * * @protected * @returns {TagLayoutType[]} * @memberof OverlayTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * A slider or track bar is a graphical control element with which * a user may set a value by moving an indicator, usually horizontally * * @class SliderTag * @extends {AFXTag} */ class SliderTag extends AFXTag { /** * Slider max value placeholder * * @private * @type {number} * @memberof SliderTag */ private _max; /** * Current slider value placeholder * * @private * @type {number} * @memberof SliderTag */ private _value; /** * Placeholder of the on change event handle * * @private * @type {TagEventCallback} * @memberof SliderTag */ private _onchange; /** * Placeholder of the on changing event handle * * @private * @type {TagEventCallback} * @memberof SliderTag */ private _onchanging; /** * Creates an instance of SliderTag. * @memberof SliderTag */ constructor(); /** * Init the default value of the slider: * - `max`: 100 * - `value`: 0 * * @protected * @memberof SliderTag */ protected init(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof SliderTag */ protected reload(d?: any): void; /** * Set value change event handle. * This handle will be triggered when the * slider indicator is released * * @memberof SliderTag */ set onvaluechange(f: TagEventCallback); /** * Set value changing event handle. * This handle is triggered when moving the * slider indicator * * @memberof SliderTag */ set onvaluechanging(f: TagEventCallback); /** * Setter: Enable/disable the slider * * Getter: Check whether the slider is enabled * * @memberof SliderTag */ set enable(v: boolean); get enable(): boolean; /** * Setter: Set the slider value * * Getter: Get the current slider value * * @memberof SliderTag */ set value(v: number); get value(): number; /** * Setter: Set the maximum value of the slider * * Getter: Get the maximum value of the slider * * @memberof SliderTag */ set max(v: number); get max(): number; /** * Mount the tag and bind some basic events * * @protected * @memberof SliderTag */ protected mount(): void; /** * Calibrate the slide based on its value and max value * * @memberof SliderTag */ calibrate(): void; /** * enable dragging on the slider indicator * * @private * @memberof SliderTag */ private enable_dragging; /** * Layout definition * * @protected * @returns {TagLayoutType[]} * @memberof SliderTag */ protected layout(): TagLayoutType[]; } } } } declare namespace OS { namespace GUI { namespace tag { /** * A system panel contains the following elements: * - Spotlight to access to applications menu * - Current focused application menu * - System tray for all running services running in background * * @export * @class SystemPanelTag * @extends {AFXTag} */ class SystemPanelTag extends AFXTag { /** * Reference to spotlight data * * @private * @type {(GenericObject)} * @memberof SystemPanelTag */ private _osmenu; /** * Placeholder indicates whether the spotlight is currently shown * * @private * @type {boolean} * @memberof SystemPanelTag */ private _view; /** * Store pending loading task * * @private * @type {number[]} * @memberof SystemPanelTag */ private _pending_task; /** * Loading animation check timeout * * @memberof SystemPanelTag */ private _loading_toh; /** * Place holder for a private callback function * * @private * @memberof SystemPanelTag */ private _cb; /** * Place holder for system app list * * @private * @type {GenericObject[]} * @memberof SystemPanelTag */ private app_list; /** *Creates an instance of SystemPanelTag. * @memberof SystemPanelTag */ constructor(); /** * Do nothing * * @protected * @memberof SystemPanelTag */ protected init(): void; /** * Do nothing * * @protected * @param {*} [d] * @memberof SystemPanelTag */ protected reload(d?: any): void; /** * Attach a service to the system tray on the pannel, * this operation is performed when a service is started * * @param {BaseService} s * @returns * @memberof SystemPanelTag */ attachservice(s: application.BaseService): void; /** * Launch the selected application from the spotlight * applications list * * @private * @returns {void} * @memberof SystemPanelTag */ private open; /** * Perform spotlight search operation on keyboard event * * @private * @param {JQuery.KeyboardEventBase} e * @returns {void} * @memberof SystemPanelTag */ private search; /** * detach a service from the system tray of the panel. * This function is called when the corresponding running * service is killed * * @param {BaseService} s * @memberof SystemPanelTag */ detachservice(s: application.BaseService): void; /** * Layout definition of the panel * * @protected * @returns {TagLayoutType[]} * @memberof SystemPanelTag */ protected layout(): TagLayoutType[]; /** * Refresh applications list on the spotlight widget * from system packages meta-data * * @private * @memberof SystemPanelTag */ private refreshAppList; /** * Show/hide the spotlight * * @private * @param {boolean} flag * @memberof SystemPanelTag */ private toggle; /** * Calibrate the spotlight widget * * @memberof SystemPanelTag */ calibrate(): void; /** * Refresh the pinned applications menu * * @private * @memberof SystemPanelTag */ private RefreshPinnedApp; /** * Check if the loading tasks ended, * if it the case, stop the animation * * @private * @memberof SystemPanelTag */ private animation_check; /** * Mount the tag bind some basic event * * @protected * @memberof SystemPanelTag */ protected mount(): void; } } } }