From bfeef223a8dfb5e6d0f97ecec743a993de0c3f8c Mon Sep 17 00:00:00 2001 From: DanyLE Date: Sat, 27 Jul 2024 11:50:04 +0200 Subject: [PATCH] improve: allow changing year in calendar widget --- Makefile | 4 +- d.ts/antos.d.ts | 18464 ++++++++++----------- src/core/tags/CalendarTag.ts | 21 +- src/themes/default/afx-calendar-view.css | 13 + src/themes/system/afx-calendar-view.css | 4 +- 5 files changed, 9267 insertions(+), 9239 deletions(-) diff --git a/Makefile b/Makefile index aca6d5e..70551e6 100644 --- a/Makefile +++ b/Makefile @@ -8,11 +8,11 @@ TSC=./node_modules/typescript/bin/tsc UGLIFYJS=./node_modules/terser/bin/terser UGLIFYCSS=./node_modules/uglifycss/uglifycss -VERSION?=2.0.0-b +VERSION?=2.0.1-b BUILDID?=master GSED=sed -UNAME_S := $(shell uname -s) +UNAME_S := $(shell uname -s)cd ifeq ($(UNAME_S),Darwin) GSED=gsed endif diff --git a/d.ts/antos.d.ts b/d.ts/antos.d.ts index 64d4d58..a81db19 100644 --- a/d.ts/antos.d.ts +++ b/d.ts/antos.d.ts @@ -1,3 +1,9020 @@ +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 {@link 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 {@link 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 {@link RequestResult} + * which contains an error or an object of {@link 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 {@link 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 {@link 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 {@link 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 {@link 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 {@link 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 {@link RequestResult} that + * contains an error or a {@link OS.setting.UserSettingType} object + */ + function auth(): Promise; + /** + * Perform a login operation + * + * @export + * @param {UserLoginType} d user data {@link UserLoginType} + * @returns {Promise} a promise on a {@link RequestResult} that + * contains an error or a {@link OS.setting.UserSettingType} object + */ + function login(d: UserLoginType): Promise; + /** + * Perform a logout operation + * + * @export + * @returns {Promise} a promise on a {@link RequestResult} + */ + function logout(): Promise; + /** + * Save the current user settings + * + * @export + * @returns {Promise} a promise on a {@link RequestResult} + */ + function setting(): Promise; + /** + * Query the current versions of all system components + * + * @export + * @returns {Promise} a promise on a {@link RequestResult} + */ + function versions(): Promise; + } + } +} +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); + /** + * Purge the model from the system + * + * @protected + * @memberof BaseModel + */ + protected destroy(): 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 + * + * + * @returns {void} + * @memberof BaseDialog + */ + 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; + /** + * blur the sub-window + * + * @returns {void} + * @memberof SubWindow + */ + blur(): 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; + /** + * Show the dialog + * + * @memberof BaseDialog + */ + show(): 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 { + ['constructor']: typeof BasicDialog; + /** + * 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 {@link 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 {@link PromptDialog} nut allows + * user to input multi-line text. + * + * Refer to {@link 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: {@link 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 { + /** + * 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 { + /** + * Enum definition of different UI locattion + * + * @export + * @enum {string } + */ + enum ANCHOR { + /** + * Center top + */ + NORTH = "NORTH", + /** + * Center bottom + */ + SOUTH = "SOUTH", + /** + * Center left + */ + WEST = "WEST", + /** + * Center right + */ + EST = "EST", + /** + * Top left + */ + NORTH_WEST = "NORTH_WEST", + /** + * Bottom left + */ + SOUTH_WEST = "SOUTH_WEST", + /** + * Top right + */ + NORTH_EST = "NORTH_EST", + /** + * Bottom right + */ + SOUTH_EST = "SOUTH_EST" + } + /** + * 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 {@link 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 {@link 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. + * @return {Promise} a promise object + */ + function loadScheme(path: string, app: BaseModel, parent: HTMLElement | string): Promise; + /** + * 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; + /** + * Get the system dock tag + * + * @export + * @return {*} {GUI.tag.AppDockTag} + */ + function systemDock(): GUI.tag.AppDockTag; + /** + * Get the current virtual desktop + * + * @export + * @return {*} {GUI.tag.DesktopTag} + */ + function desktop(): GUI.tag.DesktopTag; + /** + * 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; + /** + * Toast notification configuration options + * + * + * @export + * @interface ToastOptions + */ + interface ToastOptions { + /** + * Where the Toast is displayed? see {@link ANCHOR} + * + * @type {ANCHOR} + * @memberof ToastOptions + */ + location?: ANCHOR; + /** + * Timeout (in seconds) before the Toast disappears + * Set this value to 0 to prevent the Toast to disappear, + * in this case, user need to explicitly close the notification + * + * @type {number} + * @memberof ToastOptions + */ + timeout?: number; + /** + * AFXTag that is used to render the data + * + * @type {number} + * @memberof ToastOptions + */ + tag?: string; + } + /** + * Toast notification API + * Show a toast message on different posisition on screen, see {@link ToastOptions} + * + * @export + * @param + * @returns + */ + function toast(data: any, opts?: ToastOptions, app?: application.BaseApplication): void; + /** + * 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 {@link application} namespace. + * + * This process is similar to uninstall the application + * from the current system state + * + * @export + * @param {string} app + */ + function unloadApp(app: string, save?: boolean): void; + /** + * Create a service process. + * + * Services are singleton processes, there is only + * one process of a service at a time + * + * @export + * @param {string} ph + * @param {AppArgumentsType[]} [params] service arguments + * @returns {Promise} + */ + function pushService(ph: string, params?: AppArgumentsType[]): 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 {@link 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 {@link OS.Version} if the string + * is in the format recognized by {@link OS.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 {@link OS.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 Array prototype with some API + * functions used by AntOS API + * + * @interface Array + * @template T + */ +interface Array { + /** + * Check if the array includes an element + * + * @param {T} element to check + * @returns {boolean} + * @memberof Array + */ + includes(element: T): boolean; +} +/** + * Extend the Data prototype with the + * {@link timestamp} function + * + * @interface Date + */ +interface Date { + /** + * Return the timestamp of the current Date object + * + * @returns {number} + * @memberof Date + */ + timestamp(): number; + /** + * Covnert to GMTString + * + * @returns {number} + * @memberof Date + */ + toGMTString(): string; +} +/** + * Generic key-value pair object interface + * + * @interface GenericObject + * @template T + */ +interface GenericObject { + [index: string]: T; +} +/** + * Global function to create a {@link OS.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 {@link 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]-[build ID]) + * + * e.g.: 1.2.3-r-b means that: + * - version major number is 1 + * - version minor number is 2 + * - patch version is 3 + * - the current branch is release `r` + * - build ID (optional) + * ``` + * + * @export + * @class Version + */ + class Version { + /** + * The version string + * + * @private + * @type {string} + * @memberof Version + */ + private 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; + /** + * Version build ID (optional): usually the current git commit hash + * + * @type {number} + * @memberof Version + */ + build_id: string; + /** + *Creates an instance of Version. + * + * @param {string} string string represents the version + * @memberof Version + */ + constructor(string: string); + /** + * Setter/getter to set the version string to the object + * + * @memberof Version + */ + set version_string(v: string); + get version_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 {@link OS.Version} + */ + const VERSION: Version; + /** + * Variable represents the current AntOS source code repository + * is an instance of string + */ + const REPOSITORY: string; + /** + * Indicate whether the current de + */ + var mobile: boolean; + /** + * Register a model prototype to the system namespace. + * There are two types of model to be registered, if the model + * is of type {@link OS.GUI.SubWindow}, its prototype will be registered + * in the {@link OS.GUI.dialogs} namespace, otherwise, if the model type + * is {@link OS.application.BaseApplication} or {@link OS.application.BaseService}, its prototype will be + * registered in the {@link 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 {@link OS.GUI.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]: () => Promise; + }; + /** + * Perform the system shutdown operation. This function calls all + * clean up handles in {@link cleanupHandles}, then save the system setting + * before exiting + * + * @export + */ + function exit(): void; + /** + * Register a callback to the system {@link cleanupHandles} + * + * @export + * @param {string} n callback string name + * @param {() => void} f the callback handle + * @returns + */ + function onexit(n: string, f: () => Promise): () => Promise; + /** + * 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 {@link pkgname} should be specified + * + * @type {string} + * @memberof PackageMetaType + */ + app?: string; + /** + * Package name, in case of {@link 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 {@link 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; + /** + * A task is a Promise object that is tracked by AntOS via the + * Announcerment system + * + * Task manager implementation can subscribe to the following global events + * - ANTOS-TASK-PENDING : a new task/promise is created and executing + * - ANTOS-TASK-FULFILLED: a fullfilled task is a resolved promise + * - ANTOS-TASK-REJECTED: a rejected task is a rejected or error promise + * + * Whenever a task is created by this API, it states will be automatically announced + * to any subscribers of these events + * + * @export + * @param {Promise} a Promise object + */ + function Task(fn: (resolve: (any: any) => void, reject: (any: any) => void) => void): Promise; + /** + * 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; + /** + * 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 {@link RequestResult}. + * A success request result should contain a list of {@link 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 {@link 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 {@link 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 {@link 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 + * `SYSTEM-LOCALE-CHANGED` 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; + /** + * A watcher is a Proxy wrapper to an object + * + * It is used to automatically detect changes in the + * target object and notify the change to a callback + * handler + * + * @export + * @param {Object} target object + * @param {(obj: Object, key: string, value: any, path: any[]) => void} callback function + * @returns {Proxy} the wrapper object + */ + function watcher(target: GenericObject, callback: (obj: Object, key: any, value: any, path: any[]) => void): Object; + } +} +/// +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 { + /** + * Watcher of all settings specific to the application. + * The settings stored in this object will be saved to application folder + * in JSON format as .settings.json and will be loaded automatically + * when application is initialized. + * + * This object is globally acessible to all processes of the same application + * + * @type {GenericObject} + * @memberof BaseApplication + */ + static setting_wdg: GenericObject; + /** + * Reference to per application setting i.e. setting_wdg + * + * @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; + /** + *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(): Promise; + /** + * API function to register responsive UI event to the current window tag + * + * @protected + * @param {GUI.TagResponsiveValidator} responsive validator + * @param {GUI.TagResponsiveCallback} responsive callback + * @returns {void} + * @memberof BaseApplication + */ + protected morphon(validator: GUI.TagResponsiveValidator, callback: GUI.TagResponsiveCallback): void; + /** + * API function to unregister responsive UI event from current window tag + * + * @protected + * @param {GUI.TagResponsiveValidator} responsive validator + * @returns {void} + * @memberof BaseApplication + */ + protected morphoff(validator: GUI.TagResponsiveValidator): void; + /** + * Render the application UI by first loading its scheme + * and then mount this scheme to the DOM tree + * + * @protected + * @returns {Promise} + * @memberof BaseApplication + */ + protected loadScheme(): Promise; + /** + * API function to perform an heavy task. + * This function will create a Task that is tracked by any + * task manager implementation + * + * @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 + * + * @param {string} name locale name e.g. `en_GB` + * @returns {void} + * @memberof BaseApplication + */ + 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; + /** + * 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; + /** + * Getter to access the application window instance + * + * @memberof BaseApplication + */ + get window(): GUI.tag.WindowTag; + /** + * 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 {@link 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[]; + /** + * Show local toast notification + * + * @param {any} data to send + * @param {GUI.ToastOptions} notification options see {@link GUI.ToastOptions} + * @returns {void} + * @memberof BaseApplication + */ + toast(data: any, opts?: GUI.ToastOptions): void; + /** + * The cleanup function that is called by {@link 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 { + /** + * 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 ({@link OS.GUI.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 {HTMLElement} + * @memberof BaseModel + */ + protected host: HTMLElement; + /** + * 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 + * + * @param {string} name + * @memberof BaseModel + */ + updateLocale(name: string): void; + /** + * Render the model's UI + * + * @protected + * @param {string} p VFS path to the UI scheme definition + * @returns {Promise} + * @memberof BaseModel + */ + protected render(p: string): Promise; + /** + * 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; + /** + * Purge the model from the system + * + * @protected + * @memberof BaseModel + */ + protected destroy(): 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 + * + * @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: API.AnnouncementDataType) => void} f event callback + * @returns {void} + * @memberof BaseModel + */ + subscribe(e: string, f: (d: API.AnnouncementDataType) => 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 {@link OS.GUI.dialogs.YesNoDialog} to confirm a task + * + * @protected + * @param {GenericObject} data {@link OS.GUI.dialogs.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 {any} u_data user data object if any + * @returns {void} + * @memberof BaseModel + */ + protected publish(t: string, m: string | FormattedString, u_data?: any): void; + /** + * Publish a global notification + * + * @param {(string | FormattedString)} m notification string + * @param {any} u_data user data object if any + * @returns {void} + * @memberof BaseModel + */ + notify(m: string | FormattedString, data?: any): 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): T; + /** + * 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 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 { + /** + * 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; + /** + * placeholder for directory changed event callback + * + * @private + * @type {TagEventCallback} + * @memberof FileViewTag + */ + private _ondirchanged; + /** + * Reference to the all selected files meta-datas + * + * @private + * @type {API.FileInfoType[]} + * @memberof FileViewTag + */ + private _selectedFiles; + /** + * 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 {@link 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 {@link TagEventType} with the data type `T` is {@link API.FileInfoType} + * + * @memberof FileViewTag + */ + set onfileselect(e: TagEventCallback); + /** + * set the callback handle for the directory changed event. + * The parameter of the callback should be an object + * of type {@link TagEventType} with the data type `T` is {@link API.VFS.BaseFileHandle} + * + * @memberof FileViewTag + */ + set onchdir(e: TagEventCallback); + /** + set the callback handle for the file open event. + * The parameter of the callback should be an object + * of type {@link TagEventType} with the data type `T` is {@link 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 {@link 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; + /** + * Setter: + * + * Allow multiple selection on file view + * + * Getter: + * + * Check whether the multiselection is actived + * + * @memberof FileViewTag + */ + set multiselect(v: boolean); + get multiselect(): boolean; + /** + * Get the current selected file + * + * @readonly + * @type {API.FileInfoType} + * @memberof FileViewTag + */ + get selectedFile(): API.FileInfoType; + /** + * Get all selected files + * + * @readonly + * @type {API.FileInfoType[]} + * @memberof FileViewTag + */ + get selectedFiles(): API.FileInfoType[]; + /** + * Setter: + * + * Set the path of the current working directory. + * When called the widget will refresh the current + * working directory using the configured {@link 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[]; + } + } + } +} +/// +/** + * + * 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.StackMenuTag} m The context menu element {@link OS.GUI.tag.StackMenuTag} + * @memberof HTMLElement + */ + contextmenuHandle(e: JQuery.MouseEventBase, m: OS.GUI.tag.StackMenuTag): 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; + /** + * Enable the drag event dispatching on this + * element + * + * This will trigger the `dragging` and `drop` event on the enabled + * element when the mouse is down, move, then up, then move + * + * The event can be listened using the traditional way, + * Example: + * ``` + * elem.addEventListener('dragging', (e) => { }, false); + * elem.addEventListener('drop', (e) => { }, false); + * ``` + * + * @meberof HTMLElement + */ + enable_drag(): void; + /** + * Perform DOM generation ({@link afxml}) then mount ({@link 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 {@link OS.GUI.AFXTag.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; + /** + * Original event if any + * + * @type {any} + * @memberof TagEventType + */ + originalEvent?: any; + /** + * is root tag? + * + * @type {boolean} + * @memberof TagEventType + */ + root?: boolean; + } + /** + * 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 + * + * @export + */ + type TagEventCallback = (e: TagEventType) => void; + /** + * Tag responsive envent callback type + * + * @export + */ + type TagResponsiveCallback = (fullfilled: boolean) => void; + /** + * Tag responsive validator type + * + * @export + */ + type TagResponsiveValidator = (w: number, h: number) => boolean; + /** + * Definitions of some default tag responsive validators + * + * @export + */ + const RESPONSIVE: { + /** + * Extra small devices (phones, 600px and down) + */ + TINY: (w: number, _h: number) => boolean; + SMALL: (w: number, _h: number) => boolean; + MEDIUM: (w: number, _h: number) => boolean; + /** + * Large devices (laptops/desktops, 992px and up) + */ + LARGE: (w: number, _h: number) => boolean; + /** + * Extra large devices (large laptops and desktops, 1200px and up) + */ + HUGE: (w: number, _h: number) => boolean; + /** + * Portrait mode + */ + PORTRAIT: (w: number, h: number) => boolean; + /** + * Landscape mode + */ + LANDSCAPE: (w: number, h: number) => boolean; + }; + /** + * 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 {@link 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; + /** + * a {@link ResponsiveHandle} to handle all responsive event + * related to this tag + * + * @private + * @memberof AFXTag + */ + private _responsive_handle; + private _responsive_check; + /** + * 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; + /** + * Setter: Enable/disable responsive tag + * + * Getter: get responsive status + */ + set responsive(v: boolean); + get responsive(): boolean; + /** + * Register a responsive event to this tag + * + * @param {TagResponsiveValidator} responsive validator + * @param {TagResponsiveCallback} responsive callback + * @memberof AFXTag + */ + morphon(validator: TagResponsiveValidator, callback: TagResponsiveCallback): void; + /** + * Unregister a responsive event from this tag + * + * @param {TagResponsiveValidator} responsive validator + * @memberof AFXTag + */ + morphoff(validator: TagResponsiveValidator): void; + /** + * Attach a data to this tag + * + * This function will define a getter `domel` + * in the attached data, this getter refers to the + * current tag + * + * @returns {void} + * @memberof AFXTag + */ + attach(data: GenericObject): void; + /** + * 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 {@link 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 {@link 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 { + /** + * Alias to all classes that extends {@link AFXTag} + */ + type AFXTagTypeClass = { + new (): T; + }; + /** + * 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 {@link 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 { + /** + * List item event data type + */ + type ListItemEventData = TagEventDataType; + /** + * A list item represent the individual view of an item in the {@link OS.GUI.tag.ListViewTag}. + * 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 + */ + /** + * 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 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 {@link itemlayout} + * + * @protected + * @returns {TagLayoutType[]} + * @memberof ListViewItemTag + */ + protected layout(): TagLayoutType[]; + /** + * Setter: + * + * Set the data of the list item. This will + * trigger the {@link 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 | TagLayoutType[]} + * @memberof ListViewItemTag + */ + protected abstract itemlayout(): TagLayoutType | 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 | TagLayoutType[]} + * @memberof SimpleListItemTag + */ + protected itemlayout(): TagLayoutType | TagLayoutType[]; + } + /** + * The layout of a double line list item contains two + * AFX labels + * + * @export + * @class DoubleLineListItemTag + * @extends {ListViewItemTag} + */ + class DoubleLineListItemTag extends ListViewItemTag { + /** + *Creates an instance of DoubleLineListItemTag. + * @memberof DoubleLineListItemTag + */ + constructor(); + /** + * Reset some property to default + * + * @protected + * @memberof DoubleLineListItemTag + */ + protected init(): void; + /** + * Do nothing + * + * @protected + * @memberof DoubleLineListItemTag + */ + protected calibrate(): void; + /** + * Refresh the inner label when the item data + * is changed + * + * @protected + * @returns {void} + * @memberof DoubleLineListItemTag + */ + protected ondatachange(): void; + /** + * Re-render the list item + * + * @protected + * @memberof DoubleLineListItemTag + */ + protected reload(): void; + /** + * List item custom layout definition + * + * @protected + * @returns {TagLayoutType | TagLayoutType[]} + * @memberof DoubleLineListItemTag + */ + protected itemlayout(): TagLayoutType | 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 {@link multiselect} feature is disabled + * + * @private + * @type {ListViewItemTag[]} + * @memberof ListViewTag + */ + private _selectedItems; + /** + * The anchor element that the list view positioned on + * This is helpful when rendering dropdown list + * @private + * @type{HTMLElement} + * @memberof ListViewTag + */ + private _anchor; + /** + * Data placeholder of the list + * + * @private + * @type {GenericObject[]} + * @memberof ListViewTag + */ + private _data; + private _drop; + private _show; + /** + * 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 {@link OS.GUI.tag.ButtonTag.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 list direction: row or column (default) + * + * Setter: Get list direction: row or column + * + * @type {string} + * @memberof ListViewTag + */ + set dir(v: string); + get dir(): string; + /** + * 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 the selected item index + * + * @readonly + * @type {number} + * @memberof ListViewTag + */ + 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 + * + * @protected + * @param {TagEventType} e tag event object + * @returns + * @memberof ListViewTag + */ + protected idbclick(e: TagEventType): void; + /** + * This function triggers the list item select event + * + * @protected + * @param {TagEventType} e tag event object + * @returns + * @memberof ListViewTag + */ + protected iselect(e: TagEventType): void; + /** + * 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; + /** + * Scroll the list view to end + * + * @memberof ListViewTag + */ + scroll_to_end(): void; + /** + * Scroll the list view to beginning + * + * @memberof ListViewTag + */ + scroll_to_start(): 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 { + /** + * 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 { + namespace tag { + /** + * This tag define a basic text input and its behavior + * + * @export + * @class InputTag + * @extends {AFXTag} + */ + class InputTag extends AFXTag { + /** + *Creates an instance of InputTag. + * @memberof InputTag + */ + constructor(); + /** + * Set the path to the header icon, the path should be + * a VFS file path + * + * @memberof InputTag + */ + set icon(v: string); + /** + * Set the icon class to the header + * + * @memberof InputTag + */ + set iconclass(v: string); + /** + * Alias to header setter/getter + * + * @memberof InputTag + */ + set text(v: string | FormattedString); + get text(): string | FormattedString; + /** + * Setter: Set the text of the label + * + * Getter: Get the current label test + * + * @memberof InputTag + */ + set label(v: string | FormattedString); + get label(): string | FormattedString; + /** + * Setter: Enable or disable the input + * + * Getter: Get the `enable` property of the input + * + * @memberof InputTag + */ + set disable(v: boolean); + get disable(): boolean; + /** + * Setter: set verbosity of the input + * + * Getter: Get the current input verbosity + * + * @memberof InputTag + */ + set verbose(v: boolean); + get verbose(): boolean; + /** + * JQuery style generic event handling on the input element + * + * @param {string} enname: JQuery event name + * @param {JQuery.TypeEventHandler} handle: JQuery handle + * @memberof InputTag + */ + on(ename: string, handle: JQuery.TypeEventHandler): void; + /** + * Manually trigger an event + * + * @param {string} evt: JQuery event name + * @memberof InputTag + */ + trigger(evt: string): void; + /** + * Mount the tag + * + * @protected + * @memberof InputTag + */ + protected mount(): void; + /** + * Get the current active input element + * + * @memberof InputTag + */ + get input(): HTMLInputElement | HTMLTextAreaElement; + /** + * Get/set the current active input value + * + * @memberof InputTag + */ + get value(): string; + set value(v: string); + /** + * Get/set input type + * This only affects the inline input element + * + * @memberof InputTag + */ + get type(): string; + set type(v: string); + /** + * Get/set input name + * + * @memberof InputTag + */ + get name(): string; + set name(v: string); + /** + * Init the tag before mounting + * + * @protected + * @memberof InputTag + */ + protected init(): void; + /** + * Re-calibrate, do nothing in this tag + * + * @protected + * @memberof InputTag + */ + protected calibrate(): void; + /** + * Update the current tag, do nothing in this tag + * + * @param {*} [d] + * @memberof InputTag + */ + reload(d?: any): void; + /** + * Input layout definition + * + * @protected + * @returns {TagLayoutType[]} + * @memberof InputTag + */ + 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; + /** + * Cache of touch event + * + * @private + * @meberof TabBarTag + */ + private _previous_touch; + /** + *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; + /** + * Setter: + * + * Set the tab bar direction: + * - `row`: horizontal direction + * - `column`: vertical direction + * + * Getter: + * + * Get the tab bar direction + * + * @memberof TabBarTag + */ + set dir(v: string); + get dir(): string; + /** + * 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[]; + /** + * Get the latest selected item + * + * @readonly + * @type {ListViewItemTag} + * @memberof TabBarTag + */ + get selectedItem(): ListViewItemTag; + /** + * 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; + /** + * Scroll the tabbar to end + * + * @memberof TabBarTag + */ + scroll_to_end(): void; + /** + * Scroll the tabbar to begin + * + * @memberof TabBarTag + */ + scroll_to_start(): void; + /** + * TabBar layout definition + * + * @protected + * @returns {TagLayoutType[]} + * @memberof TabBarTag + */ + protected layout(): TagLayoutType[]; + } + export {}; + } + } +} +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[]; + } + } + } +} +/// +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 {@link 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 {@link TileLayoutTag} + * such as {@link VBoxTag} or {@link 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: + * - `row` - horizontal direction, resize by width + * - `column` - 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; + /** + * Setter Disable or enable the resize event + * + * @memberof ResizerTag + */ + set disable(v: boolean); + get disable(): boolean; + /** + * 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 { + /** + * 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 horizontal aligment of the label content + * + * @param {string} v shall be "left, right, or center" + */ + set halign(v: string); + /** + * set horizontal aligment of the label content + * + * @param {string} v shall be "top, bottom, or center" + */ + set valign(v: string); + /** + * Set the CSS class of the label icon + * + * @memberof LabelTag + */ + set iconclass(v: string); + /** + * Set the CSS class of the label icon on the right side + * + * @memberof LabelTag + */ + set iconclass_end(v: string); + /** + * Set the CSS class of the label icon on the right side + * + * @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; + /** + * Setter: Turn on/off text selection + * + * Getter: Check whether the label is selectable + * + * @memberof LabelTag + */ + set selectable(v: boolean); + get swon(): boolean; + /** + * Lqbel layout definition + * + * @protected + * @returns {TagLayoutType[]} + * @memberof LabelTag + */ + protected layout(): TagLayoutType[]; + } + } + } +} +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 {@link TabBarTag} + * with a container widget. The attached container widget should be + * composed inside a {@link 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 + * + * @protected + * @type {TagEventCallback} + * @memberof TabContainerTag + */ + protected _ontabselect: TagEventCallback; + /** + *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[]; + /** + * Setter: Select a tab by its index + * Getter: Get the current selected index + * + * @memberof TabContainerTag + */ + set selectedIndex(i: number); + get selectedIndex(): 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[]; + } + } + } +} +/** + * 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 { + /** + * Row item event data type + */ + type GridRowEventData = TagEventDataType; + /** + * 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 + * + * @private + * @type {GenericObject[]} + * @memberof GridRowTag + */ + private _data; + /** + * placeholder for the row select event callback + * + * @private + * @type {TagEventCallback} + * @memberof ListViewItemTag + */ + private _onselect; + /** + *Creates an instance of GridRowTag. + * @memberof GridRowTag + */ + constructor(); + /** + * Set item select event handle + * + * @memberof ListViewItemTag + */ + set onrowselect(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; + /** + * setter: set row data + * + * getter: get row data + */ + set data(v: GenericObject[]); + get data(): GenericObject[]; + /** + * 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 {@link 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 {@link 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 {@link 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 {@link 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; + /** + * Event data passing between mouse event when performing + * drag and drop on the list + * + * @private + * @type {{ from: GridRowTag[]; to: GridRowTag }} + * @memberof GridViewTag + */ + private _dnd; + /** + * placeholder of list drag and drop event handle + * + * @private + * @type {TagEventCallback>} + * @memberof GridViewTag + */ + private _ondragndrop; + /** + * Creates an instance of GridViewTag. + * @memberof GridViewTag + */ + constructor(); + /** + * Set drag and drop event handle + * + * @memberof GridViewTag + */ + set ondragndrop(v: TagEventCallback>); + /** + * Setter: Enable/disable drag and drop event in the list + * + * Getter: Check whether the drag and drop event is enabled + * + * @memberof GridViewTag + */ + set dragndrop(v: boolean); + get dragndrop(): boolean; + /** + * placeholder of drag and drop mouse down event handle + * + * @private + * @memberof GridViewTag + */ + private _onmousedown; + /** + * placeholder of drag and drop mouse up event handle + * + * @private + * @memberof GridViewTag + */ + private _onmouseup; + /** + * placeholder of drag and drop mouse move event handle + * + * @private + * @memberof GridViewTag + */ + private _onmousemove; + /** + * 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; + /** + * Sort the grid using a sort function + * + * @param {context: any} context of the executed function + * @param {(a:GenericObject[], b:GenericObject[]) => boolean} a sort function that compares two rows data + * * @param {index: number} current header index + * @returns {void} + * @memberof GridViewTag + */ + sort(context: any, fn: (a: GenericObject[], b: GenericObject[], index?: number) => number): void; + /** + * Delete a grid rows + * + * @param {GridRowTag} row row DOM element + * @returns {void} + * @memberof GridViewTag + */ + delete(row: GridRowTag): void; + /** + * Scroll the grid view to bottom + * + * @memberof GridViewTag + */ + scroll_to_bottom(): void; + /** + * Scroll the grid view to top + * + * @memberof GridViewTag + */ + scroll_to_top(): 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 GridViewTag + */ + 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; + /** + * Unselect all the selected rows in the grid + * + * @returns {void} + * @memberof GridViewTag + */ + unselect(): void; + /** + * 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 { + /** + * 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 {Promise[]} + * @memberof SystemPanelTag + */ + private _pending_task; + /** + * Flag indicate where the selected application shall be opened + * + * @private + * @type {boolean} + * @memberof SystemPanelTag + */ + private _prevent_open; + /** + * Store the current attached service + * + * @private + * @type {number[]} + * @memberof SystemPanelTag + */ + private _services; + /** + * 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 panel, + * 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; + /** + * Check if the loading tasks ended, + * if it the case, stop the animation + * + * @private + * @memberof SystemPanelTag + */ + private animation_check; + private show_systray; + /** + * Mount the tag bind some basic event + * + * @protected + * @memberof SystemPanelTag + */ + protected mount(): void; + } + } + } +} +/// +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 {any} + * @memberof ButtonTag + */ + private _data; + /** + * Custom user data setter/gettter + * + * @memberof ButtonTag + */ + set data(v: any); + get data(): any; + /** + *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); + /** + * Set the icon class on the right side of the button, this property + * allows to style the button icon using CSS + * + * @memberof ButtonTag + */ + set iconclass$(v: string); + /** + * Set the CSS class of the label icon on the right side + * + * @memberof ButtonTag + */ + set iconclass_end(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[]; + } + } + } +} +declare namespace OS { + namespace GUI { + namespace tag { + type TileItemDirection = "row" | "column" | "row-reverse" | "column-reverse"; + /** + * 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} + */ + export class TileLayoutTag extends AFXTag { + /** + *C reates an instance of TileLayoutTag. + * @memberof TileLayoutTag + */ + constructor(); + private _padding; + /** + * 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: TileItemDirection); + get dir(): TileItemDirection; + /** + * Setter: + * + * SET content padding + * + * Getter: + * + * Get content padding + * + * @memberof TileLayoutTag + */ + set padding(v: number); + get padding(): number; + /** + * setter: Reverse order of the content in the tile + * + * getter: return if the tile's content is in reversed order + * + * @meberof TileLayoutTags + */ + set reversed(v: boolean); + get reversed(): boolean; + /** + * 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} + */ + export 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} + */ + export class VBoxTag extends TileLayoutTag { + /** + *Creates an instance of VBoxTag. + * @memberof VBoxTag + */ + constructor(); + /** + * Mount the tag + * + * @protected + * @memberof VBoxTag + */ + protected mount(): void; + } + export {}; + } + } +} +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 {@link 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 + * {@link 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 {@link 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 {@link TreeViewItemPrototype} and + * define it inner layout using a {@link 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 {@link TreeViewDataType} + * + * @memberof TreeViewTag + */ + 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 { + namespace tag { + /** + * menu event data type definition + */ + type StackMenuEventData = TagEventDataType; + /** + * The layout of a simple stack menu item + * + * @export + * @class SimpleStackMenuItemTag + * @extends {ListViewItemTag} + */ + class SimpleStackMenuItemTag extends ListViewItemTag { + /** + *Creates an instance of SimpleStackMenuItemTag. + * @memberof SimpleStackMenuItemTag + */ + constructor(); + /** + * Reset some property to default + * + * @protected + * @memberof SimpleStackMenuItemTag + */ + protected init(): void; + /** + * Mount the current tag + * + * @protected + * @memberof SimpleStackMenuItemTag + */ + protected mount(): 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 SimpleStackMenuItemTag + */ + set switch(v: boolean); + get switch(): boolean; + /** + * Setter: select/unselect the current item + * + * Getter: Check whether the current item is selected + * + * @memberof SimpleStackMenuItemTag + */ + set selected(v: boolean); + get selected(): boolean; + /** + * Setter: Turn on/off the radio feature of the menu entry + * + * Getter: Check whether the radio feature is enabled + * + * @memberof SimpleStackMenuItemTag + */ + 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 SimpleStackMenuItemTag + */ + set checked(v: boolean); + get checked(): boolean; + /** + * Set the keyboard shortcut text + * + * @memberof SimpleStackMenuItemTag + */ + set shortcut(v: string); + /** + * Do nothing + * + * @protected + * @memberof SimpleStackMenuItemTag + */ + protected calibrate(): void; + /** + * Refresh the inner label when the item data + * is changed + * + * @protected + * @returns {void} + * @memberof SimpleStackMenuItemTag + */ + protected ondatachange(): void; + /** + * Re-render the list item + * + * @protected + * @memberof SimpleStackMenuItemTag + */ + protected reload(): void; + /** + * List item custom layout definition + * + * @protected + * @returns {TagLayoutType} + * @memberof SimpleStackMenuItemTag + */ + protected itemlayout(): TagLayoutType; + } + /** + * A stack menu is a multilevel menu that + * uses a single list view to navigate all menu levels + * instead of using a traditional cascade style menu + * + * @export + * @class StackMenuTag + * @extends {AFXTag} + */ + class StackMenuTag extends AFXTag { + /** + * Data stack, the list always displays the + * element on the top of the stack + * + * @type {GenericObject[][]} + * @memberof StackMenuTag + */ + private stack; + /** + * Update the current tag, do nothing + * + * @protected + * @param {*} [d] + * @memberof StackMenuTag + */ + protected reload(d?: any): void; + /** + * Placeholder of tab select event handle + * + * @private + * @type {TagEventCallback} + * @memberof StackMenuTag + */ + private _onmenuselect; + /** + * Stack menu constructor + * + * @memberof StackMenuTag + */ + constructor(); + /** + * Reset to default some property value + * + * @protected + * @memberof StackMenuTag + */ + protected init(): void; + /** + * Recalcutate the menu coordinate in case of + * context menu + * + * @protected + * @memberof StackMenuTag + */ + protected calibrate(): void; + /** + * Reset the menu to its initial state + * + * @memberof StackMenuTag + */ + reset(): void; + /** + * Mount the menu and bind some basic events + * + * @protected + * @memberof StackMenuTag + */ + protected mount(): void; + /** + * Setter: set current selected item index + * + * Getter: Get current selected item index + * + * @memberof StackMenuTag + */ + set selected(i: number | number[]); + get selected(): number | number[]; + /** + * Setter: Set whether the current menu is a context menu + * + * Getter: Check whether the current menu is a context menu + * + * @memberof StackMenuTag + */ + set context(v: boolean); + get context(): boolean; + /** + * Get the latest selected item + * + * @readonly + * @type {ListViewItemTag} + * @memberof StackMenuTag + */ + get selectedItem(): ListViewItemTag; + /** + * Get all the selected items + * + * @readonly + * @type {ListViewItemTag[]} + * @memberof StackMenuTag + */ + get selectedItems(): ListViewItemTag[]; + /** + * The following setter/getter are keep for backward compatible + * with the MenuTag interface + * + * Setter: Set the menu data + * + * Getter: Get the menu data + * + * @deprecated + * @memberof StackMenuTag + */ + set items(v: GenericObject[]); + get items(): GenericObject[]; + /** + * Setter: Set the menu data + * + * Getter: Get the menu data + * + * @memberof StackMenuTag + */ + set nodes(v: GenericObject[]); + get nodes(): GenericObject[]; + /** + * Set the `menu entry select` event handle + * + * @memberof StackMenuTag + */ + set onmenuselect(v: TagEventCallback); + /** + * Hide the current menu. This function is called + * only if the current menu is context menu + * + * @memberof StackMenuTag + */ + hide(): void; + /** + * 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 StackMenuTag + */ + show(e?: JQuery.MouseEventBase): void; + /** + * Tag layout definition + * + * @protected + * @returns {TagLayoutType[]} + * @memberof StackMenuTag + */ + 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/Getter: set and get precision reading + * + * @memberof SliderTag + */ + set precision(v: boolean); + get precision(): boolean; + /** + * 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 { + /** + * An overlay tag is a layout tag that alway stay on top of + * the virtual desktop environment. Tile layout elements ({@link OS.GUI.tag.VBoxTag}, {@link OS.GUI.tag.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 stack pannel allows to navigate back and forth between pannels + * (container widget). Each container widget in the stack should be + * composed inside a {@link HBoxTag} + * + * + * @export + * @class StackPanelTag + * @extends {AFXTag} + */ + class StackPanelTag extends TabContainerTag { + private _current_pannel_index; + /** + * Mount the tag and bind basic events + * + * @protected + * @memberof StackPanelTag + */ + protected mount(): void; + /** + * Set the tab select event handle + * + * @memberof StackPanelTag + */ + set ontabselect(f: TagEventCallback); + /** + * Navigate to the next panel + * + * @memberof StackPanelTag + */ + navigateNext(): void; + /** + * Navigate back to the previous panel + * + * @memberof StackPanelTag + */ + navigateBack(): void; + /** + * Navigate to a custom panel + * + * @memberof StackPanelTag + */ + private navigate; + } + } + } +} +declare namespace OS { + namespace GUI { + namespace tag { + /** + * Meta tag that represents the virtual desktop environment. + * In near future, we may have multiple virtual desktop environments. + * Each desktop environment has a simple file manager and a window + * manager that render the window in a specific order. + * + * @export + * @class DesktopTag + * @extends {FloatListTag} + */ + class DesktopTag extends FloatListTag { + /** + * internal handle to the desktop file location + * + * @private + * @type {API.VFS.BaseFileHandle} + * @memberof DesktopTag + */ + private file; + /** + * local observer that detect if a new child element is + * added or removed + * + * @private + * @type {MutationObserver} + * @memberof DesktopTag + */ + private observer; + /** + * Internal list of the current opened window + * + * @private + * @type {Set} + * @memberof DesktopTag + */ + private window_list; + /** + * Creates an instance of DesktopTag. + * @memberof DesktopTag + */ + constructor(); + /** + * Mount the virtual desktop to the DOM tree + * + * @protected + * @memberof DesktopTag + */ + protected mount(): void; + /** + * Display all files and folders in the specific desktop location + * + * @return {*} {Promise} + * @memberof DesktopTag + */ + refresh(): Promise; + /** + * Remove this element from its parent + * + * @memberof DesktopTag + */ + remove(): void; + /** + * Active a window above all other windows + * + * @private + * @param {WindowTag} win + * @memberof DesktopTag + */ + private selectWindow; + /** + * Render all windows in order from bottom to top + * + * @private + * @memberof DesktopTag + */ + private render; + } + } + } +} +declare namespace OS { + namespace GUI { + namespace tag { + /** + * Toast notification tag + * + * @export + * @class ToastNotificationTag + * @extends {AFXTag} + */ + class ToastNotificationTag extends AFXTag { + /** + *Creates an instance of ToastNotificationTag. + * @memberof ToastNotificationTag + */ + constructor(); + /** + * Mount the tag + * + * @protected + * @memberof ToastNotificationTag + */ + protected mount(): void; + /** + * Init the tag before mounting + * + * @protected + * @memberof ToastNotificationTag + */ + protected init(): void; + /** + * Re-calibrate tag + * + * @protected + * @memberof ToastNotificationTag + */ + protected calibrate(): void; + /** + * Update the current tag, do nothing in this tag + * + * @param {*} [d] + * @memberof ToastNotificationTag + */ + reload(d?: any): void; + /** + * Tag layout definition + * + * @protected + * @returns {TagLayoutType[]} + * @memberof ToastNotificationTag + */ + protected layout(): TagLayoutType[]; + } + /** + * This tag manage all notification UI on the desktop + * + * @export + * @class NotificationTag + * @extends {AFXTag} + */ + class NotificationTag extends AFXTag { + /** + *Creates an instance of NotificationTag. + * @memberof NotificationTag + */ + constructor(); + /** + * Mount the tag + * + * @protected + * @memberof NotificationTag + */ + protected mount(): void; + /** + * Init the tag before mounting + * + * @protected + * @memberof NotificationTag + */ + protected init(): void; + /** + * Push anotification to a specific location + * + * @memberof NotificationTag + */ + push(tag: AFXTag, loc?: ANCHOR): void; + /** + * Re-calibrate tag + * + * @protected + * @memberof NotificationTag + */ + protected calibrate(): void; + /** + * Update the current tag, do nothing in this tag + * + * @param {*} [d] + * @memberof NotificationTag + */ + reload(d?: any): void; + /** + * Tag layout definition + * + * @protected + * @returns {TagLayoutType[]} + * @memberof NotificationTag + */ + 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); + /** + * 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; + /** + * Calibrate the view of the list + * + * @memberof FloatListTag + */ + calibrate(): void; + } + } + } +} +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 { + /** + * Cache of touch event + * + * @private + * @meberof AppDockTag + */ + private _previous_touch; + /** + * 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; + /** + * Add a button to the dock + * + * @private + * @param {string} [name] associated application name + * @param {AppDockItemType} [item] dock item + * @param {boolean} [pinned] the button is pinned to the dock ? + * @memberof AppDockTag + */ + private add_button; + private update_button; + /** + * 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 + */ + addapp(item: AppDockItemType): void; + /** + * Handle the application selection action + * + * @private + * @returns {Promise} + * @memberof AppDockTag + */ + private handleAppSelect; + /** + * 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; + /** + * refresh the pinned application list + * + * @private + * @memberof AppDockTag + */ + private refresh_pinned_app; + } + } + } +} +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 {@link 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 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 store the callback for the menu open event + * + * @private + * @type {(el: StackMenuTag) => void} + * @memberof WindowTag + */ + private _onmenuopen; + /** + * 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(); + /** + * blur overlay: If active the window overlay will be shown + * on inactive (blur event) + * + * Setter: Enable the switch + * + * Getter: Check whether the switch is enabled + * + * @memberof WindowTag + */ + set blur_overlay(v: boolean); + get blur_overlay(): boolean; + /** + * Setter: set menu open event handler + * + * @memberof WindowTag + */ + set onmenuopen(f: (el: StackMenuTag) => void); + /** + * 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; + /** + * Set the application menu content + * + * @memberof WindowTag + */ + set menu(v: GenericObject[]); + /** + * 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; + /** + * Get the notification tag + * + * @memberof WindowTag + */ + get notification(): NotificationTag; + /** + * 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[]; + } + } + } +} type VFSFileHandleClass = { new (...args: any[]): OS.API.VFS.BaseFileHandle; }; @@ -1063,7593 +10080,6 @@ declare namespace OS { } } } -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); - /** - * Purge the model from the system - * - * @protected - * @memberof BaseModel - */ - protected destroy(): 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 - * - * - * @returns {void} - * @memberof BaseDialog - */ - 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; - /** - * blur the sub-window - * - * @returns {void} - * @memberof SubWindow - */ - blur(): 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; - /** - * Show the dialog - * - * @memberof BaseDialog - */ - show(): 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 { - ['constructor']: typeof BasicDialog; - /** - * 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 {@link 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 {@link PromptDialog} nut allows - * user to input multi-line text. - * - * Refer to {@link 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: {@link 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 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 { - /** - * 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); - /** - * 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; - /** - * Calibrate the view of the list - * - * @memberof FloatListTag - */ - calibrate(): void; - } - } - } -} -/// -declare namespace OS { - namespace GUI { - namespace tag { - /** - * menu event data type definition - */ - type StackMenuEventData = TagEventDataType; - /** - * The layout of a simple stack menu item - * - * @export - * @class SimpleStackMenuItemTag - * @extends {ListViewItemTag} - */ - class SimpleStackMenuItemTag extends ListViewItemTag { - /** - *Creates an instance of SimpleStackMenuItemTag. - * @memberof SimpleStackMenuItemTag - */ - constructor(); - /** - * Reset some property to default - * - * @protected - * @memberof SimpleStackMenuItemTag - */ - protected init(): void; - /** - * Mount the current tag - * - * @protected - * @memberof SimpleStackMenuItemTag - */ - protected mount(): 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 SimpleStackMenuItemTag - */ - set switch(v: boolean); - get switch(): boolean; - /** - * Setter: select/unselect the current item - * - * Getter: Check whether the current item is selected - * - * @memberof SimpleStackMenuItemTag - */ - set selected(v: boolean); - get selected(): boolean; - /** - * Setter: Turn on/off the radio feature of the menu entry - * - * Getter: Check whether the radio feature is enabled - * - * @memberof SimpleStackMenuItemTag - */ - 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 SimpleStackMenuItemTag - */ - set checked(v: boolean); - get checked(): boolean; - /** - * Set the keyboard shortcut text - * - * @memberof SimpleStackMenuItemTag - */ - set shortcut(v: string); - /** - * Do nothing - * - * @protected - * @memberof SimpleStackMenuItemTag - */ - protected calibrate(): void; - /** - * Refresh the inner label when the item data - * is changed - * - * @protected - * @returns {void} - * @memberof SimpleStackMenuItemTag - */ - protected ondatachange(): void; - /** - * Re-render the list item - * - * @protected - * @memberof SimpleStackMenuItemTag - */ - protected reload(): void; - /** - * List item custom layout definition - * - * @protected - * @returns {TagLayoutType} - * @memberof SimpleStackMenuItemTag - */ - protected itemlayout(): TagLayoutType; - } - /** - * A stack menu is a multilevel menu that - * uses a single list view to navigate all menu levels - * instead of using a traditional cascade style menu - * - * @export - * @class StackMenuTag - * @extends {AFXTag} - */ - class StackMenuTag extends AFXTag { - /** - * Data stack, the list always displays the - * element on the top of the stack - * - * @type {GenericObject[][]} - * @memberof StackMenuTag - */ - private stack; - /** - * Update the current tag, do nothing - * - * @protected - * @param {*} [d] - * @memberof StackMenuTag - */ - protected reload(d?: any): void; - /** - * Placeholder of tab select event handle - * - * @private - * @type {TagEventCallback} - * @memberof StackMenuTag - */ - private _onmenuselect; - /** - * Stack menu constructor - * - * @memberof StackMenuTag - */ - constructor(); - /** - * Reset to default some property value - * - * @protected - * @memberof StackMenuTag - */ - protected init(): void; - /** - * Recalcutate the menu coordinate in case of - * context menu - * - * @protected - * @memberof StackMenuTag - */ - protected calibrate(): void; - /** - * Reset the menu to its initial state - * - * @memberof StackMenuTag - */ - reset(): void; - /** - * Mount the menu and bind some basic events - * - * @protected - * @memberof StackMenuTag - */ - protected mount(): void; - /** - * Setter: set current selected item index - * - * Getter: Get current selected item index - * - * @memberof StackMenuTag - */ - set selected(i: number | number[]); - get selected(): number | number[]; - /** - * Setter: Set whether the current menu is a context menu - * - * Getter: Check whether the current menu is a context menu - * - * @memberof StackMenuTag - */ - set context(v: boolean); - get context(): boolean; - /** - * Get the latest selected item - * - * @readonly - * @type {ListViewItemTag} - * @memberof StackMenuTag - */ - get selectedItem(): ListViewItemTag; - /** - * Get all the selected items - * - * @readonly - * @type {ListViewItemTag[]} - * @memberof StackMenuTag - */ - get selectedItems(): ListViewItemTag[]; - /** - * The following setter/getter are keep for backward compatible - * with the MenuTag interface - * - * Setter: Set the menu data - * - * Getter: Get the menu data - * - * @deprecated - * @memberof StackMenuTag - */ - set items(v: GenericObject[]); - get items(): GenericObject[]; - /** - * Setter: Set the menu data - * - * Getter: Get the menu data - * - * @memberof StackMenuTag - */ - set nodes(v: GenericObject[]); - get nodes(): GenericObject[]; - /** - * Set the `menu entry select` event handle - * - * @memberof StackMenuTag - */ - set onmenuselect(v: TagEventCallback); - /** - * Hide the current menu. This function is called - * only if the current menu is context menu - * - * @memberof StackMenuTag - */ - hide(): void; - /** - * 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 StackMenuTag - */ - show(e?: JQuery.MouseEventBase): void; - /** - * Tag layout definition - * - * @protected - * @returns {TagLayoutType[]} - * @memberof StackMenuTag - */ - protected layout(): TagLayoutType[]; - } - } - } -} -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 store the callback for the menu open event - * - * @private - * @type {(el: StackMenuTag) => void} - * @memberof WindowTag - */ - private _onmenuopen; - /** - * 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(); - /** - * blur overlay: If active the window overlay will be shown - * on inactive (blur event) - * - * Setter: Enable the switch - * - * Getter: Check whether the switch is enabled - * - * @memberof WindowTag - */ - set blur_overlay(v: boolean); - get blur_overlay(): boolean; - /** - * Setter: set menu open event handler - * - * @memberof WindowTag - */ - set onmenuopen(f: (el: StackMenuTag) => void); - /** - * 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; - /** - * Set the application menu content - * - * @memberof WindowTag - */ - set menu(v: GenericObject[]); - /** - * 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; - /** - * Get the notification tag - * - * @memberof WindowTag - */ - get notification(): NotificationTag; - /** - * 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 { - type TileItemDirection = "row" | "column" | "row-reverse" | "column-reverse"; - /** - * 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} - */ - export class TileLayoutTag extends AFXTag { - /** - *C reates an instance of TileLayoutTag. - * @memberof TileLayoutTag - */ - constructor(); - private _padding; - /** - * 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: TileItemDirection); - get dir(): TileItemDirection; - /** - * Setter: - * - * SET content padding - * - * Getter: - * - * Get content padding - * - * @memberof TileLayoutTag - */ - set padding(v: number); - get padding(): number; - /** - * setter: Reverse order of the content in the tile - * - * getter: return if the tile's content is in reversed order - * - * @meberof TileLayoutTags - */ - set reversed(v: boolean); - get reversed(): boolean; - /** - * 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} - */ - export 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} - */ - export class VBoxTag extends TileLayoutTag { - /** - *Creates an instance of VBoxTag. - * @memberof VBoxTag - */ - constructor(); - /** - * Mount the tag - * - * @protected - * @memberof VBoxTag - */ - protected mount(): void; - } - export {}; - } - } -} -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; - /** - * Cache of touch event - * - * @private - * @meberof TabBarTag - */ - private _previous_touch; - /** - *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; - /** - * Setter: - * - * Set the tab bar direction: - * - `row`: horizontal direction - * - `column`: vertical direction - * - * Getter: - * - * Get the tab bar direction - * - * @memberof TabBarTag - */ - set dir(v: string); - get dir(): string; - /** - * 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[]; - /** - * Get the latest selected item - * - * @readonly - * @type {ListViewItemTag} - * @memberof TabBarTag - */ - get selectedItem(): ListViewItemTag; - /** - * 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; - /** - * Scroll the tabbar to end - * - * @memberof TabBarTag - */ - scroll_to_end(): void; - /** - * Scroll the tabbar to begin - * - * @memberof TabBarTag - */ - scroll_to_start(): 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 { - /** - * Cache of touch event - * - * @private - * @meberof AppDockTag - */ - private _previous_touch; - /** - * 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; - /** - * Add a button to the dock - * - * @private - * @param {string} [name] associated application name - * @param {AppDockItemType} [item] dock item - * @param {boolean} [pinned] the button is pinned to the dock ? - * @memberof AppDockTag - */ - private add_button; - private update_button; - /** - * 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 - */ - addapp(item: AppDockItemType): void; - /** - * Handle the application selection action - * - * @private - * @returns {Promise} - * @memberof AppDockTag - */ - private handleAppSelect; - /** - * 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; - /** - * refresh the pinned application list - * - * @private - * @memberof AppDockTag - */ - private refresh_pinned_app; - } - } - } -} -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 {Promise[]} - * @memberof SystemPanelTag - */ - private _pending_task; - /** - * Flag indicate where the selected application shall be opened - * - * @private - * @type {boolean} - * @memberof SystemPanelTag - */ - private _prevent_open; - /** - * Store the current attached service - * - * @private - * @type {number[]} - * @memberof SystemPanelTag - */ - private _services; - /** - * 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 panel, - * 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; - /** - * Check if the loading tasks ended, - * if it the case, stop the animation - * - * @private - * @memberof SystemPanelTag - */ - private animation_check; - private show_systray; - /** - * Mount the tag bind some basic event - * - * @protected - * @memberof SystemPanelTag - */ - protected mount(): void; - } - } - } -} -/// -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 {any} - * @memberof ButtonTag - */ - private _data; - /** - * Custom user data setter/gettter - * - * @memberof ButtonTag - */ - set data(v: any); - get data(): any; - /** - *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); - /** - * Set the icon class on the right side of the button, this property - * allows to style the button icon using CSS - * - * @memberof ButtonTag - */ - set iconclass$(v: string); - /** - * Set the CSS class of the label icon on the right side - * - * @memberof ButtonTag - */ - set iconclass_end(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[]; - } - } - } -} -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; - /** - * placeholder for directory changed event callback - * - * @private - * @type {TagEventCallback} - * @memberof FileViewTag - */ - private _ondirchanged; - /** - * Reference to the all selected files meta-datas - * - * @private - * @type {API.FileInfoType[]} - * @memberof FileViewTag - */ - private _selectedFiles; - /** - * 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 {@link 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 {@link TagEventType} with the data type `T` is {@link API.FileInfoType} - * - * @memberof FileViewTag - */ - set onfileselect(e: TagEventCallback); - /** - * set the callback handle for the directory changed event. - * The parameter of the callback should be an object - * of type {@link TagEventType} with the data type `T` is {@link API.VFS.BaseFileHandle} - * - * @memberof FileViewTag - */ - set onchdir(e: TagEventCallback); - /** - set the callback handle for the file open event. - * The parameter of the callback should be an object - * of type {@link TagEventType} with the data type `T` is {@link 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 {@link 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; - /** - * Setter: - * - * Allow multiple selection on file view - * - * Getter: - * - * Check whether the multiselection is actived - * - * @memberof FileViewTag - */ - set multiselect(v: boolean); - get multiselect(): boolean; - /** - * Get the current selected file - * - * @readonly - * @type {API.FileInfoType} - * @memberof FileViewTag - */ - get selectedFile(): API.FileInfoType; - /** - * Get all selected files - * - * @readonly - * @type {API.FileInfoType[]} - * @memberof FileViewTag - */ - get selectedFiles(): API.FileInfoType[]; - /** - * Setter: - * - * Set the path of the current working directory. - * When called the widget will refresh the current - * working directory using the configured {@link 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 { - /** - * Toast notification tag - * - * @export - * @class ToastNotificationTag - * @extends {AFXTag} - */ - class ToastNotificationTag extends AFXTag { - /** - *Creates an instance of ToastNotificationTag. - * @memberof ToastNotificationTag - */ - constructor(); - /** - * Mount the tag - * - * @protected - * @memberof ToastNotificationTag - */ - protected mount(): void; - /** - * Init the tag before mounting - * - * @protected - * @memberof ToastNotificationTag - */ - protected init(): void; - /** - * Re-calibrate tag - * - * @protected - * @memberof ToastNotificationTag - */ - protected calibrate(): void; - /** - * Update the current tag, do nothing in this tag - * - * @param {*} [d] - * @memberof ToastNotificationTag - */ - reload(d?: any): void; - /** - * Tag layout definition - * - * @protected - * @returns {TagLayoutType[]} - * @memberof ToastNotificationTag - */ - protected layout(): TagLayoutType[]; - } - /** - * This tag manage all notification UI on the desktop - * - * @export - * @class NotificationTag - * @extends {AFXTag} - */ - class NotificationTag extends AFXTag { - /** - *Creates an instance of NotificationTag. - * @memberof NotificationTag - */ - constructor(); - /** - * Mount the tag - * - * @protected - * @memberof NotificationTag - */ - protected mount(): void; - /** - * Init the tag before mounting - * - * @protected - * @memberof NotificationTag - */ - protected init(): void; - /** - * Push anotification to a specific location - * - * @memberof NotificationTag - */ - push(tag: AFXTag, loc?: ANCHOR): void; - /** - * Re-calibrate tag - * - * @protected - * @memberof NotificationTag - */ - protected calibrate(): void; - /** - * Update the current tag, do nothing in this tag - * - * @param {*} [d] - * @memberof NotificationTag - */ - reload(d?: any): void; - /** - * Tag layout definition - * - * @protected - * @returns {TagLayoutType[]} - * @memberof NotificationTag - */ - protected layout(): TagLayoutType[]; - } - } - } -} -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 {@link 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 { - /** - * An overlay tag is a layout tag that alway stay on top of - * the virtual desktop environment. Tile layout elements ({@link OS.GUI.tag.VBoxTag}, {@link OS.GUI.tag.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 stack pannel allows to navigate back and forth between pannels - * (container widget). Each container widget in the stack should be - * composed inside a {@link HBoxTag} - * - * - * @export - * @class StackPanelTag - * @extends {AFXTag} - */ - class StackPanelTag extends TabContainerTag { - private _current_pannel_index; - /** - * Mount the tag and bind basic events - * - * @protected - * @memberof StackPanelTag - */ - protected mount(): void; - /** - * Set the tab select event handle - * - * @memberof StackPanelTag - */ - set ontabselect(f: TagEventCallback); - /** - * Navigate to the next panel - * - * @memberof StackPanelTag - */ - navigateNext(): void; - /** - * Navigate back to the previous panel - * - * @memberof StackPanelTag - */ - navigateBack(): void; - /** - * Navigate to a custom panel - * - * @memberof StackPanelTag - */ - private navigate; - } - } - } -} -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[]; - } - } - } -} -declare namespace OS { - namespace GUI { - namespace tag { - /** - * Meta tag that represents the virtual desktop environment. - * In near future, we may have multiple virtual desktop environments. - * Each desktop environment has a simple file manager and a window - * manager that render the window in a specific order. - * - * @export - * @class DesktopTag - * @extends {FloatListTag} - */ - class DesktopTag extends FloatListTag { - /** - * internal handle to the desktop file location - * - * @private - * @type {API.VFS.BaseFileHandle} - * @memberof DesktopTag - */ - private file; - /** - * local observer that detect if a new child element is - * added or removed - * - * @private - * @type {MutationObserver} - * @memberof DesktopTag - */ - private observer; - /** - * Internal list of the current opened window - * - * @private - * @type {Set} - * @memberof DesktopTag - */ - private window_list; - /** - * Creates an instance of DesktopTag. - * @memberof DesktopTag - */ - constructor(); - /** - * Mount the virtual desktop to the DOM tree - * - * @protected - * @memberof DesktopTag - */ - protected mount(): void; - /** - * Display all files and folders in the specific desktop location - * - * @return {*} {Promise} - * @memberof DesktopTag - */ - refresh(): Promise; - /** - * Remove this element from its parent - * - * @memberof DesktopTag - */ - remove(): void; - /** - * Active a window above all other windows - * - * @private - * @param {WindowTag} win - * @memberof DesktopTag - */ - private selectWindow; - /** - * Render all windows in order from bottom to top - * - * @private - * @memberof DesktopTag - */ - private render; - } - } - } -} -/// -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 {@link 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 {@link TileLayoutTag} - * such as {@link VBoxTag} or {@link 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: - * - `row` - horizontal direction, resize by width - * - `column` - 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; - /** - * Setter Disable or enable the resize event - * - * @memberof ResizerTag - */ - set disable(v: boolean); - get disable(): boolean; - /** - * 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[]; - } - } - } -} -/** - * 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 { - /** - * Row item event data type - */ - type GridRowEventData = TagEventDataType; - /** - * 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 - * - * @private - * @type {GenericObject[]} - * @memberof GridRowTag - */ - private _data; - /** - * placeholder for the row select event callback - * - * @private - * @type {TagEventCallback} - * @memberof ListViewItemTag - */ - private _onselect; - /** - *Creates an instance of GridRowTag. - * @memberof GridRowTag - */ - constructor(); - /** - * Set item select event handle - * - * @memberof ListViewItemTag - */ - set onrowselect(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; - /** - * setter: set row data - * - * getter: get row data - */ - set data(v: GenericObject[]); - get data(): GenericObject[]; - /** - * 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 {@link 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 {@link 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 {@link 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 {@link 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; - /** - * Event data passing between mouse event when performing - * drag and drop on the list - * - * @private - * @type {{ from: GridRowTag[]; to: GridRowTag }} - * @memberof GridViewTag - */ - private _dnd; - /** - * placeholder of list drag and drop event handle - * - * @private - * @type {TagEventCallback>} - * @memberof GridViewTag - */ - private _ondragndrop; - /** - * Creates an instance of GridViewTag. - * @memberof GridViewTag - */ - constructor(); - /** - * Set drag and drop event handle - * - * @memberof GridViewTag - */ - set ondragndrop(v: TagEventCallback>); - /** - * Setter: Enable/disable drag and drop event in the list - * - * Getter: Check whether the drag and drop event is enabled - * - * @memberof GridViewTag - */ - set dragndrop(v: boolean); - get dragndrop(): boolean; - /** - * placeholder of drag and drop mouse down event handle - * - * @private - * @memberof GridViewTag - */ - private _onmousedown; - /** - * placeholder of drag and drop mouse up event handle - * - * @private - * @memberof GridViewTag - */ - private _onmouseup; - /** - * placeholder of drag and drop mouse move event handle - * - * @private - * @memberof GridViewTag - */ - private _onmousemove; - /** - * 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; - /** - * Sort the grid using a sort function - * - * @param {context: any} context of the executed function - * @param {(a:GenericObject[], b:GenericObject[]) => boolean} a sort function that compares two rows data - * * @param {index: number} current header index - * @returns {void} - * @memberof GridViewTag - */ - sort(context: any, fn: (a: GenericObject[], b: GenericObject[], index?: number) => number): void; - /** - * Delete a grid rows - * - * @param {GridRowTag} row row DOM element - * @returns {void} - * @memberof GridViewTag - */ - delete(row: GridRowTag): void; - /** - * Scroll the grid view to bottom - * - * @memberof GridViewTag - */ - scroll_to_bottom(): void; - /** - * Scroll the grid view to top - * - * @memberof GridViewTag - */ - scroll_to_top(): 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 GridViewTag - */ - 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; - /** - * Unselect all the selected rows in the grid - * - * @returns {void} - * @memberof GridViewTag - */ - unselect(): void; - /** - * 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 { - /** - * 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/Getter: set and get precision reading - * - * @memberof SliderTag - */ - set precision(v: boolean); - get precision(): boolean; - /** - * 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[]; - } - } - } -} -/// -/** - * - * 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.StackMenuTag} m The context menu element {@link OS.GUI.tag.StackMenuTag} - * @memberof HTMLElement - */ - contextmenuHandle(e: JQuery.MouseEventBase, m: OS.GUI.tag.StackMenuTag): 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; - /** - * Enable the drag event dispatching on this - * element - * - * This will trigger the `dragging` and `drop` event on the enabled - * element when the mouse is down, move, then up, then move - * - * The event can be listened using the traditional way, - * Example: - * ``` - * elem.addEventListener('dragging', (e) => { }, false); - * elem.addEventListener('drop', (e) => { }, false); - * ``` - * - * @meberof HTMLElement - */ - enable_drag(): void; - /** - * Perform DOM generation ({@link afxml}) then mount ({@link 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 {@link OS.GUI.AFXTag.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; - /** - * Original event if any - * - * @type {any} - * @memberof TagEventType - */ - originalEvent?: any; - /** - * is root tag? - * - * @type {boolean} - * @memberof TagEventType - */ - root?: boolean; - } - /** - * 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 - * - * @export - */ - type TagEventCallback = (e: TagEventType) => void; - /** - * Tag responsive envent callback type - * - * @export - */ - type TagResponsiveCallback = (fullfilled: boolean) => void; - /** - * Tag responsive validator type - * - * @export - */ - type TagResponsiveValidator = (w: number, h: number) => boolean; - /** - * Definitions of some default tag responsive validators - * - * @export - */ - const RESPONSIVE: { - /** - * Extra small devices (phones, 600px and down) - */ - TINY: (w: number, _h: number) => boolean; - SMALL: (w: number, _h: number) => boolean; - MEDIUM: (w: number, _h: number) => boolean; - /** - * Large devices (laptops/desktops, 992px and up) - */ - LARGE: (w: number, _h: number) => boolean; - /** - * Extra large devices (large laptops and desktops, 1200px and up) - */ - HUGE: (w: number, _h: number) => boolean; - /** - * Portrait mode - */ - PORTRAIT: (w: number, h: number) => boolean; - /** - * Landscape mode - */ - LANDSCAPE: (w: number, h: number) => boolean; - }; - /** - * 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 {@link 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; - /** - * a {@link ResponsiveHandle} to handle all responsive event - * related to this tag - * - * @private - * @memberof AFXTag - */ - private _responsive_handle; - private _responsive_check; - /** - * 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; - /** - * Setter: Enable/disable responsive tag - * - * Getter: get responsive status - */ - set responsive(v: boolean); - get responsive(): boolean; - /** - * Register a responsive event to this tag - * - * @param {TagResponsiveValidator} responsive validator - * @param {TagResponsiveCallback} responsive callback - * @memberof AFXTag - */ - morphon(validator: TagResponsiveValidator, callback: TagResponsiveCallback): void; - /** - * Unregister a responsive event from this tag - * - * @param {TagResponsiveValidator} responsive validator - * @memberof AFXTag - */ - morphoff(validator: TagResponsiveValidator): void; - /** - * Attach a data to this tag - * - * This function will define a getter `domel` - * in the attached data, this getter refers to the - * current tag - * - * @returns {void} - * @memberof AFXTag - */ - attach(data: GenericObject): void; - /** - * 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 {@link 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 {@link 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 { - /** - * Alias to all classes that extends {@link AFXTag} - */ - type AFXTagTypeClass = { - new (): T; - }; - /** - * 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 {@link 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 { - /** - * 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 {@link TabBarTag} - * with a container widget. The attached container widget should be - * composed inside a {@link 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 - * - * @protected - * @type {TagEventCallback} - * @memberof TabContainerTag - */ - protected _ontabselect: TagEventCallback; - /** - *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[]; - /** - * Setter: Select a tab by its index - * Getter: Get the current selected index - * - * @memberof TabContainerTag - */ - set selectedIndex(i: number); - get selectedIndex(): 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 { - /** - * List item event data type - */ - type ListItemEventData = TagEventDataType; - /** - * A list item represent the individual view of an item in the {@link OS.GUI.tag.ListViewTag}. - * 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 - */ - /** - * 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 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 {@link itemlayout} - * - * @protected - * @returns {TagLayoutType[]} - * @memberof ListViewItemTag - */ - protected layout(): TagLayoutType[]; - /** - * Setter: - * - * Set the data of the list item. This will - * trigger the {@link 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 | TagLayoutType[]} - * @memberof ListViewItemTag - */ - protected abstract itemlayout(): TagLayoutType | 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 | TagLayoutType[]} - * @memberof SimpleListItemTag - */ - protected itemlayout(): TagLayoutType | TagLayoutType[]; - } - /** - * The layout of a double line list item contains two - * AFX labels - * - * @export - * @class DoubleLineListItemTag - * @extends {ListViewItemTag} - */ - class DoubleLineListItemTag extends ListViewItemTag { - /** - *Creates an instance of DoubleLineListItemTag. - * @memberof DoubleLineListItemTag - */ - constructor(); - /** - * Reset some property to default - * - * @protected - * @memberof DoubleLineListItemTag - */ - protected init(): void; - /** - * Do nothing - * - * @protected - * @memberof DoubleLineListItemTag - */ - protected calibrate(): void; - /** - * Refresh the inner label when the item data - * is changed - * - * @protected - * @returns {void} - * @memberof DoubleLineListItemTag - */ - protected ondatachange(): void; - /** - * Re-render the list item - * - * @protected - * @memberof DoubleLineListItemTag - */ - protected reload(): void; - /** - * List item custom layout definition - * - * @protected - * @returns {TagLayoutType | TagLayoutType[]} - * @memberof DoubleLineListItemTag - */ - protected itemlayout(): TagLayoutType | 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 {@link multiselect} feature is disabled - * - * @private - * @type {ListViewItemTag[]} - * @memberof ListViewTag - */ - private _selectedItems; - /** - * The anchor element that the list view positioned on - * This is helpful when rendering dropdown list - * @private - * @type{HTMLElement} - * @memberof ListViewTag - */ - private _anchor; - /** - * Data placeholder of the list - * - * @private - * @type {GenericObject[]} - * @memberof ListViewTag - */ - private _data; - private _drop; - private _show; - /** - * 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 {@link OS.GUI.tag.ButtonTag.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 list direction: row or column (default) - * - * Setter: Get list direction: row or column - * - * @type {string} - * @memberof ListViewTag - */ - set dir(v: string); - get dir(): string; - /** - * 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 the selected item index - * - * @readonly - * @type {number} - * @memberof ListViewTag - */ - 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 - * - * @protected - * @param {TagEventType} e tag event object - * @returns - * @memberof ListViewTag - */ - protected idbclick(e: TagEventType): void; - /** - * This function triggers the list item select event - * - * @protected - * @param {TagEventType} e tag event object - * @returns - * @memberof ListViewTag - */ - protected iselect(e: TagEventType): void; - /** - * 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; - /** - * Scroll the list view to end - * - * @memberof ListViewTag - */ - scroll_to_end(): void; - /** - * Scroll the list view to beginning - * - * @memberof ListViewTag - */ - scroll_to_start(): 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 tag define a basic text input and its behavior - * - * @export - * @class InputTag - * @extends {AFXTag} - */ - class InputTag extends AFXTag { - /** - *Creates an instance of InputTag. - * @memberof InputTag - */ - constructor(); - /** - * Set the path to the header icon, the path should be - * a VFS file path - * - * @memberof InputTag - */ - set icon(v: string); - /** - * Set the icon class to the header - * - * @memberof InputTag - */ - set iconclass(v: string); - /** - * Alias to header setter/getter - * - * @memberof InputTag - */ - set text(v: string | FormattedString); - get text(): string | FormattedString; - /** - * Setter: Set the text of the label - * - * Getter: Get the current label test - * - * @memberof InputTag - */ - set label(v: string | FormattedString); - get label(): string | FormattedString; - /** - * Setter: Enable or disable the input - * - * Getter: Get the `enable` property of the input - * - * @memberof InputTag - */ - set disable(v: boolean); - get disable(): boolean; - /** - * Setter: set verbosity of the input - * - * Getter: Get the current input verbosity - * - * @memberof InputTag - */ - set verbose(v: boolean); - get verbose(): boolean; - /** - * JQuery style generic event handling on the input element - * - * @param {string} enname: JQuery event name - * @param {JQuery.TypeEventHandler} handle: JQuery handle - * @memberof InputTag - */ - on(ename: string, handle: JQuery.TypeEventHandler): void; - /** - * Manually trigger an event - * - * @param {string} evt: JQuery event name - * @memberof InputTag - */ - trigger(evt: string): void; - /** - * Mount the tag - * - * @protected - * @memberof InputTag - */ - protected mount(): void; - /** - * Get the current active input element - * - * @memberof InputTag - */ - get input(): HTMLInputElement | HTMLTextAreaElement; - /** - * Get/set the current active input value - * - * @memberof InputTag - */ - get value(): string; - set value(v: string); - /** - * Get/set input type - * This only affects the inline input element - * - * @memberof InputTag - */ - get type(): string; - set type(v: string); - /** - * Get/set input name - * - * @memberof InputTag - */ - get name(): string; - set name(v: string); - /** - * Init the tag before mounting - * - * @protected - * @memberof InputTag - */ - protected init(): void; - /** - * Re-calibrate, do nothing in this tag - * - * @protected - * @memberof InputTag - */ - protected calibrate(): void; - /** - * Update the current tag, do nothing in this tag - * - * @param {*} [d] - * @memberof InputTag - */ - reload(d?: any): void; - /** - * Input layout definition - * - * @protected - * @returns {TagLayoutType[]} - * @memberof InputTag - */ - 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 horizontal aligment of the label content - * - * @param {string} v shall be "left, right, or center" - */ - set halign(v: string); - /** - * set horizontal aligment of the label content - * - * @param {string} v shall be "top, bottom, or center" - */ - set valign(v: string); - /** - * Set the CSS class of the label icon - * - * @memberof LabelTag - */ - set iconclass(v: string); - /** - * Set the CSS class of the label icon on the right side - * - * @memberof LabelTag - */ - set iconclass_end(v: string); - /** - * Set the CSS class of the label icon on the right side - * - * @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; - /** - * Setter: Turn on/off text selection - * - * Getter: Check whether the label is selectable - * - * @memberof LabelTag - */ - set selectable(v: boolean); - get swon(): boolean; - /** - * Lqbel layout definition - * - * @protected - * @returns {TagLayoutType[]} - * @memberof LabelTag - */ - 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 {@link 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 - * {@link 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 {@link 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 {@link TreeViewItemPrototype} and - * define it inner layout using a {@link 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 {@link TreeViewDataType} - * - * @memberof TreeViewTag - */ - 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 { - /** - * 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 {@link 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 - */ - /** - * Current active process ID - */ - var pidactive: number; - var processes: GenericObject; - /** - * Create a new process of application or service - * - * @export - * @param {string} app class name string - * @param {ProcessTypeClass} cls prototype class - * @param {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; - /** - * Get the current active application - * @export - * @returns {BaseModel} - */ - function getActiveApp(): BaseModel; - } -} -/** - * 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 {@link OS.Version} if the string - * is in the format recognized by {@link OS.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 {@link OS.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 Array prototype with some API - * functions used by AntOS API - * - * @interface Array - * @template T - */ -interface Array { - /** - * Check if the array includes an element - * - * @param {T} element to check - * @returns {boolean} - * @memberof Array - */ - includes(element: T): boolean; -} -/** - * Extend the Data prototype with the - * {@link timestamp} function - * - * @interface Date - */ -interface Date { - /** - * Return the timestamp of the current Date object - * - * @returns {number} - * @memberof Date - */ - timestamp(): number; - /** - * Covnert to GMTString - * - * @returns {number} - * @memberof Date - */ - toGMTString(): string; -} -/** - * Generic key-value pair object interface - * - * @interface GenericObject - * @template T - */ -interface GenericObject { - [index: string]: T; -} -/** - * Global function to create a {@link OS.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 {@link 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]-[build ID]) - * - * e.g.: 1.2.3-r-b means that: - * - version major number is 1 - * - version minor number is 2 - * - patch version is 3 - * - the current branch is release `r` - * - build ID (optional) - * ``` - * - * @export - * @class Version - */ - class Version { - /** - * The version string - * - * @private - * @type {string} - * @memberof Version - */ - private 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; - /** - * Version build ID (optional): usually the current git commit hash - * - * @type {number} - * @memberof Version - */ - build_id: string; - /** - *Creates an instance of Version. - * - * @param {string} string string represents the version - * @memberof Version - */ - constructor(string: string); - /** - * Setter/getter to set the version string to the object - * - * @memberof Version - */ - set version_string(v: string); - get version_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 {@link OS.Version} - */ - const VERSION: Version; - /** - * Variable represents the current AntOS source code repository - * is an instance of string - */ - const REPOSITORY: string; - /** - * Indicate whether the current de - */ - var mobile: boolean; - /** - * Register a model prototype to the system namespace. - * There are two types of model to be registered, if the model - * is of type {@link OS.GUI.SubWindow}, its prototype will be registered - * in the {@link OS.GUI.dialogs} namespace, otherwise, if the model type - * is {@link OS.application.BaseApplication} or {@link OS.application.BaseService}, its prototype will be - * registered in the {@link 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 {@link OS.GUI.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]: () => Promise; - }; - /** - * Perform the system shutdown operation. This function calls all - * clean up handles in {@link cleanupHandles}, then save the system setting - * before exiting - * - * @export - */ - function exit(): void; - /** - * Register a callback to the system {@link cleanupHandles} - * - * @export - * @param {string} n callback string name - * @param {() => void} f the callback handle - * @returns - */ - function onexit(n: string, f: () => Promise): () => Promise; - /** - * 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 {@link pkgname} should be specified - * - * @type {string} - * @memberof PackageMetaType - */ - app?: string; - /** - * Package name, in case of {@link 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 {@link 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; - /** - * A task is a Promise object that is tracked by AntOS via the - * Announcerment system - * - * Task manager implementation can subscribe to the following global events - * - ANTOS-TASK-PENDING : a new task/promise is created and executing - * - ANTOS-TASK-FULFILLED: a fullfilled task is a resolved promise - * - ANTOS-TASK-REJECTED: a rejected task is a rejected or error promise - * - * Whenever a task is created by this API, it states will be automatically announced - * to any subscribers of these events - * - * @export - * @param {Promise} a Promise object - */ - function Task(fn: (resolve: (any: any) => void, reject: (any: any) => void) => void): Promise; - /** - * 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; - /** - * 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 {@link RequestResult}. - * A success request result should contain a list of {@link 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 {@link 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 {@link 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 {@link 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 - * `SYSTEM-LOCALE-CHANGED` 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; - /** - * A watcher is a Proxy wrapper to an object - * - * It is used to automatically detect changes in the - * target object and notify the change to a callback - * handler - * - * @export - * @param {Object} target object - * @param {(obj: Object, key: string, value: any, path: any[]) => void} callback function - * @returns {Proxy} the wrapper object - */ - function watcher(target: GenericObject, callback: (obj: Object, key: any, value: any, path: any[]) => void): Object; - } -} declare namespace OS { /** * This namespace is dedicated to everything related to the @@ -9016,524 +10446,165 @@ declare namespace OS { function systemSetting(conf: any): void; } /// -/// declare namespace OS { - /** - * Application argument type definition - * - * @export - * @interface AppArgumentsType - */ - interface AppArgumentsType { + namespace application { /** - * File type to be open by the app + * Services are processes that run in the background and + * are waken up in certain circumstances such as by global + * events or user interactions. * - * @type {string} - * @memberof AppArgumentsType - */ - type?: string; - /** - * File path to be opened + * 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. * - * @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 ({@link OS.GUI.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 {HTMLElement} - * @memberof BaseModel - */ - protected host: HTMLElement; - /** - * 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 - * - * @param {string} name - * @memberof BaseModel - */ - updateLocale(name: string): void; - /** - * Render the model's UI - * - * @protected - * @param {string} p VFS path to the UI scheme definition - * @returns {Promise} - * @memberof BaseModel - */ - protected render(p: string): Promise; - /** - * 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; - /** - * Purge the model from the system - * - * @protected - * @memberof BaseModel - */ - protected destroy(): void; - /** - * Model meta data, need to be implemented by - * subclasses + * Services are singleton processes, there is only + * one process of a service at a time * + * @export * @abstract - * @returns {API.PackageMetaType} - * @memberof BaseModel + * @class BaseService + * @extends {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 - * - * @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: API.AnnouncementDataType) => void} f event callback - * @returns {void} - * @memberof BaseModel - */ - subscribe(e: string, f: (d: API.AnnouncementDataType) => 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 {@link OS.GUI.dialogs.YesNoDialog} to confirm a task - * - * @protected - * @param {GenericObject} data {@link OS.GUI.dialogs.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 {any} u_data user data object if any - * @returns {void} - * @memberof BaseModel - */ - protected publish(t: string, m: string | FormattedString, u_data?: any): void; - /** - * Publish a global notification - * - * @param {(string | FormattedString)} m notification string - * @param {any} u_data user data object if any - * @returns {void} - * @memberof BaseModel - */ - notify(m: string | FormattedString, data?: any): 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): T; - /** - * 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; + 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 | FormattedString} + * @memberof BaseService + */ + text: string | FormattedString; + /** + * 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 {@link watch}. + * + * @private + * @type {number} + * @memberof BaseService + */ + private timer; + /** + * 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; + /** + * 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 { @@ -9796,1146 +10867,75 @@ declare namespace OS { function unregister(app: BaseModel): void; } } -/// 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 + * This namespace dedicated to all operations related to system + * process management */ - namespace application { + namespace PM { /** - * Abstract prototype of all AntOS applications. - * Any new application definition should extend - * this prototype + * A process is either an instance of an application or a service + */ + type ProcessType = application.BaseApplication | application.BaseService; + /** + * Alias to all classes that extends {@link 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 + */ + /** + * Current active process ID + */ + var pidactive: number; + var processes: GenericObject; + /** + * Create a new process of application or service * * @export - * @abstract - * @class BaseApplication - * @extends {BaseModel} + * @param {string} app class name string + * @param {ProcessTypeClass} cls prototype class + * @param {AppArgumentsType[]} [args] process arguments + * @returns {Promise} a promise on the created process */ - abstract class BaseApplication extends BaseModel { - /** - * Watcher of all settings specific to the application. - * The settings stored in this object will be saved to application folder - * in JSON format as .settings.json and will be loaded automatically - * when application is initialized. - * - * This object is globally acessible to all processes of the same application - * - * @type {GenericObject} - * @memberof BaseApplication - */ - static setting_wdg: GenericObject; - /** - * Reference to per application setting i.e. setting_wdg - * - * @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; - /** - *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(): Promise; - /** - * API function to register responsive UI event to the current window tag - * - * @protected - * @param {GUI.TagResponsiveValidator} responsive validator - * @param {GUI.TagResponsiveCallback} responsive callback - * @returns {void} - * @memberof BaseApplication - */ - protected morphon(validator: GUI.TagResponsiveValidator, callback: GUI.TagResponsiveCallback): void; - /** - * API function to unregister responsive UI event from current window tag - * - * @protected - * @param {GUI.TagResponsiveValidator} responsive validator - * @returns {void} - * @memberof BaseApplication - */ - protected morphoff(validator: GUI.TagResponsiveValidator): void; - /** - * Render the application UI by first loading its scheme - * and then mount this scheme to the DOM tree - * - * @protected - * @returns {Promise} - * @memberof BaseApplication - */ - protected loadScheme(): Promise; - /** - * API function to perform an heavy task. - * This function will create a Task that is tracked by any - * task manager implementation - * - * @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 - * - * @param {string} name locale name e.g. `en_GB` - * @returns {void} - * @memberof BaseApplication - */ - 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; - /** - * 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; - /** - * Getter to access the application window instance - * - * @memberof BaseApplication - */ - get window(): GUI.tag.WindowTag; - /** - * 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 {@link 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[]; - /** - * Show local toast notification - * - * @param {any} data to send - * @param {GUI.ToastOptions} notification options see {@link GUI.ToastOptions} - * @returns {void} - * @memberof BaseApplication - */ - toast(data: any, opts?: GUI.ToastOptions): void; - /** - * The cleanup function that is called by {@link 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 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 | FormattedString} - * @memberof BaseService - */ - text: string | FormattedString; - /** - * 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 {@link watch}. - * - * @private - * @type {number} - * @memberof BaseService - */ - private timer; - /** - * 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; - /** - * 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 { - 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 {@link 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 {@link 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 {@link RequestResult} - * which contains an error or an object of {@link 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 {@link 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 {@link 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 {@link 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 {@link 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 {@link 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 {@link RequestResult} that - * contains an error or a {@link OS.setting.UserSettingType} object - */ - function auth(): Promise; - /** - * Perform a login operation - * - * @export - * @param {UserLoginType} d user data {@link UserLoginType} - * @returns {Promise} a promise on a {@link RequestResult} that - * contains an error or a {@link OS.setting.UserSettingType} object - */ - function login(d: UserLoginType): Promise; - /** - * Perform a logout operation - * - * @export - * @returns {Promise} a promise on a {@link RequestResult} - */ - function logout(): Promise; - /** - * Save the current user settings - * - * @export - * @returns {Promise} a promise on a {@link RequestResult} - */ - function setting(): Promise; - /** - * Query the current versions of all system components - * - * @export - * @returns {Promise} a promise on a {@link RequestResult} - */ - function versions(): Promise; - } - } -} -/// -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 { - /** - * Enum definition of different UI locattion - * - * @export - * @enum {string } - */ - enum ANCHOR { - /** - * Center top - */ - NORTH = "NORTH", - /** - * Center bottom - */ - SOUTH = "SOUTH", - /** - * Center left - */ - WEST = "WEST", - /** - * Center right - */ - EST = "EST", - /** - * Top left - */ - NORTH_WEST = "NORTH_WEST", - /** - * Bottom left - */ - SOUTH_WEST = "SOUTH_WEST", - /** - * Top right - */ - NORTH_EST = "NORTH_EST", - /** - * Bottom right - */ - SOUTH_EST = "SOUTH_EST" - } - /** - * 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 {@link 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 {@link 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. - * @return {Promise} a promise object - */ - function loadScheme(path: string, app: BaseModel, parent: HTMLElement | string): Promise; - /** - * 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; - /** - * Get the system dock tag - * - * @export - * @return {*} {GUI.tag.AppDockTag} - */ - function systemDock(): GUI.tag.AppDockTag; - /** - * Get the current virtual desktop - * - * @export - * @return {*} {GUI.tag.DesktopTag} - */ - function desktop(): GUI.tag.DesktopTag; - /** - * 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; - /** - * Toast notification configuration options - * - * - * @export - * @interface ToastOptions - */ - interface ToastOptions { - /** - * Where the Toast is displayed? see {@link ANCHOR} - * - * @type {ANCHOR} - * @memberof ToastOptions - */ - location?: ANCHOR; - /** - * Timeout (in seconds) before the Toast disappears - * Set this value to 0 to prevent the Toast to disappear, - * in this case, user need to explicitly close the notification - * - * @type {number} - * @memberof ToastOptions - */ - timeout?: number; - /** - * AFXTag that is used to render the data - * - * @type {number} - * @memberof ToastOptions - */ - tag?: string; - } - /** - * Toast notification API - * Show a toast message on different posisition on screen, see {@link ToastOptions} - * - * @export - * @param - * @returns - */ - function toast(data: any, opts?: ToastOptions, app?: application.BaseApplication): void; - /** - * 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 {@link application} namespace. - * - * This process is similar to uninstall the application - * from the current system state - * - * @export - * @param {string} app - */ - function unloadApp(app: string, save?: boolean): void; - /** - * Create a service process. - * - * Services are singleton processes, there is only - * one process of a service at a time - * - * @export - * @param {string} ph - * @param {AppArgumentsType[]} [params] service arguments - * @returns {Promise} - */ - function pushService(ph: string, params?: AppArgumentsType[]): 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 {@link 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; + 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; + /** + * Get the current active application + * @export + * @returns {BaseModel} + */ + function getActiveApp(): BaseModel; } } diff --git a/src/core/tags/CalendarTag.ts b/src/core/tags/CalendarTag.ts index 6e5bf3d..e23082f 100644 --- a/src/core/tags/CalendarTag.ts +++ b/src/core/tags/CalendarTag.ts @@ -115,8 +115,18 @@ namespace OS { protected mount(): void { (this.refs.prev as ButtonTag).iconclass = "fa fa-angle-left"; (this.refs.next as ButtonTag).iconclass = "fa fa-angle-right"; + (this.refs.prev_year as ButtonTag).iconclass = "fa fa-angle-left"; + (this.refs.next_year as ButtonTag).iconclass = "fa fa-angle-right"; (this.refs.prev as ButtonTag).onbtclick = (e) => this.prevmonth(); (this.refs.next as ButtonTag).onbtclick = (e) => this.nextmonth(); + (this.refs.next_year as ButtonTag).onbtclick = (e) => { + this._year++; + this.calendar(new Date(this._year, this._month, 1)); + } + (this.refs.prev_year as ButtonTag).onbtclick = (e) => { + this._year--; + this.calendar(new Date(this._year, this._month, 1)); + } const grid = this.refs.grid as GridViewTag; grid.header = [ { text: "__(Sun)" }, @@ -304,7 +314,8 @@ namespace OS { grid.rows = rows; (this.refs.mlbl as LabelTag).text = `${ months[this._month] - } ${this._year}`; + }`; + (this.refs.ylbl as LabelTag).text = `${this._year}`; } /** @@ -320,9 +331,13 @@ namespace OS { el: "div", ref: "ctrl", children: [ - { el: "afx-button", class: "prevmonth", ref: "prev" }, + { el: "afx-button", ref: "prev" }, { el: "afx-label", ref: "mlbl" }, - { el: "afx-button", class: "nextmonth", ref: "next" }, + { el: "afx-button", ref: "next" }, + { el: "div"}, + { el: "afx-button", ref: "prev_year" }, + { el: "afx-label", ref: "ylbl" }, + { el: "afx-button", ref: "next_year" }, ], }, { el: "afx-grid-view", ref: "grid" }, diff --git a/src/themes/default/afx-calendar-view.css b/src/themes/default/afx-calendar-view.css index a7d8065..da50d79 100644 --- a/src/themes/default/afx-calendar-view.css +++ b/src/themes/default/afx-calendar-view.css @@ -6,6 +6,19 @@ afx-calendar-view > div afx-label i{ font-weight: bold; } +afx-calendar-view afx-button button, +afx-calendar-view afx-button button:active, +afx-calendar-view afx-button button.btactive +{ + border: 0; + background-color: transparent; +} + +afx-calendar-view afx-button button:active, +afx-calendar-view afx-button button.btactive +{ + color: var(--item-bg-active); +} afx-calendar-view afx-grid-view afx-grid-row.afx-grid-row-selected afx-grid-cell { diff --git a/src/themes/system/afx-calendar-view.css b/src/themes/system/afx-calendar-view.css index d747b7c..c98aa48 100644 --- a/src/themes/system/afx-calendar-view.css +++ b/src/themes/system/afx-calendar-view.css @@ -6,7 +6,7 @@ afx-calendar-view afx-grid-view afx-grid-row:nth-child(even) afx-grid-cell afx-calendar-view afx-grid-view .grid_row_header afx-grid-cell{ border-right: 0; } -afx-calendar-view afx-label { +afx-calendar-view afx-label, afx-calendar-view > div > div { flex-direction: row; justify-content: center; } @@ -15,7 +15,7 @@ afx-calendar-view > div { display: flex; flex-direction: row; } -afx-calendar-view > div > afx-label +afx-calendar-view > div > div { flex:1; } \ No newline at end of file