mirror of
https://github.com/lxsang/antos-frontend.git
synced 2024-11-10 06:48:21 +01:00
649c7d942a
- Label and Button now can set icon on both left and right side of the text - Fix ListView dropdown bug, and allow the dropdown list to positioned correctly based on its nearest anchored element
11426 lines
376 KiB
TypeScript
11426 lines
376 KiB
TypeScript
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<any>}
|
|
* @memberof PackageCommandType
|
|
*/
|
|
args: GenericObject<any>;
|
|
}
|
|
/**
|
|
*
|
|
* 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>
|
|
* | any[]
|
|
* | FileInfoType
|
|
* | FileInfoType[]
|
|
* | setting.UserSettingType)}
|
|
* @memberof RequestResult
|
|
*/
|
|
result: string | boolean | GenericObject<any> | 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<RequestResult>} A promise on a [[RequestResult]]
|
|
* which contains an error or a list of FileInfoType
|
|
*/
|
|
function scandir(p: string): Promise<RequestResult>;
|
|
/**
|
|
*
|
|
* 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<RequestResult>} A promise on a RequestResult
|
|
* which contains an error or true on success
|
|
*/
|
|
function mkdir(p: string): Promise<RequestResult>;
|
|
/**
|
|
* 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<RequestResult>} A promise on a RequestResult
|
|
* which contains an error or true on success
|
|
*/
|
|
function sharefile(p: string, pub: boolean): Promise<RequestResult>;
|
|
/**
|
|
* Get VFS file meta-data
|
|
*
|
|
* @export
|
|
* @param {string} p VFS file path
|
|
* @returns {Promise<RequestResult>} A promise on a [[RequestResult]]
|
|
* which contains an error or an object of FileInfoType
|
|
*/
|
|
function fileinfo(p: string): Promise<RequestResult>;
|
|
/**
|
|
* 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<any>} A promise on a [[RequestResult]]
|
|
* which contains an error or an object of [[FileInfoType]]
|
|
*/
|
|
function readfile(p: string, t: string): Promise<any>;
|
|
/**
|
|
* 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<RequestResult>} A promise on a [[RequestResult]]
|
|
* which contains an error or a success response
|
|
*/
|
|
function move(s: string, d: string): Promise<RequestResult>;
|
|
/**
|
|
* Delete a VFS file on the server-side
|
|
*
|
|
* @export
|
|
* @param {string} p VFS file path
|
|
* @returns {Promise<RequestResult>} A promise on a [[RequestResult]]
|
|
* which contains an error or a success response
|
|
*/
|
|
function remove(p: string): Promise<RequestResult>;
|
|
/**
|
|
* Read the file as binary data
|
|
*
|
|
* @export
|
|
* @param {string} p VFS file to be read
|
|
* @returns {Promise<ArrayBuffer>} a Promise on an array buffer
|
|
*/
|
|
function fileblob(p: string): Promise<ArrayBuffer>;
|
|
/**
|
|
* Send a command to the serverside package manager
|
|
*
|
|
* @export
|
|
* @param {PackageCommandType} d a package command of type PackageCommandType
|
|
* @returns {Promise<RequestResult>} a promise on a [[RequestResult]]
|
|
*/
|
|
function packages(d: PackageCommandType): Promise<RequestResult>;
|
|
/**
|
|
* Upload file to the server via VFS interface
|
|
*
|
|
* @export
|
|
* @param {string} d VFS destination directory path
|
|
* @returns {Promise<RequestResult>} a promise on a [[RequestResult]]
|
|
*/
|
|
function upload(d: string): Promise<RequestResult>;
|
|
/**
|
|
* 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<RequestResult>} a promise on a [[RequestResult]]
|
|
*/
|
|
function write(p: string, d: string): Promise<RequestResult>;
|
|
/**
|
|
* 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<any>} 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<any>} a promise on the result object (any)
|
|
*/
|
|
function apigateway(d: GenericObject<any>, ws: boolean): Promise<any>;
|
|
/**
|
|
* Check if a user is logged in
|
|
*
|
|
* @export
|
|
* @returns {Promise<RequestResult>} a promise on a [[RequestResult]] that
|
|
* contains an error or a [[UserSettingType]] object
|
|
*/
|
|
function auth(): Promise<RequestResult>;
|
|
/**
|
|
* Perform a login operation
|
|
*
|
|
* @export
|
|
* @param {UserLoginType} d user data [[UserLoginType]]
|
|
* @returns {Promise<RequestResult>} a promise on a [[RequestResult]] that
|
|
* contains an error or a [[UserSettingType]] object
|
|
*/
|
|
function login(d: UserLoginType): Promise<RequestResult>;
|
|
/**
|
|
* Perform a logout operation
|
|
*
|
|
* @export
|
|
* @returns {Promise<RequestResult>} a promise on a [[RequestResult]]
|
|
*/
|
|
function logout(): Promise<RequestResult>;
|
|
/**
|
|
* Save the current user settings
|
|
*
|
|
* @export
|
|
* @returns {Promise<RequestResult>} a promise on a [[RequestResult]]
|
|
*/
|
|
function setting(): Promise<RequestResult>;
|
|
/**
|
|
* This is the low level function of AntOS VDB API.
|
|
* It requests the server API to perform some simple
|
|
* SQL query.
|
|
*
|
|
* @export
|
|
* @param {string} cmd action to perform: save, delete, get, select
|
|
* @param {GenericObject<any>} d data object of the request based on each action:
|
|
* - save:
|
|
* ```
|
|
* { table: "table name", data: [record data object]}
|
|
* ```
|
|
* - get:
|
|
* ```
|
|
* { table: "table name", id: [record id]}
|
|
* ```
|
|
* - delete:
|
|
* ```
|
|
* { table: "table name", id: [record id]}
|
|
* or
|
|
* { table: "table name", cond: [conditional object]}
|
|
* ```
|
|
* - select:
|
|
* ```
|
|
* { table: "table name", cond: [conditional object]}
|
|
* ```
|
|
* @returns {Promise<RequestResult>} a promise of [[RequestResult]] on the
|
|
* query data
|
|
*
|
|
* A conditional object represents a SQL condition statement as an object,
|
|
* example: `pid = 10 AND cid = 2 ORDER BY date DESC`
|
|
* ```
|
|
* {
|
|
* exp: {
|
|
* "and": {
|
|
* pid: 10,
|
|
* cid: 2
|
|
* }
|
|
* },
|
|
* order: {
|
|
* date: "DESC"
|
|
* }
|
|
* }
|
|
* ```
|
|
*/
|
|
function dbquery(cmd: string, d: GenericObject<any>): Promise<RequestResult>;
|
|
}
|
|
}
|
|
}
|
|
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<any>}
|
|
* @memberof BaseDialog
|
|
*/
|
|
data: GenericObject<any>;
|
|
/**
|
|
*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 [[init]] function will find the scheme definition
|
|
* in this class variable
|
|
*
|
|
* @static
|
|
* @type {string}
|
|
* @memberof BasicDialog
|
|
*/
|
|
static scheme: string;
|
|
/**
|
|
*Creates an instance of BasicDialog.
|
|
* @param {string} name dialog name
|
|
* @param {(string | OS.API.VFS.BaseFileHandle)} [markup] UI scheme definition
|
|
* @memberof BasicDialog
|
|
*/
|
|
constructor(name: string, markup?: string | OS.API.VFS.BaseFileHandle);
|
|
/**
|
|
* Render the dialog using the UI scheme provided by either
|
|
* the `markup` instance variable or the `scheme` class variable
|
|
*
|
|
* @returns {void}
|
|
* @memberof BasicDialog
|
|
*/
|
|
init(): void;
|
|
/**
|
|
* Main entry point for the dialog
|
|
*
|
|
* @memberof BasicDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* The namespace `dialogs` is dedicated to all Dialog definition
|
|
* in AntOS
|
|
*/
|
|
namespace dialogs {
|
|
/**
|
|
* Simple prompt dialog to get user input text.
|
|
* The input data of the dialog:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* title: string, // window title
|
|
* label: string, // label text
|
|
* value: string, // user input text
|
|
* type: string // input type: text or password
|
|
* }
|
|
* ```
|
|
*
|
|
* The data passing from the dialog to the callback function is
|
|
* in the string text of the user input value
|
|
*
|
|
* @export
|
|
* @class PromptDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class PromptDialog extends BasicDialog {
|
|
/**
|
|
*Creates an instance of PromptDialog.
|
|
* @memberof PromptDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Main entry point
|
|
*
|
|
* @memberof PromptDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* A text dialog is similar to a [[PromptDialog]] nut allows
|
|
* user to input multi-line text.
|
|
*
|
|
* Refer to [[PromptDialog]] for the definition of input and callback data
|
|
* of the dialog
|
|
*
|
|
* @export
|
|
* @class TextDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class TextDialog extends BasicDialog {
|
|
/**
|
|
*Creates an instance of TextDialog.
|
|
* @memberof TextDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Main entry point
|
|
*
|
|
* @memberof TextDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* A Calendar dialog allows user to select a date
|
|
*
|
|
* Input data:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* title: string // window title
|
|
* }
|
|
* ```
|
|
*
|
|
* @export
|
|
* @class CalendarDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class CalendarDialog extends BasicDialog {
|
|
/**
|
|
* Creates an instance of CalendarDialog.
|
|
*
|
|
* Callback data: a Date object represent the selected date
|
|
*
|
|
*
|
|
* @memberof CalendarDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
*
|
|
*
|
|
* @memberof CalendarDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* Color picker dialog
|
|
*
|
|
* Input data:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* title: string // window title
|
|
* }
|
|
* ```
|
|
* Callback data: [[ColorType]] object
|
|
*
|
|
* @export
|
|
* @class ColorPickerDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class ColorPickerDialog extends BasicDialog {
|
|
/**
|
|
*Creates an instance of ColorPickerDialog.
|
|
* @memberof ColorPickerDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
*
|
|
*
|
|
* @memberof ColorPickerDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* Show key-value pair of the input object
|
|
*
|
|
* Input data:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* title: string, // window title
|
|
* [propName:string]: any
|
|
* }
|
|
* ```
|
|
*
|
|
* No data for callback
|
|
*
|
|
* @export
|
|
* @class InfoDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class InfoDialog extends BasicDialog {
|
|
/**
|
|
*Creates an instance of InfoDialog.
|
|
* @memberof InfoDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
*
|
|
*
|
|
* @memberof InfoDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* A simple confirm dialog
|
|
*
|
|
* Input data:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* title: string, // window title
|
|
* icon?: string, // label icon
|
|
* iconclass?: string, // label iconclass
|
|
* text: string // label text
|
|
* }
|
|
* ```
|
|
*
|
|
* Callback data: `boolean`
|
|
*
|
|
* @export
|
|
* @class YesNoDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class YesNoDialog extends BasicDialog {
|
|
/**
|
|
*Creates an instance of YesNoDialog.
|
|
* @memberof YesNoDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Main entry point
|
|
*
|
|
* @memberof YesNoDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* A selection dialog provide user with a list of options to
|
|
* select.
|
|
*
|
|
* Input data:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* title: string, // window title
|
|
* data:
|
|
* {
|
|
* text: string,
|
|
* [propName:string]: any
|
|
* } [] // list data
|
|
* ```
|
|
*
|
|
* Callback data: the selected data in the input list
|
|
*
|
|
* @export
|
|
* @class SelectionDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class SelectionDialog extends BasicDialog {
|
|
/**
|
|
*Creates an instance of SelectionDialog.
|
|
* @memberof SelectionDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Main entry
|
|
*
|
|
* @memberof SelectionDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* An About dialog is dedicated to show the parent
|
|
* application meta-data
|
|
*
|
|
* Input data: no
|
|
*
|
|
* Callback data: no
|
|
*
|
|
* @export
|
|
* @class AboutDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class AboutDialog extends BasicDialog {
|
|
/**
|
|
*Creates an instance of AboutDialog.
|
|
* @memberof AboutDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Main entry point
|
|
*
|
|
* @returns {void}
|
|
* @memberof AboutDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* File dialog allows user to select a file/folder
|
|
*
|
|
* Input data:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* title: string, // window title
|
|
* root?: string, // the root path folder of the file view
|
|
* type?: "file"|"dir"|"app", // file type to be selected
|
|
* mimes?: string[], // mime types of file to be selected
|
|
* hidden?: boolean, // show/hide hidden file
|
|
* file?: string // file name
|
|
*
|
|
* }
|
|
* ```
|
|
*
|
|
* Callback data:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* file: string, // selected file path
|
|
* name: string // user input file name
|
|
* }
|
|
* ```
|
|
*
|
|
* @export
|
|
* @class FileDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class FileDialog extends BasicDialog {
|
|
/**
|
|
*Creates an instance of FileDialog.
|
|
* @memberof FileDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Store the last opened directory
|
|
*
|
|
* @static
|
|
* @type {string}
|
|
* @memberof FileDialog
|
|
*/
|
|
static last_opened: string;
|
|
/**
|
|
*
|
|
*
|
|
* @returns {void}
|
|
* @memberof FileDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* Generic & dynamic key-value dialog. The content
|
|
* of the dialog consist of an array of label and input elements
|
|
* which are generated based on the input model
|
|
*
|
|
* The input data of the dialog should be:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* title: string, // window title
|
|
* model: {
|
|
* [propName:string]: string
|
|
* },
|
|
* data: {
|
|
* [propName:string]: string
|
|
* },
|
|
* allow_empty: boolean
|
|
* }
|
|
* ```
|
|
* Where:
|
|
* - keys of `model` are data fields, each key correspond to an input element
|
|
* - values of `model` are description texts of fields, each value correspond to a label text
|
|
* - data is the input data object in the format of model (optional)
|
|
*
|
|
* ```
|
|
* Example:
|
|
* {
|
|
* title: "Greeting",
|
|
* model: {
|
|
* name: "Your name",
|
|
* email: "Your email"
|
|
* },
|
|
* allow_empty: false
|
|
* }
|
|
*```
|
|
|
|
* The data passing from the dialog to the callback function is
|
|
* the user input data corresponding to the input model
|
|
*
|
|
* Example of callback data for the above model:
|
|
*
|
|
* ```
|
|
* {
|
|
* name: "John Doe",
|
|
* email: "jd@mail.com"
|
|
* }
|
|
* ```
|
|
*
|
|
* @export
|
|
* @class MultiInputDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class MultiInputDialog extends BasicDialog {
|
|
/**
|
|
* References to all the input fields in the
|
|
* dialog
|
|
*
|
|
* @private
|
|
* @type {HTMLElement[]}
|
|
* @memberof MultiInputDialog
|
|
*/
|
|
private inputs;
|
|
/**
|
|
*Creates an instance of MultiInputDialog.
|
|
* @memberof MultiInputDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Generate the scheme before rendering
|
|
*
|
|
* @memberof MultiInputDialog
|
|
*/
|
|
init(): void;
|
|
/**
|
|
* Main entry point
|
|
*
|
|
* @memberof MultiInputDialog
|
|
*/
|
|
main(): void;
|
|
}
|
|
/**
|
|
* Generic dynamic key-value dialog
|
|
*
|
|
* Allow user to input any data key-value based object:
|
|
*
|
|
* {
|
|
* [prop:string]: string;
|
|
* }
|
|
*
|
|
* @export
|
|
* @class KeyValueDialog
|
|
* @extends {BasicDialog}
|
|
*/
|
|
class KeyValueDialog extends BasicDialog {
|
|
/**
|
|
* Reference to the form container
|
|
*
|
|
* @private
|
|
* @type {HTMLDivElement}
|
|
* @memberof KeyValueDialog
|
|
*/
|
|
private container;
|
|
/**
|
|
* Creates an instance of KeyValueDialog.
|
|
* @memberof KeyValueDialog
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Main entry point
|
|
*
|
|
* @memberof KeyValueDialog
|
|
*/
|
|
main(): void;
|
|
/**
|
|
* Add new input key-value field to the dialog
|
|
*
|
|
* @private
|
|
* @memberof KeyValueDialog
|
|
*/
|
|
private addField;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
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 [[nodes]] property should be used
|
|
*
|
|
* @type {BasicItemType[]}
|
|
* @memberof BasicItemType
|
|
*/
|
|
children?: BasicItemType[];
|
|
/**
|
|
* Item children, usually used by tree view or menu item
|
|
*
|
|
* @type {BasicItemType[]}
|
|
* @memberof BasicItemType
|
|
*/
|
|
nodes?: BasicItemType[];
|
|
[propName: string]: any;
|
|
}
|
|
/**
|
|
* Element id of the virtual desktop, used by JQuery
|
|
*/
|
|
var workspace: string;
|
|
/**
|
|
* Indicate whether the system is in fullscreen mode
|
|
*/
|
|
var fullscreen: boolean;
|
|
/**
|
|
* Reference to the current system dialog, only one dialog
|
|
* is allowed at a time. A dialog may have sub dialog
|
|
*/
|
|
var dialog: BaseDialog;
|
|
/**
|
|
* Convert an application html scheme to
|
|
* UI elements, then insert this UI scheme to the DOM tree.
|
|
*
|
|
* This function renders the UI of the application before calling the
|
|
* application's [[main]] function
|
|
*
|
|
* @export
|
|
* @param {string} html html scheme string
|
|
* @param {BaseModel} app reference to the target application
|
|
* @param {(Element | string)} parent
|
|
* The parent HTML element where the application is rendered.
|
|
* This is usually the reference to the virtual desktop element.
|
|
*/
|
|
function htmlToScheme(html: string, app: BaseModel, parent: Element | string): void;
|
|
/**
|
|
* Load an application scheme file then render
|
|
* it with [[htmlToScheme]]
|
|
*
|
|
* @export
|
|
* @param {string} path VFS path to the scheme file
|
|
* @param {BaseModel} app the target application
|
|
* @param {(HTMLElement | string)} parent The parent HTML element where the application is rendered.
|
|
*/
|
|
function loadScheme(path: string, app: BaseModel, parent: HTMLElement | string): void;
|
|
/**
|
|
* Clear the current system theme
|
|
*
|
|
* @export
|
|
*/
|
|
function clearTheme(): void;
|
|
/**
|
|
* Load a theme based on its name, then refresh the
|
|
* system UI theme
|
|
*
|
|
* @export
|
|
* @param {string} name name of the theme e.g. `antos_dark`
|
|
* @param {boolean} force force to clear the system theme before applying the new one
|
|
*/
|
|
function loadTheme(name: string, force: boolean): void;
|
|
/**
|
|
* 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<any>} [data] input data of the dialog, refer to each
|
|
* dialog definition for the format of the input data
|
|
* @returns {Promise<any>} 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<any>): Promise<any>;
|
|
/**
|
|
* Toast notification configuration options
|
|
*
|
|
*
|
|
* @export
|
|
* @interface ToastOptions
|
|
*/
|
|
interface ToastOptions {
|
|
/**
|
|
* Where the Toast is displayed? see [[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 [[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<API.PackageMetaType>} result in forme of:
|
|
* `service_name:service-meta-data` key-value pairs
|
|
*/
|
|
function appsWithServices(): GenericObject<API.PackageMetaType>;
|
|
/**
|
|
* Find an launch an application using input application argument
|
|
* such as VFS file meta-data.
|
|
*
|
|
* Based on the input application argument, the function will try
|
|
* to find all applications that is compatible with that argument.
|
|
* Three cases possible:
|
|
* - There is no application that can handle the argument, a message will
|
|
* be notified to user.
|
|
* - There is one application that can handle the argument, the application
|
|
* will be launched with the argument
|
|
* - There are many applications that can handle the arguments, a selection
|
|
* dialog will be popped up and allows user to select an application to launch.
|
|
*
|
|
* @export
|
|
* @param {AppArgumentsType} it application argument
|
|
* @returns {void}
|
|
*/
|
|
function openWith(it: AppArgumentsType): void;
|
|
/**
|
|
* Kil all processes related to an application, reload the application
|
|
* prototype definition and launch a new process of this application.
|
|
*
|
|
* This function is used only for debug purpose or used by
|
|
* AntOSDK during in-browser application development
|
|
*
|
|
* @export
|
|
* @param {string} app the application class name
|
|
* @param {AppArgumentsType[]} args application arguments
|
|
* @returns {void}
|
|
*/
|
|
function forceLaunch(app: string, args: AppArgumentsType[]): void;
|
|
/**
|
|
* Kill an running processes of an application, then
|
|
* unregister the application prototype definition
|
|
* from the [[application]] namespace.
|
|
*
|
|
* This process is similar to uninstall the application
|
|
* from the current system state
|
|
*
|
|
* @export
|
|
* @param {string} app
|
|
*/
|
|
function unloadApp(app: string, 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
|
|
* @returns {Promise<PM.ProcessType>}
|
|
*/
|
|
function pushService(ph: string): Promise<PM.ProcessType>;
|
|
/**
|
|
* Synchronously start a list of services
|
|
*
|
|
* @export
|
|
* @param {string[]} srvs list of service class names
|
|
* @returns {Promise<void>}
|
|
*/
|
|
function pushServices(srvs: string[]): Promise<void>;
|
|
/**
|
|
* Launch an application with arguments
|
|
*
|
|
* @export
|
|
* @param {string} app application class name
|
|
* @param {AppArgumentsType[]} args application arguments
|
|
*/
|
|
function launch(app: string, args: AppArgumentsType[]): Promise<OS.PM.ProcessType>;
|
|
/**
|
|
* Dock an application to the system application dock
|
|
*
|
|
* @export
|
|
* @param {BaseApplication} app reference to the application process
|
|
* @param {API.PackageMetaType} meta Application meta-data
|
|
* @returns {void}
|
|
*/
|
|
function dock(app: OS.application.BaseApplication, meta: API.PackageMetaType): void;
|
|
/**
|
|
* Toggle system fullscreen
|
|
*
|
|
* @export
|
|
*/
|
|
function toggleFullscreen(): void;
|
|
/**
|
|
* Remove an application process from the system application
|
|
* dock. This action will also exit the process
|
|
*
|
|
* @export
|
|
* @param {BaseApplication} app
|
|
* @returns
|
|
*/
|
|
function undock(app: application.BaseApplication): void;
|
|
/**
|
|
* Attach a running service process to the system tray
|
|
*
|
|
* @export
|
|
* @param {BaseService} srv reference to the running service process
|
|
* @returns {void}
|
|
*/
|
|
function attachservice(srv: application.BaseService): void;
|
|
/**
|
|
* Detach a running process from the system tray
|
|
*
|
|
* @export
|
|
* @param {BaseService} srv reference to the running service process
|
|
* @returns {void}
|
|
*/
|
|
function detachservice(srv: application.BaseService): void;
|
|
/**
|
|
* Register a hot key and its handle in the
|
|
* system shortcut
|
|
*
|
|
* @export
|
|
* @param {string} k the hotkey e.g. `ALT-C`
|
|
* @param {(e: JQuery.KeyPressEvent) => void} f handle function
|
|
* @param {boolean} force force to rebind the hotkey
|
|
* @returns {void}
|
|
*/
|
|
function bindKey(k: string, f: (e: JQuery.KeyDownEvent) => void, force?: boolean): void;
|
|
/**
|
|
* Load and apply system wallpaper from the setting object
|
|
*
|
|
* @export
|
|
* @param {setting.WPSettingType} obj wallpaper setting object
|
|
*/
|
|
function wallpaper(obj?: setting.WPSettingType): void;
|
|
/**
|
|
* Refresh the virtual desktop
|
|
*
|
|
* @export
|
|
*/
|
|
function refreshDesktop(): void;
|
|
/**
|
|
* Show the login screen and perform the login operation.
|
|
*
|
|
* Once login successfully, the [[startAntOS]] will be called
|
|
*
|
|
* @export
|
|
*/
|
|
function login(): void;
|
|
/**
|
|
* Start AntOS after a successful login.
|
|
*
|
|
* This function performs the following operations:
|
|
*
|
|
* - System cleanup
|
|
* - Apply system setting
|
|
* - Load desktop wallpaper and the current theme from the system setting
|
|
* - Load system package meta-data
|
|
* - Load and apply system locale and language
|
|
*
|
|
*
|
|
* @export
|
|
* @param {*} conf
|
|
*/
|
|
function startAntOS(conf: any): void;
|
|
/**
|
|
* HTML schemes used by the system:
|
|
* - The login screen scheme
|
|
* - The workspace including:
|
|
* - System panel
|
|
* - Virtual desktop
|
|
* - Context menu
|
|
* - System tooltip
|
|
*/
|
|
const schemes: GenericObject<string>;
|
|
}
|
|
}
|
|
/**
|
|
* Reference to the global this
|
|
*/
|
|
declare const Ant: typeof globalThis;
|
|
/**
|
|
* Extend the String prototype with some API
|
|
* functions used by AntOS API
|
|
*
|
|
* @interface String
|
|
*/
|
|
interface String {
|
|
/**
|
|
* Simple string hash function
|
|
*
|
|
* @returns {number}
|
|
* @memberof String
|
|
*/
|
|
hash(): number;
|
|
/**
|
|
* Parse the current string and convert it
|
|
* to an object of type [[Version]] if the string
|
|
* is in the format recognized by [[Version]],
|
|
* e.g.: `1.0.1-a`
|
|
*
|
|
* @returns {OS.Version}
|
|
* @memberof String
|
|
*/
|
|
__v(): OS.Version;
|
|
/**
|
|
* Convert the current string to base 64 string
|
|
*
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
asBase64(): string;
|
|
/**
|
|
* Unescape all escaped characters on the
|
|
* string using `\`
|
|
*
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
unescape(): string;
|
|
/**
|
|
* Escape the current string using backslash
|
|
*
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
escape(): string;
|
|
/**
|
|
* Convert the current string to uint8 array
|
|
*
|
|
* @returns {Uint8Array}
|
|
* @memberof String
|
|
*/
|
|
asUint8Array(): Uint8Array;
|
|
/**
|
|
* Format the current using input parameters.
|
|
* The current string should be a formatted string
|
|
* in the following form:
|
|
*
|
|
* ```typescript
|
|
* "example string: {0} and {1}".format("hello", "world")
|
|
* // return "example string: hello and world"
|
|
* ```
|
|
*
|
|
* @param {...any[]} args
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
format(...args: any[]): string;
|
|
/**
|
|
* Create a [[FormattedString]] object using the current
|
|
* string and the input parameters
|
|
*
|
|
* @param {...any[]} args
|
|
* @returns {OS.FormattedString}
|
|
* @memberof String
|
|
*/
|
|
f(...args: any[]): OS.FormattedString;
|
|
/**
|
|
* Check if the current string is translatable, if it
|
|
* is the case, translate the string to the language specified
|
|
* in the current system locale setting.
|
|
*
|
|
* A translatable string is a string in the following
|
|
* form: `"__(example string)"`
|
|
*
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
__(): string;
|
|
/**
|
|
* Translate current string to the language specified
|
|
* by the system locale setting
|
|
*
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
l(): string;
|
|
/**
|
|
* Trim left of a string by a mask string
|
|
*
|
|
* @param {string} arg specifies a sub-string to be removed
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
trimFromLeft(arg: string): string;
|
|
/**
|
|
* Trim right of a string by a mask string
|
|
*
|
|
* @param {string} arg specifies a sub-string to be removed
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
trimFromRight(arg: string): string;
|
|
/**
|
|
* Trim both left and right of a string by a mask string
|
|
*
|
|
* @param {string} arg specifies a sub-string to be removed
|
|
* @returns {string}
|
|
* @memberof String
|
|
*/
|
|
trimBy(arg: string): string;
|
|
}
|
|
/**
|
|
* Extend the Data prototype with the
|
|
* [[timestamp]] function
|
|
*
|
|
* @interface Date
|
|
*/
|
|
interface Date {
|
|
/**
|
|
* Return the timestamp of the current Date object
|
|
*
|
|
* @returns {number}
|
|
* @memberof Date
|
|
*/
|
|
timestamp(): number;
|
|
/**
|
|
* Covnert to GMTString
|
|
*
|
|
* @returns {number}
|
|
* @memberof Date
|
|
*/
|
|
toGMTString(): string;
|
|
}
|
|
/**
|
|
* Generic key-value pair object interface
|
|
*
|
|
* @interface GenericObject
|
|
* @template T
|
|
*/
|
|
interface GenericObject<T> {
|
|
[index: string]: T;
|
|
}
|
|
/**
|
|
* Global function to create a [[FormattedString]] from
|
|
* a formatted string and a list of parameters. Example
|
|
*
|
|
* ```typescript
|
|
* __("hello {0}", world) // return a FormattedString object
|
|
* ```
|
|
*
|
|
* @param {...any[]} args
|
|
* @returns {(OS.FormattedString | string)}
|
|
*/
|
|
declare function __(...args: any[]): OS.FormattedString | string;
|
|
/**
|
|
* This global function allow chaining stack trace from one error to
|
|
* another. It is particular helping when tracking the source of
|
|
* the error in promises chain which results in some obfuscated stack
|
|
* traces as the stack resets on every new promise.
|
|
*
|
|
* @param {Error} e
|
|
* @returns {Error}
|
|
*/
|
|
declare function __e(e: Error): Error;
|
|
/**
|
|
* This namespace is the main entry point of AntOS
|
|
* API
|
|
*/
|
|
declare namespace OS {
|
|
/**
|
|
* Represent a translatable formatted string
|
|
*
|
|
* @export
|
|
* @class FormattedString
|
|
*/
|
|
class FormattedString {
|
|
/**
|
|
* Format string in the following form
|
|
*
|
|
* ```typescript
|
|
* "format string with {0} and {1}"
|
|
* // {[0-9]} is the format pattern
|
|
* ```
|
|
*
|
|
* @type {string}
|
|
* @memberof FormattedString
|
|
*/
|
|
fs: string;
|
|
/**
|
|
* The value of the format pattern represented
|
|
* in [[fs]]
|
|
*
|
|
* @type {any[]}
|
|
* @memberof FormattedString
|
|
*/
|
|
values: any[];
|
|
/**
|
|
* Creates an instance of FormattedString.
|
|
* @param {string} fs format string
|
|
* @param {any[]} args input values of the format patterns
|
|
* @memberof FormattedString
|
|
*/
|
|
constructor(fs: string, args: any[]);
|
|
/**
|
|
* Convert FormattedString to String
|
|
*
|
|
* @returns {string}
|
|
* @memberof FormattedString
|
|
*/
|
|
toString(): string;
|
|
/**
|
|
* Translate the format string to the current system
|
|
* locale language, format the string with values and
|
|
* then converted it to normal `string`
|
|
*
|
|
* @returns {string}
|
|
* @memberof FormattedString
|
|
*/
|
|
__(): string;
|
|
/**
|
|
* Return the hash number of the formatted string
|
|
*
|
|
* @returns {number}
|
|
* @memberof FormattedString
|
|
*/
|
|
hash(): number;
|
|
/**
|
|
* Match the formatted string against a regular expression
|
|
* a string pattern
|
|
*
|
|
* @param {(string | RegExp)} t string or regular expression
|
|
* @returns {RegExpMatchArray}
|
|
* @memberof FormattedString
|
|
*/
|
|
match(t: string | RegExp): RegExpMatchArray;
|
|
/**
|
|
* Convert the formatted string to Base^$
|
|
*
|
|
* @returns {string}
|
|
* @memberof FormattedString
|
|
*/
|
|
asBase64(): string;
|
|
/**
|
|
* Un escape the formatted string
|
|
*
|
|
* @returns {string}
|
|
* @memberof FormattedString
|
|
*/
|
|
unescape(): string;
|
|
/**
|
|
* Escape the formatted string
|
|
*
|
|
* @returns {string}
|
|
* @memberof FormattedString
|
|
*/
|
|
escape(): string;
|
|
/**
|
|
* Convert the formatted string to uint8 array
|
|
*
|
|
* @returns {Uint8Array}
|
|
* @memberof FormattedString
|
|
*/
|
|
asUint8Array(): Uint8Array;
|
|
/**
|
|
* Input values for the format string
|
|
*
|
|
* @param {...any[]} args
|
|
* @memberof FormattedString
|
|
*/
|
|
format(...args: any[]): void;
|
|
}
|
|
/**
|
|
* This class represents the Version number format used by AntOS. A typical
|
|
* AntOS version number is in the following format:
|
|
*
|
|
* ```
|
|
* [major_number].[minor_number].[patch]-[branch]-[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 [[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 [[SubWindow]], its prototype will be registered
|
|
* in the [[dialogs]] namespace, otherwise, if the model type
|
|
* is [[Application]] or [[Service]], its prototype will be
|
|
* registered in the [[application]] namespace.
|
|
*
|
|
* When a model is loaded in the system, its prototype is registered
|
|
* for later uses
|
|
*
|
|
* @export
|
|
* @param {string} name class name
|
|
* @param {*} x the corresponding class
|
|
* @returns {*}
|
|
*/
|
|
function register(name: string, x: PM.ModelTypeClass): void;
|
|
/**
|
|
* This function cleans up the entire system and
|
|
* makes sure the system is in a new and clean session.
|
|
* It performs the following operations:
|
|
*
|
|
* - Kill all running processes
|
|
* - Unregister all global events and reset the global
|
|
* announcement system
|
|
* - Clear the current theme
|
|
* - Reset process manager and all system settings
|
|
*
|
|
* @export
|
|
*/
|
|
function cleanup(): void;
|
|
/**
|
|
* Booting up AntOS. This function checks whether the user
|
|
* is successfully logged in, then call [[startAntOS]], otherwise
|
|
* it shows the login screen
|
|
*
|
|
* @export
|
|
*/
|
|
function boot(): void;
|
|
/**
|
|
* Placeholder for all the callbacks that are called when the system
|
|
* exits. These callbacks are useful when an application or service wants
|
|
* to perform a particular task before shuting down the system
|
|
*/
|
|
const cleanupHandles: {
|
|
[index: string]: () => Promise<any>;
|
|
};
|
|
/**
|
|
* Perform the system shutdown operation. This function calls all
|
|
* clean up handles in [[cleanupHandles]], then save the system setting
|
|
* before exiting
|
|
*
|
|
* @export
|
|
*/
|
|
function exit(): void;
|
|
/**
|
|
* Register a callback to the system [[cleanupHandles]]
|
|
*
|
|
* @export
|
|
* @param {string} n callback string name
|
|
* @param {() => void} f the callback handle
|
|
* @returns
|
|
*/
|
|
function onexit(n: string, f: () => Promise<any>): () => Promise<any>;
|
|
/**
|
|
* The namespace API is dedicated to the definition of the core system APIs
|
|
* used by AntOS and its applications. The following core APIs are defined:
|
|
*
|
|
* - The AntOS announcement system
|
|
* - Virtual File system
|
|
* - Virtual Database
|
|
* - Low-level REST based client-server communication
|
|
* - Dependencies management
|
|
* - System utilities
|
|
*
|
|
* These APIs are considered as middle-ware that abstracts the client-server
|
|
* communication and provide the application layer with a standardized APIs
|
|
* for file/database access, system events handling (announcement), automatic
|
|
* dependencies resolving, etc.
|
|
*/
|
|
namespace API {
|
|
/**
|
|
* AntOS package meta-data type definition
|
|
*
|
|
* @export
|
|
* @interface PackageMetaType
|
|
*/
|
|
interface PackageMetaType {
|
|
/**
|
|
* The application class name, if the package has only services
|
|
* this property is ignored and [[pkgname]] should be specified
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
app?: string;
|
|
/**
|
|
* Package name, in case of [[app]] being undefined, this property
|
|
* need to be specified
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
pkgname?: string;
|
|
/**
|
|
* Package category
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
category: string;
|
|
/**
|
|
* Package description string
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
description: string;
|
|
/**
|
|
* List of services that is attached to the
|
|
* package
|
|
*
|
|
* @type {string[]}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
services?: string[];
|
|
/**
|
|
* CSS icon class of the package
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
iconclass?: string;
|
|
/**
|
|
* VFS application icon path
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
icon?: string;
|
|
/**
|
|
* Package information
|
|
*
|
|
* @type {{
|
|
* author: string;
|
|
* email: string;
|
|
* [propName: string]: any;
|
|
* }}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
info: {
|
|
/**
|
|
* Author of the package
|
|
*
|
|
* @type {string}
|
|
*/
|
|
author: string;
|
|
/**
|
|
* Author's email
|
|
*
|
|
* @type {string}
|
|
*/
|
|
email: string;
|
|
[propName: string]: any;
|
|
};
|
|
/**
|
|
* Application-specific locale definition. When the system locale changes,
|
|
* translatable texts inside the application will be first translated using
|
|
* the locale dictionary defined in the package meta-data. If no translation
|
|
* found, the system locale dictionary is used instead.
|
|
*
|
|
* A local dictionary definition should be in the following format:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* [locale_name: string]: {
|
|
* [origin_string]: string // translation string
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* Example of locale dictionaries:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* "en_GB": {
|
|
* "Cancel": "Cancel",
|
|
* "Modify": "Modify"
|
|
* },
|
|
* "fr_FR": {
|
|
* "Cancel": "Annuler",
|
|
* "Modify": "Modifier"
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* @type {{ [index: string]: GenericObject<string> }} locale dictionaries
|
|
* @memberof PackageMetaType
|
|
*/
|
|
locales: {
|
|
[index: string]: GenericObject<string>;
|
|
};
|
|
/**
|
|
* Mime types supported by the packages, regular expression can be used
|
|
* to specified a range of mimes in common
|
|
*
|
|
* @type {string[]}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
mimes: string[];
|
|
/**
|
|
* Package (application) name
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
name: string;
|
|
/**
|
|
* VFS path to package installation location
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
path: string;
|
|
/**
|
|
* Package version, should be in a format conforming
|
|
* to the version definition in [[Version]] class
|
|
*
|
|
* @type {string}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
version: string;
|
|
/**
|
|
* Package dependencies, each entry is in the following format
|
|
*
|
|
* `package_name@version`
|
|
*
|
|
* Example:
|
|
*
|
|
* ```json
|
|
* [
|
|
* "File@0.1.5-b"
|
|
* ]
|
|
* ```
|
|
*
|
|
* @type {string[]}
|
|
* @memberof PackageMetaType
|
|
*/
|
|
dependencies: string[];
|
|
[propName: string]: any;
|
|
}
|
|
/**
|
|
* Placeholder to store all loaded shared libraries. Once
|
|
* a shared library is firstly loaded, its identity will be
|
|
* stored in this variable. Based on this information, in
|
|
* the next use of the library, the system knows that the
|
|
* library is already loaded and ready to use.
|
|
*
|
|
* A shared library can be a javascript or a CSS file.
|
|
*/
|
|
const shared: GenericObject<boolean>;
|
|
/**
|
|
* 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<string>;
|
|
/**
|
|
* Re-export the system announcement [[getMID]] function to the
|
|
* core API
|
|
*
|
|
* @export
|
|
* @returns {number}
|
|
*/
|
|
function mid(): number;
|
|
/**
|
|
* REST-based API.
|
|
*
|
|
* Perform a POST request to the server. Data exchanged
|
|
* is in `application/json`
|
|
*
|
|
* @export
|
|
* @param {string} p the server URI
|
|
* @param {*} d data object that will be converted to JSON
|
|
* @returns {Promise<any>} a promise on the result data
|
|
*/
|
|
function post(p: string, d: any): Promise<any>;
|
|
/**
|
|
* 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<ArrayBuffer>} a promise on the returned binary data
|
|
*/
|
|
function blob(p: string): Promise<ArrayBuffer>;
|
|
/**
|
|
* REST-based API.
|
|
*
|
|
* Send file to server
|
|
*
|
|
* @export
|
|
* @param {string} p resource URI
|
|
* @param {string} d VFS path of the destination file
|
|
* @returns {Promise<any>}
|
|
*/
|
|
function upload(p: string, d: string): Promise<any>;
|
|
/**
|
|
* REST-based API.
|
|
*
|
|
* Download a file
|
|
*
|
|
* @export
|
|
* @param {string} name file name
|
|
* @param {*} b file content
|
|
*/
|
|
function saveblob(name: string, b: any): void;
|
|
/**
|
|
* Helper function to trigger the global `loading`
|
|
* event. This event should be triggered in the
|
|
* beginning of a heavy task
|
|
*
|
|
* @export
|
|
* @param {number} q message id, see [[mid]]
|
|
* @param {string} p message string
|
|
*/
|
|
function loading(q: number, p: string): void;
|
|
/**
|
|
* Helper function to trigger the global `loaded`
|
|
* event: This event should be triggered in the
|
|
* end of a heavy task that has previously triggered
|
|
* the `loading` event
|
|
*
|
|
* @export
|
|
* @param {number} q the message id of the corresponding `loading` event
|
|
* @param {string} p the message string
|
|
* @param {string} m message status (`OK` of `FAIL`)
|
|
*/
|
|
function loaded(q: number, p: string, m: string): void;
|
|
/**
|
|
* Perform an REST GET request
|
|
*
|
|
* @export
|
|
* @param {string} p the URI of the request
|
|
* @param {string} [t=undefined] the response data type:
|
|
* - jsonp: the response is an json object
|
|
* - script: the response is a javascript code
|
|
* - xm, html: the response is a XML/HTML object
|
|
* - text: plain text
|
|
* @returns {Promise<any>} a Promise on the requested data
|
|
*/
|
|
function get(p: string, t?: string): Promise<any>;
|
|
/**
|
|
* REST-based API
|
|
*
|
|
* Perform a GET operation and executed the returned
|
|
* content as javascript
|
|
*
|
|
* @export
|
|
* @param {string} p URI resource
|
|
* @returns {Promise<any>} promise on the executed content
|
|
*/
|
|
function script(p: string): Promise<any>;
|
|
/**
|
|
* 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<any>} promise on the returned content
|
|
*/
|
|
function resource(r: string): Promise<any>;
|
|
/**
|
|
* 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<void>} a promise on the result data
|
|
*/
|
|
function requires(l: string, force?: boolean): Promise<void>;
|
|
/**
|
|
* Synchronously load a list of shared libraries
|
|
*
|
|
* @export
|
|
* @param {string[]} libs list of shared libraries
|
|
* @returns {Promise<void>}
|
|
*/
|
|
function require(libs: string[]): Promise<void>;
|
|
/**
|
|
* The namespace packages is dedicated to all package management
|
|
* related APIs.
|
|
*/
|
|
namespace packages {
|
|
/**
|
|
* Fetch the package meta-data from the server
|
|
*
|
|
* @export
|
|
* @returns {Promise<RequestResult>} Promise on a [[RequestResult]].
|
|
* A success request result should contain a list of [[PackageMetaType]]
|
|
*/
|
|
function fetch(): Promise<RequestResult>;
|
|
/**
|
|
* Request the server to regenerate the package
|
|
* caches
|
|
*
|
|
* @export
|
|
* @returns {Promise<RequestResult>}
|
|
*/
|
|
function cache(): Promise<RequestResult>;
|
|
}
|
|
/**
|
|
* Save the current user setting
|
|
*
|
|
* @export
|
|
* @returns {Promise<RequestResult>} promise on a [[RequestResult]]
|
|
*/
|
|
function setting(): Promise<RequestResult>;
|
|
/**
|
|
* 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<any>} 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<any>} a promise on the result object (any)
|
|
*/
|
|
function apigateway(d: GenericObject<any>, ws: boolean): Promise<any>;
|
|
/**
|
|
* Perform the global search operation when user enter
|
|
* text in spotlight.
|
|
*
|
|
* This function will call all the search handles stored
|
|
* in [[searchHandle]] and build the search result based
|
|
* on output of these handle
|
|
*
|
|
* @export
|
|
* @param {string} text text to search
|
|
* @returns {any[]}
|
|
*/
|
|
function search(text: string): any[];
|
|
/**
|
|
* Register a search handle to the global [[searchHandle]]
|
|
*
|
|
* @export
|
|
* @param {string} name handle name string
|
|
* @param {(text: string) => any[]} fn search handle
|
|
*/
|
|
function onsearch(name: string, fn: (text: string) => any[]): void;
|
|
/**
|
|
* Set the current system locale: This function will
|
|
* find and load the locale dictionary definition file in the
|
|
* system asset resource, then trigger the global event
|
|
* `systemlocalechange` to translated all translatable text
|
|
* to the target language
|
|
*
|
|
* @export
|
|
* @param {string} name locale name, e.g. `en_GB`
|
|
* @returns {Promise<any>}
|
|
*/
|
|
function setLocale(name: string): Promise<any>;
|
|
/**
|
|
* 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<any>} Promise on the clipboard data
|
|
*/
|
|
function getClipboard(): Promise<any>;
|
|
/**
|
|
* 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;
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
declare namespace OS {
|
|
/**
|
|
* This namespace is dedicated to application and service definition.
|
|
* When an application is loaded, its prototype definition will be
|
|
* inserted to this namespace for reuse lately
|
|
*/
|
|
namespace application {
|
|
/**
|
|
* Abstract prototype of all AntOS applications.
|
|
* Any new application definition should extend
|
|
* this prototype
|
|
*
|
|
* @export
|
|
* @abstract
|
|
* @class BaseApplication
|
|
* @extends {BaseModel}
|
|
*/
|
|
abstract class BaseApplication extends BaseModel {
|
|
/**
|
|
* Placeholder of all settings specific to the application.
|
|
* The settings stored in this object will be saved to system
|
|
* setting when logout and can be reused in the next login session
|
|
*
|
|
* @type {GenericObject<any>}
|
|
* @memberof BaseApplication
|
|
*/
|
|
setting: GenericObject<any>;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* Loading animation check timeout
|
|
*
|
|
* @private
|
|
* @memberof BaseApplication
|
|
*/
|
|
private _loading_toh;
|
|
/**
|
|
* Store pending loading task
|
|
*
|
|
* @private
|
|
* @type {number[]}
|
|
* @memberof BaseApplication
|
|
*/
|
|
private _pending_task;
|
|
/**
|
|
*Creates an instance of BaseApplication.
|
|
* @param {string} name application name
|
|
* @param {AppArgumentsType[]} args application arguments
|
|
* @memberof BaseApplication
|
|
*/
|
|
constructor(name: string, args: AppArgumentsType[]);
|
|
/**
|
|
* Init the application, this function is called when the
|
|
* application process is created and docked in the application
|
|
* dock.
|
|
*
|
|
* The application UI will be rendered after the execution
|
|
* of this function.
|
|
*
|
|
* @returns {void}
|
|
* @memberof BaseApplication
|
|
*/
|
|
init(): void;
|
|
/**
|
|
* Render the application UI by first loading its scheme
|
|
* and then mount this scheme to the DOM tree
|
|
*
|
|
* @protected
|
|
* @returns {void}
|
|
* @memberof BaseApplication
|
|
*/
|
|
protected loadScheme(): void;
|
|
/**
|
|
* API function to perform an heavy task.
|
|
* This function will trigger the global `loading`
|
|
* event at the beginning of the task, and the `loaded`
|
|
* event after finishing the task
|
|
*
|
|
* @protected
|
|
* @param {Promise<any>} promise the promise on a task to be performed
|
|
* @returns {Promise<void>}
|
|
* @memberof BaseApplication
|
|
*/
|
|
protected load(promise: Promise<any>): Promise<void>;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* Set a setting value to the application setting
|
|
* registry
|
|
*
|
|
* @protected
|
|
* @param {string} k setting name
|
|
* @param {*} v setting value
|
|
* @returns {void}
|
|
* @memberof BaseApplication
|
|
*/
|
|
protected registry(k: string, v: any): void;
|
|
/**
|
|
* Show the appliation
|
|
*
|
|
* @returns {void}
|
|
* @memberof BaseApplication
|
|
*/
|
|
show(): void;
|
|
/**
|
|
* Blur the application
|
|
*
|
|
* @returns {void}
|
|
* @memberof BaseApplication
|
|
*/
|
|
blur(): void;
|
|
/**
|
|
* Hide the application
|
|
*
|
|
* @returns {void}
|
|
* @memberof BaseApplication
|
|
*/
|
|
hide(): void;
|
|
/**
|
|
* Maximize or restore the application window size
|
|
* and its position
|
|
*
|
|
* @returns {void}
|
|
* @memberof BaseApplication
|
|
*/
|
|
toggle(): void;
|
|
/**
|
|
* Get the application title
|
|
*
|
|
* @returns {(string| FormattedString)}
|
|
* @memberof BaseApplication
|
|
*/
|
|
title(): string | FormattedString;
|
|
/**
|
|
* 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 [[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 [[GUI.ToastOptions]]
|
|
* @returns {void}
|
|
* @memberof BaseApplication
|
|
*/
|
|
toast(data: any, opts?: GUI.ToastOptions): void;
|
|
/**
|
|
* The cleanup function that is called by [[onexit]] function.
|
|
* Application need to override this function to perform some
|
|
* specific task before exiting or to prevent the application
|
|
* to be exited
|
|
*
|
|
* @protected
|
|
* @param {BaseEvent} e
|
|
* @memberof BaseApplication
|
|
*/
|
|
protected cleanup(e: BaseEvent): void;
|
|
/**
|
|
* Check if the loading tasks ended,
|
|
* if it the case, stop the animation
|
|
*
|
|
* @private
|
|
* @memberof BaseApplication
|
|
*/
|
|
private animation_check;
|
|
}
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
/// <reference types="jquery" />
|
|
declare namespace OS {
|
|
/**
|
|
* Application argument type definition
|
|
*
|
|
* @export
|
|
* @interface AppArgumentsType
|
|
*/
|
|
interface AppArgumentsType {
|
|
/**
|
|
* File type to be open by the app
|
|
*
|
|
* @type {string}
|
|
* @memberof AppArgumentsType
|
|
*/
|
|
type?: string;
|
|
/**
|
|
* File path to be opened
|
|
*
|
|
* @type {string}
|
|
* @memberof AppArgumentsType
|
|
*/
|
|
path: string;
|
|
/**
|
|
* Any other object
|
|
*/
|
|
[propName: string]: any;
|
|
}
|
|
/**
|
|
* Enum definition of different model types
|
|
*
|
|
* @export
|
|
* @enum {number}
|
|
*/
|
|
enum ModelType {
|
|
/**
|
|
* Applications
|
|
*/
|
|
Application = 0,
|
|
/**
|
|
* Services
|
|
*/
|
|
Service = 1,
|
|
/**
|
|
* Sub-window such as dialogs
|
|
*/
|
|
SubWindow = 2
|
|
}
|
|
/**
|
|
* Base AntOS event definition
|
|
*
|
|
* @export
|
|
* @class BaseEvent
|
|
*/
|
|
class BaseEvent {
|
|
/**
|
|
* The event name placeholder
|
|
*
|
|
* @type {string}
|
|
* @memberof BaseEvent
|
|
*/
|
|
name: string;
|
|
/**
|
|
* Placeholder indicates whether the event is forced to
|
|
* be happen
|
|
*
|
|
* @private
|
|
* @type {boolean}
|
|
* @memberof BaseEvent
|
|
*/
|
|
private force;
|
|
/**
|
|
* Placeholder indicates whether the event is prevented.
|
|
* This value has not effect if `force` is set to `true`
|
|
*
|
|
* @type {boolean}
|
|
* @memberof BaseEvent
|
|
*/
|
|
prevent: boolean;
|
|
/**
|
|
*Creates an instance of BaseEvent.
|
|
* @param {string} name event name
|
|
* @param {boolean} force indicates whether the event is forced
|
|
* @memberof BaseEvent
|
|
*/
|
|
constructor(name: string, force: boolean);
|
|
/**
|
|
* Prevent the current event. This function
|
|
* has no effect if `force` is set to true
|
|
*
|
|
* @memberof BaseEvent
|
|
*/
|
|
preventDefault(): void;
|
|
}
|
|
/**
|
|
* The root model of all applications, dialogs or services
|
|
* in the system
|
|
*
|
|
* @export
|
|
* @abstract
|
|
* @class BaseModel
|
|
*/
|
|
abstract class BaseModel {
|
|
/**
|
|
* The class name
|
|
*
|
|
* @type {string}
|
|
* @memberof BaseModel
|
|
*/
|
|
name: string;
|
|
/**
|
|
* The argument of the model
|
|
*
|
|
* @type {AppArgumentsType[]}
|
|
* @memberof BaseModel
|
|
*/
|
|
args: AppArgumentsType[];
|
|
/**
|
|
* Each model has its own local announcement system
|
|
* to handle all local events inside that model.
|
|
*
|
|
* This observable object is propagate to all the
|
|
* UI elements ([[AFXTag]]) inside the model
|
|
*
|
|
* @protected
|
|
* @type {API.Announcer}
|
|
* @memberof BaseModel
|
|
*/
|
|
protected _observable: API.Announcer;
|
|
/**
|
|
* Reference to the core API namespace
|
|
*
|
|
* @protected
|
|
* @type {typeof API}
|
|
* @memberof BaseModel
|
|
*/
|
|
protected _api: typeof API;
|
|
/**
|
|
* Reference to the core GUI namespace
|
|
*
|
|
* @protected
|
|
* @type {typeof GUI}
|
|
* @memberof BaseModel
|
|
*/
|
|
protected _gui: typeof GUI;
|
|
/**
|
|
* Reference to the model's dialog
|
|
*
|
|
* @type {GUI.BaseDialog}
|
|
* @memberof BaseModel
|
|
*/
|
|
dialog: GUI.BaseDialog;
|
|
/**
|
|
* The HTML element ID of the virtual desktop
|
|
*
|
|
* @protected
|
|
* @type {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 {void}
|
|
* @memberof BaseModel
|
|
*/
|
|
protected render(p: string): void;
|
|
/**
|
|
* Exit the model
|
|
*
|
|
* @param {boolean} force set this value to `true` will bypass the prevented exit event by user
|
|
* @returns {void}
|
|
* @memberof BaseModel
|
|
*/
|
|
quit(force?: boolean): void;
|
|
/**
|
|
* 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<any>} 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<any>}
|
|
* @memberof BaseModel
|
|
*/
|
|
protected call(cmd: GenericObject<any>): Promise<any>;
|
|
/**
|
|
* 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<WebSocket>}
|
|
* @memberof BaseModel
|
|
*/
|
|
protected stream(): Promise<WebSocket>;
|
|
/**
|
|
* 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<any>) => void} f event callback
|
|
* @returns {void}
|
|
* @memberof BaseModel
|
|
*/
|
|
subscribe(e: string, f: (d: API.AnnouncementDataType<any>) => void): void;
|
|
/**
|
|
* Open a dialog
|
|
*
|
|
* @param {(GUI.BaseDialog | string)} d a dialog object or a dialog class name
|
|
* @param {GenericObject<any>} [data] input data of the dialog, refer to each
|
|
* dialog definition for the format of the input data
|
|
* @returns {Promise<any>} 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<any>): Promise<any>;
|
|
/**
|
|
* Open a [[YesNoDialog]] to confirm a task
|
|
*
|
|
* @protected
|
|
* @param {GenericObject<any>} data [[YesNoDialog]] input data
|
|
* @returns {Promise<boolean>}
|
|
* @memberof BaseModel
|
|
*/
|
|
protected ask(data: GenericObject<any>): Promise<boolean>;
|
|
/**
|
|
* 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): HTMLElement;
|
|
/**
|
|
* Select all DOM Element inside the UI of the model
|
|
* using JQuery selector
|
|
*
|
|
* @protected
|
|
* @param {string} sel
|
|
* @returns {HTMLElement}
|
|
* @memberof BaseModel
|
|
*/
|
|
protected select(sel: string): JQuery<HTMLElement>;
|
|
}
|
|
}
|
|
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<boolean>}
|
|
* @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<boolean>);
|
|
/**
|
|
* 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<API.FileInfoType>}
|
|
* @memberof FileViewTag
|
|
*/
|
|
private _onfileselect;
|
|
/**
|
|
* placeholder for file open event callback
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<API.FileInfoType>}
|
|
* @memberof FileViewTag
|
|
*/
|
|
private _onfileopen;
|
|
/**
|
|
* placeholder for directory changed event callback
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<API.VFS.BaseFileHandle>}
|
|
* @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<any>[])}
|
|
* @memberof FileViewTag
|
|
*/
|
|
private _header;
|
|
/**
|
|
* placeholder for the user-specified meta-data fetch function
|
|
*
|
|
* @private
|
|
* @memberof FileViewTag
|
|
*/
|
|
private _fetch;
|
|
/**
|
|
*Creates an instance of FileViewTag.
|
|
* @memberof FileViewTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Init the widget before mounting
|
|
*
|
|
* @protected
|
|
* @memberof FileViewTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* Update the current widget, do nothing
|
|
*
|
|
* @protected
|
|
* @param {*} [d]
|
|
* @memberof FileViewTag
|
|
*/
|
|
protected reload(d?: any): void;
|
|
/**
|
|
* set the function that allows to fetch file entries.
|
|
* This handle function should return a promise on
|
|
* an arry of [[API.FileInfoType]]
|
|
*
|
|
* @memberof FileViewTag
|
|
*/
|
|
set fetch(v: (p: string) => Promise<API.FileInfoType[]>);
|
|
/**
|
|
* set the callback handle for the file select event.
|
|
* The parameter of the callback should be an object
|
|
* of type [[TagEventType]]<T> with the data type `T` is [[API.FileInfoType]]
|
|
*
|
|
* @memberof FileViewTag
|
|
*/
|
|
set onfileselect(e: TagEventCallback<API.FileInfoType>);
|
|
/**
|
|
* set the callback handle for the directory changed event.
|
|
* The parameter of the callback should be an object
|
|
* of type [[TagEventType]]<T> with the data type `T` is [[API.VFS.BaseFileHandle]]
|
|
*
|
|
* @memberof FileViewTag
|
|
*/
|
|
set onchdir(e: TagEventCallback<API.VFS.BaseFileHandle>);
|
|
/**
|
|
set the callback handle for the file open event.
|
|
* The parameter of the callback should be an object
|
|
* of type [[TagEventType]]<T> with the data type `T` is [[API.FileInfoType]]
|
|
*
|
|
* @memberof FileViewTag
|
|
*/
|
|
set onfileopen(e: TagEventCallback<API.FileInfoType>);
|
|
/**
|
|
* Setter:
|
|
*
|
|
* chang the view of the widget, there are three different views
|
|
* - `icon`
|
|
* - `list`
|
|
* - `tree`
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the current view setting of the widget
|
|
*
|
|
* @memberof FileViewTag
|
|
*/
|
|
set view(v: string);
|
|
get view(): string;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Turn on/off the changing current working directory feature
|
|
* of the widget when a directory is double clicked. If enabled,
|
|
* the widget will use the configured [[fetch]] function to query
|
|
* the content of the selected directory
|
|
*
|
|
* Getter:
|
|
*
|
|
* check whether changing current working directory feature
|
|
* is enabled
|
|
*
|
|
* @memberof FileViewTag
|
|
*/
|
|
set chdir(v: boolean);
|
|
get chdir(): boolean;
|
|
/**
|
|
* Setter : Enable or disable the status bar of the widget
|
|
*
|
|
* Getter: Check whether the status bar is enabled
|
|
*
|
|
* @memberof FileViewTag
|
|
*/
|
|
set status(v: boolean);
|
|
get status(): boolean;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Allow the widget to show or hide hidden file
|
|
*
|
|
* Getter:
|
|
*
|
|
* Check whether the hidden file should be shown in
|
|
* the widget
|
|
*
|
|
* @memberof FileViewTag
|
|
*/
|
|
set showhidden(v: boolean);
|
|
get showhidden(): boolean;
|
|
/**
|
|
* 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 [[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<DnDEventDataType<TreeViewTag | ListViewItemTag | GridCellPrototype>>);
|
|
/**
|
|
* 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[];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
/**
|
|
*
|
|
* 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 [[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 ([[afxml]]) then mount ([[sync]]) all the
|
|
* elements.
|
|
*
|
|
* @param {OS.API.Announcer} o an AntOS observable object
|
|
* @param {boolean} [flag] indicates whether this is the top-most call of the operation
|
|
* @memberof HTMLElement
|
|
*/
|
|
uify(o: OS.API.Announcer, flag?: boolean): void;
|
|
/**
|
|
*
|
|
*
|
|
* @type {*}
|
|
* @memberof HTMLElement
|
|
*/
|
|
mozRequestFullScreen: any;
|
|
/**
|
|
*
|
|
*
|
|
* @type {*}
|
|
* @memberof HTMLElement
|
|
*/
|
|
webkitRequestFullscreen: any;
|
|
/**
|
|
*
|
|
*
|
|
* @type {*}
|
|
* @memberof HTMLElement
|
|
*/
|
|
msRequestFullscreen: any;
|
|
}
|
|
/**
|
|
*
|
|
*
|
|
* @interface Document
|
|
*/
|
|
interface Document {
|
|
mozCancelFullScreen: any;
|
|
webkitExitFullscreen: any;
|
|
cancelFullScreen: any;
|
|
}
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
/**
|
|
* [[TagLayoutType]] interface using by AFX tags to defined
|
|
* its internal DOM hierarchy
|
|
*
|
|
* @export
|
|
* @interface TagLayoutType
|
|
*/
|
|
interface TagLayoutType {
|
|
/**
|
|
* Element tag name
|
|
*
|
|
* @type {string}
|
|
* @memberof TagLayoutType
|
|
*/
|
|
el: string;
|
|
/**
|
|
* Children layout of the current element
|
|
*
|
|
* @type {TagLayoutType[]}
|
|
* @memberof TagLayoutType
|
|
*/
|
|
children?: TagLayoutType[];
|
|
/**
|
|
* Reference name of the element used by AFX Tag
|
|
*
|
|
* @type {string}
|
|
* @memberof TagLayoutType
|
|
*/
|
|
ref?: string;
|
|
/**
|
|
* CSS class of the element
|
|
*
|
|
* @type {string}
|
|
* @memberof TagLayoutType
|
|
*/
|
|
class?: string;
|
|
/**
|
|
* this is the `data-id` attribute of the element,
|
|
* can be query by the [[aid]] Tag API function.
|
|
* Not to be confused with the DOM `id` attribute
|
|
*
|
|
* @type {(string | number)}
|
|
* @memberof TagLayoutType
|
|
*/
|
|
id?: string | number;
|
|
/**
|
|
* Tooltip text of the element
|
|
*
|
|
* @type {(string | FormattedString)}
|
|
* @memberof TagLayoutType
|
|
*/
|
|
tooltip?: string | FormattedString;
|
|
/**
|
|
* `data-width` of the element, not to be confused with
|
|
* the `width` attribute of the DOM element
|
|
*
|
|
* @type {number|string}
|
|
* @memberof TagLayoutType
|
|
*/
|
|
width?: number | string;
|
|
/**
|
|
** `data-height` of the element, not to be confused with
|
|
* the `height` attribute of the DOM element
|
|
*
|
|
* @type {number|string}
|
|
* @memberof TagLayoutType
|
|
*/
|
|
height?: number | string;
|
|
}
|
|
/**
|
|
* Data type for event issued by AFX tags
|
|
*
|
|
* @export
|
|
* @interface TagEventDataType
|
|
* @template T item template
|
|
*/
|
|
interface TagEventDataType<T> {
|
|
/**
|
|
* 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<T> {
|
|
/**
|
|
* `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;
|
|
}
|
|
/**
|
|
* Drag and Drop data type sent between mouse events
|
|
*
|
|
* @export
|
|
* @interface DnDEventDataType
|
|
* @template T
|
|
*/
|
|
interface DnDEventDataType<T> {
|
|
/**
|
|
* Reference to the source DOM element
|
|
*
|
|
* @type {T}
|
|
* @memberof DnDEventDataType
|
|
*/
|
|
from: T[];
|
|
/**
|
|
* Reference to the target DOM element
|
|
*
|
|
* @type {T}
|
|
* @memberof DnDEventDataType
|
|
*/
|
|
to: T;
|
|
}
|
|
/**
|
|
* Tag event callback type
|
|
*/
|
|
type TagEventCallback<T> = (e: TagEventType<T>) => void;
|
|
/**
|
|
* Base abstract class for tag implementation, any AFX tag should be
|
|
* subclass of this class
|
|
*
|
|
* @export
|
|
* @abstract
|
|
* @class AFXTag
|
|
* @extends {HTMLElement}
|
|
*/
|
|
abstract class AFXTag extends HTMLElement {
|
|
/**
|
|
* The announcer object of the tag
|
|
*
|
|
* @type {API.Announcer}
|
|
* @memberof AFXTag
|
|
*/
|
|
observable: API.Announcer;
|
|
/**
|
|
* Reference to some of the tag's children
|
|
* element. This reference object is built
|
|
* based on the `ref` property found in the
|
|
* tag layout [[TagLayoutType]]
|
|
*
|
|
* @protected
|
|
* @type {GenericObject<HTMLElement>}
|
|
* @memberof AFXTag
|
|
*/
|
|
protected refs: GenericObject<HTMLElement>;
|
|
/**
|
|
* boolean value indicated whether the tag
|
|
* is already mounted in the DOM tree
|
|
*
|
|
* @protected
|
|
* @type {boolean}
|
|
* @memberof AFXTag
|
|
*/
|
|
protected _mounted: boolean;
|
|
/**
|
|
*Creates an instance of AFXTag.
|
|
* @memberof AFXTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* This function verifies if a property name of the input object
|
|
* corresponds to a setter of the current tag. If this is the
|
|
* case, it sets the value of that property to the setter
|
|
*
|
|
* @param {GenericObject<any>} v input object
|
|
* @memberof AFXTag
|
|
*/
|
|
set(v: GenericObject<any>): void;
|
|
/**
|
|
* Setter to set the tooltip text to the current tag.
|
|
* The text should be in the following format:
|
|
* ```text
|
|
* cr|cl|ct|cb: tooltip text
|
|
* ```
|
|
*
|
|
* @memberof AFXTag
|
|
*/
|
|
set tooltip(v: string);
|
|
/**
|
|
*
|
|
* This function looking for a property name of the tag
|
|
* in its prototype chain. The descriptor of the property
|
|
* will be returned if it exists
|
|
*
|
|
* @private
|
|
* @param {string} k the property name to be queried
|
|
* @returns {PropertyDescriptor} the property descriptor or undefined
|
|
* @memberof AFXTag
|
|
*/
|
|
private descriptor_of;
|
|
/**
|
|
* Setter: set the id of the tag in string or number
|
|
*
|
|
* Getter: get the id of the current tag
|
|
*
|
|
* @memberof AFXTag
|
|
*/
|
|
set aid(v: string | number);
|
|
get aid(): string | number;
|
|
/**
|
|
* Implementation from HTMLElement interface,
|
|
* this function mount the current tag hierarchy
|
|
*
|
|
* @returns {void}
|
|
* @memberof AFXTag
|
|
*/
|
|
sync(): void;
|
|
/**
|
|
* Generate the DOM hierarchy of the current tag
|
|
*
|
|
* @param {API.Announcer} o observable object
|
|
* @memberof AFXTag
|
|
*/
|
|
afxml(o: API.Announcer): void;
|
|
/**
|
|
* Update the current tag hierarchy
|
|
*
|
|
* @param {*} d any data object
|
|
* @memberof AFXTag
|
|
*/
|
|
update(d: any): void;
|
|
/**
|
|
* Init the current tag, this function
|
|
* is called before the [[mount]] function
|
|
*
|
|
* @protected
|
|
* @abstract
|
|
* @memberof AFXTag
|
|
*/
|
|
protected abstract init(): void;
|
|
/**
|
|
* Mount only the current tag
|
|
*
|
|
* @protected
|
|
* @abstract
|
|
* @memberof AFXTag
|
|
*/
|
|
protected abstract mount(): void;
|
|
/**
|
|
* Layout definition of a tag
|
|
*
|
|
* @protected
|
|
* @abstract
|
|
* @returns {TagLayoutType[]} tag layout object
|
|
* @memberof AFXTag
|
|
*/
|
|
protected abstract layout(): TagLayoutType[];
|
|
/**
|
|
* Update only the current tag, this function is
|
|
* called by [[update]] before chaining the
|
|
* update process to its children
|
|
*
|
|
* @protected
|
|
* @abstract
|
|
* @param {*} [d]
|
|
* @memberof AFXTag
|
|
*/
|
|
protected abstract reload(d?: any): void;
|
|
/**
|
|
* This function is used to re-render the current
|
|
* tag
|
|
*
|
|
* @protected
|
|
* @memberof AFXTag
|
|
*/
|
|
protected calibrate(): void;
|
|
/**
|
|
* This function parses the input layout object
|
|
* and generates all the elements defined by
|
|
* the tag
|
|
*
|
|
* @private
|
|
* @param {TagLayoutType} tag tag layout object
|
|
* @returns {Element} the DOM element specified by the tag layout
|
|
* @memberof AFXTag
|
|
*/
|
|
private mkui;
|
|
/**
|
|
* This function inserts or removes an attribute name
|
|
* to/from the target element based on the input `flag`.
|
|
*
|
|
* @protected
|
|
* @param {boolean} flag indicates whether the attribute name should be inserted o removed
|
|
* @param {string} v the attribute name
|
|
* @param {HTMLElement} [el] the target element
|
|
* @memberof AFXTag
|
|
*/
|
|
protected attsw(flag: boolean, v: string, el?: HTMLElement): void;
|
|
/**
|
|
* Insert the attribute name to the target element
|
|
*
|
|
* @protected
|
|
* @param {string} v the attribute name
|
|
* @param {HTMLElement} [el] the target element
|
|
* @memberof AFXTag
|
|
*/
|
|
protected atton(v: string, el?: HTMLElement): void;
|
|
/**
|
|
* Remove the attribute name from the target element
|
|
*
|
|
* @protected
|
|
* @param {string} v attribute name
|
|
* @param {HTMLElement} [el] the target element
|
|
* @memberof AFXTag
|
|
*/
|
|
protected attoff(v: string, el?: HTMLElement): void;
|
|
/**
|
|
* Verify if the target element has an attribute name
|
|
*
|
|
* @protected
|
|
* @param {string} v attribute name
|
|
* @param {HTMLElement} [el] target element
|
|
* @returns {boolean}
|
|
* @memberof AFXTag
|
|
*/
|
|
protected hasattr(v: string, el?: HTMLElement): boolean;
|
|
}
|
|
/**
|
|
* All the AFX tags are defined in this namespace,
|
|
* these tags are defined as custom DOM elements and will be
|
|
* stored in the `customElements` registry of the browser
|
|
*/
|
|
namespace tag {
|
|
/**
|
|
* Alias to all classes that extends [[AFXTag]]
|
|
*/
|
|
type AFXTagTypeClass = {
|
|
new <T extends AFXTag>(): 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 [[AFXTag]]
|
|
* @param {string} name name of the tag
|
|
* @param {{ new (): T }} cls the class that defines the tag
|
|
* @returns {void}
|
|
*/
|
|
function define<T extends AFXTag>(name: string, cls: {
|
|
new (): T;
|
|
}): void;
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* List item event data type
|
|
*/
|
|
type ListItemEventData = TagEventDataType<ListViewItemTag>;
|
|
/**
|
|
* A list item represent the individual view of an item in the [[ListView]].
|
|
* This class is an abstract prototype class, implementation of any
|
|
* list view item should extend it
|
|
*
|
|
*
|
|
* @export
|
|
* @abstract
|
|
* @class ListViewItemTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
abstract class ListViewItemTag extends AFXTag {
|
|
/**
|
|
* Data placeholder for the list item
|
|
*
|
|
* @private
|
|
* @type {GenericObject<any>}
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
private _data;
|
|
/**
|
|
* placeholder for the item select event callback
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<ListItemEventData>}
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
private _onselect;
|
|
/**
|
|
* Context menu event callback handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<ListItemEventData>}
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
private _onctxmenu;
|
|
/**
|
|
* Click event callback placeholder
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<ListItemEventData>}
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
private _onclick;
|
|
/**
|
|
* Double click event callback handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<ListItemEventData>}
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
private _ondbclick;
|
|
/**
|
|
* Item close event callback placeholder
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<ListItemEventData>}
|
|
* @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<ListViewItemTag>);
|
|
/**
|
|
* Setter: select/unselect the current item
|
|
*
|
|
* Getter: Check whether the current item is selected
|
|
*
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
set selected(v: boolean);
|
|
get selected(): boolean;
|
|
/**
|
|
* Set the context menu event handle
|
|
*
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
set onctxmenu(v: TagEventCallback<ListViewItemTag>);
|
|
/**
|
|
* Set the item click event handle
|
|
*
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
set onitemclick(v: TagEventCallback<ListViewItemTag>);
|
|
/**
|
|
* Set the item double click event handle
|
|
*
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
set onitemdbclick(v: TagEventCallback<ListViewItemTag>);
|
|
/**
|
|
* set the item close event handle
|
|
*
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
set onitemclose(v: TagEventCallback<ListViewItemTag>);
|
|
/**
|
|
* Mount the tag and bind some events
|
|
*
|
|
* @protected
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* Layout definition of the item tag.
|
|
* This function define the outer layout of the item.
|
|
* Custom inner layout of each item implementation should
|
|
* be defined in [[itemlayout]]
|
|
*
|
|
* @protected
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
protected layout(): TagLayoutType[];
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set the data of the list item. This will
|
|
* trigger the [[ondatachange]] function
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the data of the current list item
|
|
*
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
set data(v: GenericObject<any>);
|
|
get data(): GenericObject<any>;
|
|
/**
|
|
* 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<ListItemEventData>}
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _onlistselect;
|
|
/**
|
|
* placeholder of list double click event handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<ListItemEventData>}
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _onlistdbclick;
|
|
/**
|
|
* placeholder of list drag and drop event handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<DnDEventDataType<ListViewItemTag>>}
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _ondragndrop;
|
|
/**
|
|
* placeholder of list item close event handle
|
|
*
|
|
* @private
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _onitemclose;
|
|
/**
|
|
* placeholder of drag and drop mouse down event handle
|
|
*
|
|
* @private
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _onmousedown;
|
|
/**
|
|
* placeholder of drag and drop mouse up event handle
|
|
*
|
|
* @private
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _onmouseup;
|
|
/**
|
|
* placeholder of drag and drop mouse move event handle
|
|
*
|
|
* @private
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _onmousemove;
|
|
/**
|
|
* Reference to the latest selected DOM item
|
|
*
|
|
* @private
|
|
* @type {ListViewItemTag}
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _selectedItem;
|
|
/**
|
|
* A collection of selected items in the list.
|
|
* The maximum size of this collection is 1 if
|
|
* the [[multiselect]] feature is disabled
|
|
*
|
|
* @private
|
|
* @type {ListViewItemTag[]}
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _selectedItems;
|
|
/**
|
|
* 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<any>[]}
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _data;
|
|
/**
|
|
* Event data passing between mouse event when performing
|
|
* drag and drop on the list
|
|
*
|
|
* @private
|
|
* @type {{ from: ListViewItemTag[]; to: ListViewItemTag }}
|
|
* @memberof ListViewTag
|
|
*/
|
|
private _dnd;
|
|
/**
|
|
*Creates an instance of ListViewTag.
|
|
* @memberof ListViewTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Reset the tag's properties to the default values
|
|
*
|
|
* @protected
|
|
* @memberof ListViewTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* This function does nothing
|
|
*
|
|
* @protected
|
|
* @param {*} [d]
|
|
* @memberof ListViewTag
|
|
*/
|
|
protected reload(d?: any): void;
|
|
/**
|
|
* Setter: toggle between dropdown and traditional list
|
|
*
|
|
* Getter: Check whether the list is dropdown or traditional list
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set dropdown(v: boolean);
|
|
/**
|
|
* Set drag and drop event handle
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set ondragndrop(v: TagEventCallback<DnDEventDataType<ListViewItemTag>>);
|
|
/**
|
|
* Set list select event handle
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set onlistselect(v: TagEventCallback<ListItemEventData>);
|
|
/**
|
|
* Set double click event handle
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set onlistdbclick(v: TagEventCallback<ListItemEventData>);
|
|
/**
|
|
* Set item close event handle
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set onitemclose(v: (e: TagEventType<ListItemEventData>) => boolean);
|
|
get dropdown(): boolean;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set the default tag name of list's items.
|
|
* If the tag name is not specified in the
|
|
* data of a list item, this tag will be used
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the default tag name of list item
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set itemtag(v: string);
|
|
get itemtag(): string;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Turn on/off of the `multiselect` feature
|
|
*
|
|
* Getter:
|
|
*
|
|
* Check whether multi-select is allowed
|
|
* in this list
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set multiselect(v: boolean);
|
|
get multiselect(): boolean;
|
|
/**
|
|
* Setter: Enable/disable drag and drop event in the list
|
|
*
|
|
* Getter: Check whether the drag and drop event is enabled
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set dragndrop(v: boolean);
|
|
get dragndrop(): boolean;
|
|
/**
|
|
* Set the buttons layout of the list.
|
|
* Button layout allows to add some custom
|
|
* behaviors to the list.
|
|
*
|
|
* Each button data should define the [[onbtclick]]
|
|
* event handle to specify the custom behavior
|
|
*
|
|
* When the list is configured as dropdown. The buttons
|
|
* layout will be disabled
|
|
*
|
|
* Example of a button data:
|
|
*
|
|
* ```
|
|
* {
|
|
* text: "Button text",
|
|
* icon: "home://path/to/icon.png",
|
|
* iconclass: "icon-class-name",
|
|
* onbtclick: (e) => console.log(e)
|
|
* }
|
|
* ```
|
|
*
|
|
* @memberof ListViewTag
|
|
*/
|
|
set buttons(v: GenericObject<any>[]);
|
|
/**
|
|
* Getter: Get list direction: horizontal or vertical (default)
|
|
*
|
|
* Setter: Get list direction: horizontal or vertical
|
|
*
|
|
* @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<any>[]}
|
|
* @memberof ListViewTag
|
|
*/
|
|
get data(): GenericObject<any>[];
|
|
set data(data: GenericObject<any>[]);
|
|
/**
|
|
* 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<any>} item
|
|
* @returns {ListViewItemTag} the added list item element
|
|
* @memberof ListViewTag
|
|
*/
|
|
unshift(item: GenericObject<any>): ListViewItemTag;
|
|
/**
|
|
* check whether the list has data
|
|
*
|
|
* @private
|
|
* @param {GenericObject<any>} v
|
|
* @returns
|
|
* @memberof ListViewTag
|
|
*/
|
|
private has_data;
|
|
/**
|
|
* Add an item to the beginning or end of the list
|
|
*
|
|
* @param {GenericObject<any>} 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<any>, 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<ListViewItemTag>): void;
|
|
/**
|
|
* This function triggers the list item select event
|
|
*
|
|
* @protected
|
|
* @param {TagEventType} e tag event object
|
|
* @returns
|
|
* @memberof ListViewTag
|
|
*/
|
|
protected iselect(e: TagEventType<ListViewItemTag>): 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;
|
|
/**
|
|
* 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<number>}
|
|
* @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<number>);
|
|
/**
|
|
* 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[];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
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<HTMLInputElement | HTMLTextAreaElement, unknown, any, any, string>} handle: JQuery handle
|
|
* @memberof InputTag
|
|
*/
|
|
on(ename: string, handle: JQuery.TypeEventHandler<HTMLInputElement | HTMLTextAreaElement, unknown, any, any, string>): 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<ListViewItemTag>;
|
|
/**
|
|
* 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<TabEventData>}
|
|
* @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:
|
|
* - `horizontal`: horizontal direction
|
|
* - `vertical`: 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<any>} item tab data
|
|
* @memberof TabBarTag
|
|
*/
|
|
push(item: GenericObject<any>): 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<any>} item tab data
|
|
* @memberof TabBarTag
|
|
*/
|
|
unshift(item: GenericObject<any>): ListViewItemTag;
|
|
/**
|
|
* Setter: Set tabs data
|
|
*
|
|
* Getter: Get all tabs data
|
|
*
|
|
* @memberof TabBarTag
|
|
*/
|
|
set items(v: GenericObject<any>[]);
|
|
get items(): GenericObject<any>[];
|
|
/**
|
|
* 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<TabEventData>) => boolean);
|
|
/**
|
|
* Set the tab select event handle
|
|
*
|
|
* @memberof TabBarTag
|
|
*/
|
|
set ontabselect(v: TagEventCallback<TabEventData>);
|
|
/**
|
|
* Mount the tab bar and bind some basic events
|
|
*
|
|
* @protected
|
|
* @memberof TabBarTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* TabBar layout definition
|
|
*
|
|
* @protected
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof TabBarTag
|
|
*/
|
|
protected layout(): TagLayoutType[];
|
|
}
|
|
export {};
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
/**
|
|
* 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<ColorType>}
|
|
* @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<ColorType>);
|
|
/**
|
|
* 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[];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* A `resizer` tag is basically used to dynamically resize an element using mouse.
|
|
* It is usually put inside a [[TileLayoutTag]] an can be attached to any element. Example:
|
|
*
|
|
* The resizer tag in the following example will be attached to the first `afx-vbox`,
|
|
* and allows to resize this element using mouse
|
|
*
|
|
* ```xml
|
|
* <afx-hbox>
|
|
* <afx-vbox>...</afx-vbox>
|
|
* <afx-resizer></afx-resizer>
|
|
* <afx-vbox>...</afx-vbox>
|
|
* </afx-hbox>
|
|
* ```
|
|
*
|
|
* @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<any>}
|
|
* @memberof ResizerTag
|
|
*/
|
|
private _onresize;
|
|
/**
|
|
* Reference to the parent tag of the current tag.
|
|
* The parent tag should be an instance of a [[TileLayoutTag]]
|
|
* such as [[VBoxTag]] or [[HBoxTag]]
|
|
*
|
|
* @private
|
|
* @type {*}
|
|
* @memberof ResizerTag
|
|
*/
|
|
private _parent;
|
|
/**
|
|
* Placeholder of the minimum value that
|
|
* the attached element can be resized
|
|
*
|
|
* @private
|
|
* @type {number}
|
|
* @memberof ResizerTag
|
|
*/
|
|
private _minsize;
|
|
/**
|
|
*Creates an instance of ResizerTag.
|
|
* @memberof ResizerTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Set the properties of the tag to default values
|
|
*
|
|
* @protected
|
|
* @memberof ResizerTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @param {*} [d]
|
|
* @memberof ResizerTag
|
|
*/
|
|
protected reload(d?: any): void;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set resize direction, two possible values:
|
|
* - `hz` - horizontal direction, resize by width
|
|
* - `ve` - vertical direction, resize by height
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the resize direction
|
|
*
|
|
* @memberof ResizerTag
|
|
*/
|
|
set dir(v: string);
|
|
get dir(): string;
|
|
/**
|
|
* Getter : Check whether the resizer should attach to its next or previous element
|
|
*
|
|
* Setter: if `v=true` select next element as attached element of the resizer, otherwise
|
|
* select the previous element
|
|
* @readonly
|
|
* @type {boolean}
|
|
* @memberof ResizerTag
|
|
*/
|
|
get attachnext(): boolean;
|
|
set attachnext(v: boolean);
|
|
/**
|
|
* Setter:
|
|
* - set the resize event callback
|
|
*
|
|
* Getter:
|
|
* - get the resize event callback
|
|
*
|
|
* @memberof ResizerTag
|
|
*/
|
|
set onelresize(v: TagEventCallback<any>);
|
|
get onelresize(): TagEventCallback<any>;
|
|
/**
|
|
* Mount the tag to the DOM tree
|
|
*
|
|
* @protected
|
|
* @memberof ResizerTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* Enable draggable on the element
|
|
*
|
|
* @private
|
|
* @memberof ResizerTag
|
|
*/
|
|
private make_draggable;
|
|
/**
|
|
* Resize the attached element in the horizontal direction (width)
|
|
*
|
|
* @private
|
|
* @param {JQuery.MouseEventBase} e JQuery mouse event
|
|
* @returns {void}
|
|
* @memberof ResizerTag
|
|
*/
|
|
private horizontalResize;
|
|
/**
|
|
* Resize the attached element in the vertical direction (height)
|
|
*
|
|
* @protected
|
|
* @param {JQuery.MouseEventBase} e JQuery mouse event
|
|
* @returns {void}
|
|
* @memberof ResizerTag
|
|
*/
|
|
protected verticalResize(e: JQuery.MouseEventBase): void;
|
|
/**
|
|
* Layout definition of the tag, empty layout
|
|
*
|
|
* @protected
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof ResizerTag
|
|
*/
|
|
protected layout(): TagLayoutType[];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* 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$(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 [[TabBarTag]]
|
|
* with a container widget. The attached container widget should be
|
|
* composed inside a [[HBoxTag]]
|
|
*
|
|
* The tab bar in a tab container can be configured to display tabs
|
|
* in horizontal (row) or vertical (column) order. Default to vertical order
|
|
*
|
|
* Once a tab is selected, its attached container will be shown
|
|
*
|
|
* @export
|
|
* @class TabContainerTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
class TabContainerTag extends AFXTag {
|
|
/**
|
|
* Reference to the currently selected tab DOM element
|
|
*
|
|
* @private
|
|
* @type {TabContainerTabType}
|
|
* @memberof TabContainerTag
|
|
*/
|
|
private _selectedTab;
|
|
/**
|
|
* Placeholder of the tab select event handle
|
|
*
|
|
* @protected
|
|
* @type {TagEventCallback<TabContainerTabType>}
|
|
* @memberof TabContainerTag
|
|
*/
|
|
protected _ontabselect: TagEventCallback<TabContainerTabType>;
|
|
/**
|
|
*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<TabContainerTabType>);
|
|
/**
|
|
* 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<any>} item tab descriptor
|
|
* @param {boolean} insert insert the tab content to the container ?
|
|
* @returns {ListViewItemTag} the tab DOM element
|
|
* @memberof TabContainerTag
|
|
*/
|
|
addTab(item: GenericObject<any>, 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<T> {
|
|
/**
|
|
* 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<any>}
|
|
* @memberof Array
|
|
*/
|
|
domel?: GenericObject<any>;
|
|
}
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* Row item event data type
|
|
*/
|
|
type GridRowEventData = TagEventDataType<GridRowTag>;
|
|
/**
|
|
* A grid Row is a simple element that
|
|
* contains a group of grid cell
|
|
*
|
|
* @export
|
|
* @class GridRowTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
class GridRowTag extends AFXTag {
|
|
/**
|
|
* Data placeholder for a collection of cell data
|
|
*
|
|
* @type {GenericObject<any>[]}
|
|
* @memberof GridRowTag
|
|
*/
|
|
data: GenericObject<any>[];
|
|
/**
|
|
* placeholder for the row select event callback
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<GridRowEventData>}
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
private _onselect;
|
|
/**
|
|
*Creates an instance of GridRowTag.
|
|
* @memberof GridRowTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Set item select event handle
|
|
*
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
set onrowselect(v: TagEventCallback<GridRowEventData>);
|
|
/**
|
|
* Setter: select/unselect the current item
|
|
*
|
|
* Getter: Check whether the current item is selected
|
|
*
|
|
* @memberof ListViewItemTag
|
|
*/
|
|
set selected(v: boolean);
|
|
get selected(): boolean;
|
|
/**
|
|
* 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<GridCellPrototype>;
|
|
/**
|
|
* 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<CellEventData>}
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
private _oncellselect;
|
|
/**
|
|
* placeholder for cell double click event callback
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<CellEventData>}
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
private _oncelldbclick;
|
|
/**
|
|
* Data placeholder of the current cell
|
|
*
|
|
* @private
|
|
* @type {GenericObject<any>}
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
private _data;
|
|
/**
|
|
*Creates an instance of GridCellPrototype.
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Set the cell selected event callback
|
|
*
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
set oncellselect(v: TagEventCallback<CellEventData>);
|
|
/**
|
|
* Set the cell double click event callback
|
|
*
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
set oncelldbclick(v: TagEventCallback<CellEventData>);
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set the data of the cell, this will trigger
|
|
* the [[ondatachange]] function
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the current cell data placeholder
|
|
*
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
set data(v: GenericObject<any>);
|
|
get data(): GenericObject<any>;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set/unset the current cell as selected.
|
|
* This will trigger the [[cellselect]]
|
|
* event
|
|
*
|
|
* Getter:
|
|
*
|
|
* Check whether the current cell is selected
|
|
*
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
set selected(v: boolean);
|
|
get selected(): boolean;
|
|
/**
|
|
* Update the current cell. This will
|
|
* reset the cell data
|
|
*
|
|
* @protected
|
|
* @param {*} d
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
protected reload(d: any): void;
|
|
/**
|
|
* Mount the current cell to the grid
|
|
*
|
|
* @protected
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* This function triggers the cell select
|
|
* event
|
|
*
|
|
* @private
|
|
* @param {TagEventType<GridCellPrototype>} e
|
|
* @param {boolean} flag
|
|
* @returns {void}
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
private cellselect;
|
|
/**
|
|
* Abstract function called when the cell data changed.
|
|
* This should be implemented by subclasses
|
|
*
|
|
* @protected
|
|
* @abstract
|
|
* @memberof GridCellPrototype
|
|
*/
|
|
protected abstract ondatachange(): void;
|
|
}
|
|
/**
|
|
* Simple grid cell defines a grid cell with
|
|
* an [[LabelTag]] as it cell layout
|
|
*
|
|
* @export
|
|
* @class SimpleGridCellTag
|
|
* @extends {GridCellPrototype}
|
|
*/
|
|
class SimpleGridCellTag extends GridCellPrototype {
|
|
/**
|
|
*Creates an instance of SimpleGridCellTag.
|
|
* @memberof SimpleGridCellTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Reset the label of the cell with its data
|
|
*
|
|
* @protected
|
|
* @memberof SimpleGridCellTag
|
|
*/
|
|
protected ondatachange(): void;
|
|
/**
|
|
* This function do nothing in this tag
|
|
*
|
|
* @protected
|
|
* @memberof SimpleGridCellTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* This function do nothing in this tag
|
|
*
|
|
* @protected
|
|
* @memberof SimpleGridCellTag
|
|
*/
|
|
protected calibrate(): void;
|
|
/**
|
|
* The layout of the cell with a simple [[LabelTag]]
|
|
*
|
|
* @returns
|
|
* @memberof SimpleGridCellTag
|
|
*/
|
|
layout(): {
|
|
el: string;
|
|
ref: string;
|
|
}[];
|
|
}
|
|
/**
|
|
* A Grid contains a header and a collection grid rows
|
|
* which has the same number of cells as the number of
|
|
* the header elements
|
|
*
|
|
* @export
|
|
* @class GridViewTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
class GridViewTag extends AFXTag {
|
|
/**
|
|
* Grid header definition
|
|
*
|
|
* @private
|
|
* @type {GenericObject<any>[]}
|
|
* @memberof GridViewTag
|
|
*/
|
|
private _header;
|
|
/**
|
|
* Grid rows data placeholder
|
|
*
|
|
* @private
|
|
* @type {GenericObject<any>[][]}
|
|
* @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<CellEventData>}
|
|
* @memberof GridViewTag
|
|
*/
|
|
private _oncellselect;
|
|
/**
|
|
* Row select event callback placeholder
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<CellEventData>}
|
|
* @memberof GridViewTag
|
|
*/
|
|
private _onrowselect;
|
|
/**
|
|
* Cell double click event callback placeholder
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<CellEventData>}
|
|
* @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<DnDEventDataType<GridRowTag>>}
|
|
* @memberof GridViewTag
|
|
*/
|
|
private _ondragndrop;
|
|
/**
|
|
* Creates an instance of GridViewTag.
|
|
* @memberof GridViewTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Set drag and drop event handle
|
|
*
|
|
* @memberof GridViewTag
|
|
*/
|
|
set ondragndrop(v: TagEventCallback<DnDEventDataType<GridRowTag>>);
|
|
/**
|
|
* 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<CellEventData>);
|
|
/**
|
|
* set the row select event callback
|
|
*
|
|
* @memberof GridViewTag
|
|
*/
|
|
set onrowselect(v: TagEventCallback<CellEventData>);
|
|
/**
|
|
* set the cell double click event callback
|
|
*
|
|
* @memberof GridViewTag
|
|
*/
|
|
set oncelldbclick(v: TagEventCallback<CellEventData>);
|
|
/**
|
|
* 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<any>[]}
|
|
* @memberof GridViewTag
|
|
*/
|
|
get header(): GenericObject<any>[];
|
|
set header(v: GenericObject<any>[]);
|
|
/**
|
|
* 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<any>[][]);
|
|
get rows(): GenericObject<any>[][];
|
|
/**
|
|
* 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<any>[], b:GenericObject<any>[]) => 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<any>[], b: GenericObject<any>[], index?: number) => number): void;
|
|
/**
|
|
* Delete a grid rows
|
|
*
|
|
* @param {GridRowTag} row row DOM element
|
|
* @returns {void}
|
|
* @memberof GridViewTag
|
|
*/
|
|
delete(row: GridRowTag): void;
|
|
/**
|
|
* Push a row to the grid
|
|
*
|
|
* @param {GenericObject<any>[]} row list of cell data
|
|
* @param {boolean} flag indicates where the row is add to beginning or end
|
|
* of the row
|
|
* @memberof GridViewTags
|
|
*/
|
|
push(row: GenericObject<any>[], flag: boolean): void;
|
|
/**
|
|
* Unshift a row to the grid
|
|
*
|
|
* @param {GenericObject<any>[]} row list of cell data in the row
|
|
* @memberof GridViewTag
|
|
*/
|
|
unshift(row: GenericObject<any>[]): void;
|
|
/**
|
|
* This function triggers the cell select event
|
|
*
|
|
* @private
|
|
* @param {TagEventType<CellEventData>} 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<GridRowEventData>} 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<string | FormattedString>)}
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
private _osmenu;
|
|
/**
|
|
* Placeholder indicates whether the spotlight is currently shown
|
|
*
|
|
* @private
|
|
* @type {boolean}
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
private _view;
|
|
/**
|
|
* Store pending loading task
|
|
*
|
|
* @private
|
|
* @type {number[]}
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
private _pending_task;
|
|
/**
|
|
* Flag indicate where the selected application shall be openned
|
|
*
|
|
* @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<any>[]}
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
private app_list;
|
|
/**
|
|
*Creates an instance of SystemPanelTag.
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @param {*} [d]
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
protected reload(d?: any): void;
|
|
/**
|
|
* Attach a service to the system tray on the pannel,
|
|
* this operation is performed when a service is started
|
|
*
|
|
* @param {BaseService} s
|
|
* @returns
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
attachservice(s: application.BaseService): void;
|
|
/**
|
|
* Launch the selected application from the spotlight
|
|
* applications list
|
|
*
|
|
* @private
|
|
* @returns {void}
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
private open;
|
|
/**
|
|
* Perform spotlight search operation on keyboard event
|
|
*
|
|
* @private
|
|
* @param {JQuery.KeyboardEventBase} e
|
|
* @returns {void}
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
private search;
|
|
/**
|
|
* detach a service from the system tray of the panel.
|
|
* This function is called when the corresponding running
|
|
* service is killed
|
|
*
|
|
* @param {BaseService} s
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
detachservice(s: application.BaseService): void;
|
|
/**
|
|
* Layout definition of the panel
|
|
*
|
|
* @protected
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
protected layout(): TagLayoutType[];
|
|
/**
|
|
* Refresh applications list on the spotlight widget
|
|
* from system packages meta-data
|
|
*
|
|
* @private
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
private refreshAppList;
|
|
/**
|
|
* Show/hide the spotlight
|
|
*
|
|
* @private
|
|
* @param {boolean} flag
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
private toggle;
|
|
/**
|
|
* Calibrate the spotlight widget
|
|
*
|
|
* @memberof SystemPanelTag
|
|
*/
|
|
calibrate(): void;
|
|
/**
|
|
* 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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
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<JQuery.MouseEventBase>}
|
|
* @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<JQuery.MouseEventBase>);
|
|
/**
|
|
* 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);
|
|
/**
|
|
* 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 {
|
|
/**
|
|
* A tile layout organize it child elements
|
|
* in a fixed horizontal or vertical direction.
|
|
*
|
|
* The size of each child element is attributed based
|
|
* on its configuration of automatically based on the
|
|
* remaining space in the layout
|
|
*
|
|
*
|
|
* @export
|
|
* @class TileLayoutTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
class TileLayoutTag extends AFXTag {
|
|
/**
|
|
*C reates an instance of TileLayoutTag.
|
|
* @memberof TileLayoutTag
|
|
*/
|
|
constructor();
|
|
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: "row" | "column");
|
|
get dir(): "row" | "column";
|
|
/**
|
|
* Setter:
|
|
*
|
|
* SET content padding
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get content padding
|
|
*
|
|
* @memberof TileLayoutTag
|
|
*/
|
|
set padding(v: number);
|
|
get padding(): number;
|
|
/**
|
|
* Mount the element
|
|
*
|
|
* @protected
|
|
* @returns {void}
|
|
* @memberof TileLayoutTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* re-organize the layout
|
|
*
|
|
* @returns {void}
|
|
* @memberof TileLayoutTag
|
|
*/
|
|
calibrate(): void;
|
|
/**
|
|
* Organize the layout in horizontal direction, only work when
|
|
* the layout direction set to horizontal
|
|
*
|
|
* @private
|
|
* @returns {void}
|
|
* @memberof TileLayoutTag
|
|
*/
|
|
private hcalibrate;
|
|
/**
|
|
* Organize the layout in vertical direction, only work when
|
|
* the layout direction set to vertical
|
|
*
|
|
* @private
|
|
* @returns {void}
|
|
* @memberof TileLayoutTag
|
|
*/
|
|
private vcalibrate;
|
|
/**
|
|
* Layout definition
|
|
*
|
|
* @returns
|
|
* @memberof TileLayoutTag
|
|
*/
|
|
layout(): {
|
|
el: string;
|
|
ref: string;
|
|
}[];
|
|
}
|
|
/**
|
|
* A HBox organize its child elements in horizontal direction
|
|
*
|
|
* @export
|
|
* @class HBoxTag
|
|
* @extends {TileLayoutTag}
|
|
*/
|
|
class HBoxTag extends TileLayoutTag {
|
|
/**
|
|
* Creates an instance of HBoxTag.
|
|
* @memberof HBoxTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Mount the tag
|
|
*
|
|
* @protected
|
|
* @memberof HBoxTag
|
|
*/
|
|
protected mount(): void;
|
|
}
|
|
/**
|
|
* A VBox organize its child elements in vertical direction
|
|
*
|
|
* @export
|
|
* @class VBoxTag
|
|
* @extends {TileLayoutTag}
|
|
*/
|
|
class VBoxTag extends TileLayoutTag {
|
|
/**
|
|
*Creates an instance of VBoxTag.
|
|
* @memberof VBoxTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Mount the tag
|
|
*
|
|
* @protected
|
|
* @memberof VBoxTag
|
|
*/
|
|
protected mount(): void;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* 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<TreeViewItemPrototype>;
|
|
/**
|
|
* 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<TreeItemEventData>}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
private _evt;
|
|
/**
|
|
* Reference to the root node
|
|
*
|
|
* @type {TreeViewTag}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
treeroot: TreeViewTag;
|
|
/**
|
|
* The tree path from the root node
|
|
*
|
|
* @type {string}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
treepath: string;
|
|
/**
|
|
* Reference to the parent node of the current node
|
|
*
|
|
* @type {TreeViewTag}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
parent: TreeViewTag;
|
|
/**
|
|
* Placeholder for the `fetch` function of the node.
|
|
* This function is used to fetch the child nodes of the
|
|
* current nodes. This function should return a promise on
|
|
* a list of [[TreeViewDataType]]
|
|
*
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
fetch: (d: TreeViewItemPrototype) => Promise<TreeViewDataType[]>;
|
|
/**
|
|
*Creates an instance of TreeViewItemPrototype.
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Update the tree, this function
|
|
* is used to refresh/expand/collapse the
|
|
* current node based on the input parameter
|
|
*
|
|
* @protected
|
|
* @param {*} p string indication, the value should be:
|
|
* - `expand`: expand the current node
|
|
* - `collapse`: collapse the current node
|
|
* - other string: this string is considered as a tree path of a node. If this value
|
|
* is the value of current node tree path, the node will be refreshed. Otherwise, nothing
|
|
* happens
|
|
* @returns {void}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
protected reload(p: any): void;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set the data of the current node. This will trigger the
|
|
* [[ondatachange]] function
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the current node's data
|
|
*
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
set data(v: TreeViewDataType);
|
|
get data(): TreeViewDataType;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Select or unselect the current node.
|
|
* This will trigger the item select event
|
|
* on the tree root if the parameter is `true`
|
|
*
|
|
* Getter:
|
|
*
|
|
* Check whether the current node is selected
|
|
*
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
set selected(v: boolean);
|
|
get selected(): boolean;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Refresh the current node and expands its sub tree.
|
|
* This function only works if the current node is not
|
|
* a leaf node
|
|
*
|
|
* Getter:
|
|
*
|
|
* Check whether the current node is expanded
|
|
*
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
set open(v: boolean);
|
|
get open(): boolean;
|
|
/**
|
|
* Setter: Set the current indent level of this node from the root node
|
|
*
|
|
* Getter: Get the current indent level
|
|
*
|
|
* @type {number}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
get indent(): number;
|
|
set indent(v: number);
|
|
/**
|
|
* Check whether the current node is not a leaf node
|
|
*
|
|
* @private
|
|
* @returns {boolean}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
private is_folder;
|
|
/**
|
|
* Getter: Get the child nodes data of the current node
|
|
*
|
|
* Setter: Set the child nodes data of the current node
|
|
*
|
|
* @type {TreeViewDataType[]}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
get nodes(): TreeViewDataType[];
|
|
set nodes(nodes: TreeViewDataType[]);
|
|
/**
|
|
* Init the tag with default properties data
|
|
*
|
|
* @protected
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* Mount the tag and bind basic events
|
|
*
|
|
* @protected
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* Layout definition of a node. This function
|
|
* returns the definition of the base outer layout
|
|
* of a node. Custom inner layout of the node should
|
|
* be defined in the [[itemlayout]] function
|
|
*
|
|
* @protected
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
protected layout(): TagLayoutType[];
|
|
/**
|
|
* This function need to be implemented by all subclasses
|
|
* to define the inner layout of the node
|
|
*
|
|
* @protected
|
|
* @abstract
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
protected abstract itemlayout(): TagLayoutType[];
|
|
/**
|
|
* This function is called when the node data change.
|
|
* It needs to be implemented on all subclasses of this
|
|
* class
|
|
*
|
|
* @protected
|
|
* @abstract
|
|
* @memberof TreeViewItemPrototype
|
|
*/
|
|
protected abstract ondatachange(): void;
|
|
}
|
|
/**
|
|
* SimpleTreeViewItem extends [[TreeViewItemPrototype]] and
|
|
* define it inner layout using a [[LabelTag]]
|
|
*
|
|
* @export
|
|
* @class SimpleTreeViewItem
|
|
* @extends {TreeViewItemPrototype}
|
|
*/
|
|
class SimpleTreeViewItem extends TreeViewItemPrototype {
|
|
/**
|
|
*Creates an instance of SimpleTreeViewItem.
|
|
* @memberof SimpleTreeViewItem
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Refresh the label when data changed
|
|
*
|
|
* @protected
|
|
* @returns {void}
|
|
* @memberof SimpleTreeViewItem
|
|
*/
|
|
protected ondatachange(): void;
|
|
/**
|
|
* Inner layout definition
|
|
*
|
|
* @protected
|
|
* @returns
|
|
* @memberof SimpleTreeViewItem
|
|
*/
|
|
protected itemlayout(): {
|
|
el: string;
|
|
ref: string;
|
|
}[];
|
|
}
|
|
/**
|
|
* A tree view widget presents a hierarchical list of nodes.
|
|
*
|
|
* @export
|
|
* @class TreeViewTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
class TreeViewTag extends AFXTag {
|
|
/**
|
|
* Reference to the selected node
|
|
*
|
|
* @private
|
|
* @type {TreeViewItemPrototype}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _selectedItem;
|
|
/**
|
|
* Placeholder for tree select event handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<TreeItemEventData>}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _ontreeselect;
|
|
/**
|
|
* Place holder for tree double click event handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<TreeItemEventData>}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _ontreedbclick;
|
|
/**
|
|
* Placeholder for drag and drop event handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<DnDEventDataType<TreeViewTag>>}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _ondragndrop;
|
|
/**
|
|
* Tree data placeholder
|
|
*
|
|
* @private
|
|
* @type {TreeViewDataType}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _data;
|
|
/**
|
|
* Placeholder for private dragndrop mouse down event handle
|
|
*
|
|
* @private
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _treemousedown;
|
|
/**
|
|
* Placeholder for private dragndrop mouse up event handle
|
|
*
|
|
* @private
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _treemouseup;
|
|
/**
|
|
* Placeholder for private dragndrop mouse move event handle
|
|
*
|
|
* @private
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _treemousemove;
|
|
/**
|
|
* Private data object passing between dragndrop mouse event
|
|
*
|
|
* @private
|
|
* @type {{ from: TreeViewTag[]; to: TreeViewTag }}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
private _dnd;
|
|
/**
|
|
* Reference to parent tree of the current tree.
|
|
* This value is undefined if the current tree is the root
|
|
*
|
|
* @type {TreeViewTag}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
parent: TreeViewTag;
|
|
/**
|
|
* Reference to the root tree, this value is undefined
|
|
* if the curent tree is root
|
|
*
|
|
* @type {TreeViewTag}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
treeroot: TreeViewTag;
|
|
/**
|
|
* tree path of the current tree from the root
|
|
*
|
|
* @type {string}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
treepath: string;
|
|
/**
|
|
* Indent level of the current tree
|
|
*
|
|
* @type {number}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
indent: number;
|
|
/**
|
|
* Indicates whether the tree should be expanded
|
|
*
|
|
* @type {boolean}
|
|
* @memberof TreeViewTag
|
|
*/
|
|
open: boolean;
|
|
/**
|
|
* Placeholder for the `fetch` function of the tree.
|
|
* This function is used to fetch the child nodes of the
|
|
* current tree. This function should return a promise on
|
|
* a list of [[TreeViewDataType]]
|
|
*
|
|
* @memberof TreeViewTag
|
|
*/
|
|
fetch: (d: TreeViewItemPrototype) => Promise<TreeViewDataType[]>;
|
|
/**
|
|
*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<TreeItemEventData>);
|
|
/**
|
|
* Set the tree double click event handle
|
|
*
|
|
* @memberof TreeViewTag
|
|
*/
|
|
set ontreedbclick(v: TagEventCallback<TreeItemEventData>);
|
|
/**
|
|
* 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<TreeItemEventData>): 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<DnDEventDataType<TreeViewTag>>);
|
|
/**
|
|
* 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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* Menu event data interface definition
|
|
*/
|
|
type MenuEventData = TagEventDataType<MenuEntryTag>;
|
|
/**
|
|
* This class defines the abstract prototype of an menu entry.
|
|
* Any implementation of menu entry tag should extend this class
|
|
*
|
|
* @export
|
|
* @abstract
|
|
* @class MenuEntryTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
abstract class MenuEntryTag extends AFXTag {
|
|
/**
|
|
* Data placeholder of the menu entry
|
|
*
|
|
* @private
|
|
* @type {GenericObject<any>}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
private _data;
|
|
/**
|
|
* placeholder of `menu entry select` event handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<MenuEventData>}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
private _onmenuselect;
|
|
/**
|
|
* placeholder of `sub-menu entry select event` handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<MenuEventData>}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
private _onchildselect;
|
|
/**
|
|
* Reference to the parent menu entry of current one
|
|
*
|
|
* @type {MenuEntryTag}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
parent: MenuEntryTag;
|
|
/**
|
|
* Reference to the root menu entry
|
|
*
|
|
* @type {MenuTag}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
root: MenuTag;
|
|
/**
|
|
*Creates an instance of MenuEntryTag.
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Init the tag before mounting
|
|
*
|
|
* @protected
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* Set the `menu entry select` event handle
|
|
*
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
set onmenuselect(v: TagEventCallback<MenuEventData>);
|
|
/**
|
|
* Setter: Set the `sub menu entry select` event handle
|
|
*
|
|
* Getter: get the current `sub menu entry select` event handle
|
|
*
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
set onchildselect(v: TagEventCallback<MenuEventData>);
|
|
get onchildselect(): TagEventCallback<MenuEventData>;
|
|
/**
|
|
* Setter: Set data to the entry
|
|
*
|
|
* Getter: Get data of the current menu entry
|
|
*
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
set data(data: GenericObject<any>);
|
|
get data(): GenericObject<any>;
|
|
/**
|
|
* Check whether the current menu entry has sub-menu
|
|
*
|
|
* @protected
|
|
* @returns {boolean}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
protected has_nodes(): boolean;
|
|
/**
|
|
* Check whether the current menu entry is the root entry
|
|
*
|
|
* @protected
|
|
* @returns
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
protected is_root(): boolean;
|
|
/**
|
|
* Layout definition of the menu entry
|
|
* This function define the outer layout of the menu entry.
|
|
* Custom inner layout of each item implementation should
|
|
* be defined in [[itemlayout]]
|
|
* @protected
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
protected layout(): TagLayoutType[];
|
|
/**
|
|
* Setter: Set the sub-menu data
|
|
*
|
|
* Getter: Get the sub-menu data
|
|
*
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
set nodes(v: GenericObject<any>[]);
|
|
get nodes(): GenericObject<any>[];
|
|
/**
|
|
* Bind some base event to the menu entry
|
|
*
|
|
* @protected
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* Hide the sub-menu of the current menu entry
|
|
*
|
|
* @private
|
|
* @returns {void}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
private submenuoff;
|
|
/**
|
|
* This function trigger two event:
|
|
* - the `onmenuselect` event on the current entry
|
|
* - the `onchildselect` event on the parent of the current entry
|
|
*
|
|
* @protected
|
|
* @param {JQuery.ClickEvent} e
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
protected select(e: JQuery.ClickEvent): void;
|
|
/**
|
|
* custom inner layout of a menu entry
|
|
*
|
|
* @protected
|
|
* @abstract
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof MenuEntryTag
|
|
*/
|
|
protected abstract itemlayout(): TagLayoutType[];
|
|
}
|
|
/**
|
|
* This class extends the [[MenuEntryTag]] prototype. It inner layout is
|
|
* defined with the following elements:
|
|
* - a [[SwitchTag]] acts as checker or radio
|
|
* - a [[LabelTag]] to display the content of the menu entry
|
|
* - a `span` element that display the keyboard shortcut of the entry
|
|
*
|
|
* @class SimpleMenuEntryTag
|
|
* @extends {MenuEntryTag}
|
|
*/
|
|
class SimpleMenuEntryTag extends MenuEntryTag {
|
|
/**
|
|
*Creates an instance of SimpleMenuEntryTag.
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Reset some properties to default value
|
|
*
|
|
* @protected
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
protected calibrate(): void;
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @param {*} [d]
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
protected reload(d?: any): void;
|
|
/**
|
|
* Setter: Turn on/off the checker feature of the menu entry
|
|
*
|
|
* Getter: Check whether the checker feature is enabled on this menu entry
|
|
*
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
set switch(v: boolean);
|
|
get switch(): boolean;
|
|
/**
|
|
* Setter: Turn on/off the radio feature of the menu entry
|
|
*
|
|
* Getter: Check whether the radio feature is enabled
|
|
*
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
set radio(v: boolean);
|
|
get radio(): boolean;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Toggle the switch on the menu entry, this setter
|
|
* only works when the `checker` or `radio` feature is
|
|
* enabled
|
|
*
|
|
* Getter:
|
|
*
|
|
* Check whether the switch is turned on
|
|
*
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
set checked(v: boolean);
|
|
get checked(): boolean;
|
|
/**
|
|
* Set the label icon using a VFS path
|
|
*
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
set icon(v: string);
|
|
/**
|
|
* Set the label CSS icon class
|
|
*
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
set iconclass(v: string);
|
|
/**
|
|
* Set the label text
|
|
*
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
set text(v: string);
|
|
/**
|
|
* Set the keyboard shortcut text
|
|
*
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
set shortcut(v: string);
|
|
/**
|
|
* Uncheck all sub-menu items of the current menu entry
|
|
* that have the radio feature enabled
|
|
*
|
|
* @returns {void}
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
protected reset_radio(): void;
|
|
/**
|
|
* Mount the current tag
|
|
*
|
|
* @protected
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* Trigger the onmenuselect and onchildselect events
|
|
*
|
|
* @protected
|
|
* @param {JQuery.ClickEvent} e Mouse click event
|
|
* @returns {void}
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
protected select(e: JQuery.ClickEvent): void;
|
|
/**
|
|
* Inner item layout of the menu entry
|
|
*
|
|
* @returns
|
|
* @memberof SimpleMenuEntryTag
|
|
*/
|
|
itemlayout(): ({
|
|
el: string;
|
|
ref: string;
|
|
class?: undefined;
|
|
} | {
|
|
el: string;
|
|
class: string;
|
|
ref: string;
|
|
})[];
|
|
}
|
|
/**
|
|
* A menu tag contains a collection of menu entries in which each
|
|
* entry maybe a leaf entry or may contain a submenu
|
|
*
|
|
* @export
|
|
* @class MenuTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
class MenuTag extends AFXTag {
|
|
/**
|
|
* Reference to the parent menu entry of the current value.
|
|
* This value is `undefined` in case of the current menu is
|
|
* the root menu
|
|
*
|
|
* @type {MenuEntryTag}
|
|
* @memberof MenuTag
|
|
*/
|
|
parent: MenuEntryTag;
|
|
/**
|
|
* Reference to the root menu
|
|
*
|
|
* @type {MenuTag}
|
|
* @memberof MenuTag
|
|
*/
|
|
root: MenuTag;
|
|
/**
|
|
* The `pid` of the application that attached to this menu.
|
|
* This value is optional
|
|
*
|
|
* @type {number}
|
|
* @memberof MenuTag
|
|
*/
|
|
pid?: number;
|
|
/**
|
|
* placeholder for menu select event handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<MenuEventData>}
|
|
* @memberof MenuTag
|
|
*/
|
|
private _onmenuselect;
|
|
/**
|
|
* Menu data placeholder
|
|
*
|
|
* @private
|
|
* @type {GenericObject<any>[]}
|
|
* @memberof MenuTag
|
|
*/
|
|
private _items;
|
|
/**
|
|
*Creates an instance of MenuTag.
|
|
* @memberof MenuTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Reset some properties to default value
|
|
*
|
|
* @protected
|
|
* @memberof MenuTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @memberof MenuTag
|
|
*/
|
|
protected calibrate(): void;
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @param {*} [d]
|
|
* @memberof MenuTag
|
|
*/
|
|
protected reload(d?: any): void;
|
|
/**
|
|
* Setter: Set the menu items data
|
|
*
|
|
* Getter: Get menu items data
|
|
*
|
|
* @memberof MenuTag
|
|
*/
|
|
set items(data: GenericObject<any>[]);
|
|
get items(): GenericObject<any>[];
|
|
/**
|
|
* Setter: Set whether the current menu is a context menu
|
|
*
|
|
* Getter: Check whether the current menu is a context menu
|
|
*
|
|
* @memberof MenuTag
|
|
*/
|
|
set context(v: boolean);
|
|
get context(): boolean;
|
|
/**
|
|
* Set menu select event handle
|
|
*
|
|
* @memberof MenuTag
|
|
*/
|
|
set onmenuselect(v: TagEventCallback<MenuEventData>);
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set the default tag name of the menu item.
|
|
* If the tag is not specified in an item data,
|
|
* this value will be used
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the default menu entry tag name
|
|
*
|
|
* @memberof MenuTag
|
|
*/
|
|
set contentag(v: string);
|
|
get contentag(): string;
|
|
/**
|
|
* Get the reference to the function that triggers
|
|
* the menu select event
|
|
*
|
|
* @readonly
|
|
* @type {TagEventCallback}
|
|
* @memberof MenuTag
|
|
*/
|
|
get onmenuitemselect(): TagEventCallback<MenuEventData>;
|
|
/**
|
|
* This function triggers the menu select event
|
|
*
|
|
* @private
|
|
* @param {TagEventType} e
|
|
* @memberof MenuTag
|
|
*/
|
|
private handleselect;
|
|
/**
|
|
* Show the current menu. This function is called
|
|
* only if the current menu is a context menu
|
|
*
|
|
* @param {JQuery.MouseEventBase} e JQuery mouse event
|
|
* @returns {void}
|
|
* @memberof MenuTag
|
|
*/
|
|
show(e: JQuery.MouseEventBase): void;
|
|
/**
|
|
* Test whether the current menu is the root menu
|
|
*
|
|
* @private
|
|
* @returns {boolean}
|
|
* @memberof MenuTag
|
|
*/
|
|
private is_root;
|
|
/**
|
|
* Mount the menu tag and bind some basic events
|
|
*
|
|
* @protected
|
|
* @returns {void}
|
|
* @memberof MenuTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* Add a menu entry to the beginning of the current
|
|
* menu
|
|
*
|
|
* @param {GenericObject<any>} item menu entry data
|
|
* @memberof MenuTag
|
|
*/
|
|
unshift(item: GenericObject<any>): void;
|
|
/**
|
|
* Delete a menu entry
|
|
*
|
|
* @param {MenuEntryTag} item reference to the DOM element of an menu entry
|
|
* @memberof MenuTag
|
|
*/
|
|
delete(item: MenuEntryTag): void;
|
|
/**
|
|
* Add an menu entry to the beginning or end of the menu
|
|
*
|
|
* @param {GenericObject<any>} item menu entry data
|
|
* @param {boolean} flag indicates whether the entry should be added to the beginning of the menu
|
|
* @returns {MenuEntryTag}
|
|
* @memberof MenuTag
|
|
*/
|
|
push(item: GenericObject<any>, flag: boolean): MenuEntryTag;
|
|
/**
|
|
* Menu tag layout definition
|
|
*
|
|
* @returns
|
|
* @memberof MenuTag
|
|
*/
|
|
layout(): {
|
|
el: string;
|
|
ref: string;
|
|
children: ({
|
|
el: string;
|
|
class: string;
|
|
ref?: undefined;
|
|
} | {
|
|
el: string;
|
|
ref: string;
|
|
class?: undefined;
|
|
})[];
|
|
}[];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <reference types="jquery" />
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* menu event data type definition
|
|
*/
|
|
type StackMenuEventData = TagEventDataType<ListViewItemTag>;
|
|
/**
|
|
* 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<any>[][]}
|
|
* @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<TabEventData>}
|
|
* @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<any>[]);
|
|
get items(): GenericObject<any>[];
|
|
/**
|
|
* Setter: Set the menu data
|
|
*
|
|
* Getter: Get the menu data
|
|
*
|
|
* @memberof StackMenuTag
|
|
*/
|
|
set nodes(v: GenericObject<any>[]);
|
|
get nodes(): GenericObject<any>[];
|
|
/**
|
|
* Set the `menu entry select` event handle
|
|
*
|
|
* @memberof StackMenuTag
|
|
*/
|
|
set onmenuselect(v: TagEventCallback<StackMenuEventData>);
|
|
/**
|
|
* 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<number>}
|
|
* @memberof SliderTag
|
|
*/
|
|
private _onchange;
|
|
/**
|
|
* Placeholder of the on changing event handle
|
|
*
|
|
* @private
|
|
* @type {TagEventCallback<number>}
|
|
* @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<number>);
|
|
/**
|
|
* Set value changing event handle.
|
|
* This handle is triggered when moving the
|
|
* slider indicator
|
|
*
|
|
* @memberof SliderTag
|
|
*/
|
|
set onvaluechanging(f: TagEventCallback<number>);
|
|
/**
|
|
* 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 ([[VBoxTag]], [[HboxTag]])
|
|
* can be used inside this tag to compose elements
|
|
*
|
|
* @export
|
|
* @class OverlayTag
|
|
* @extends {AFXTag}
|
|
*/
|
|
class OverlayTag extends AFXTag {
|
|
/**
|
|
* Tag width placeholder
|
|
*
|
|
* @private
|
|
* @type {string}
|
|
* @memberof OverlayTag
|
|
*/
|
|
private _width;
|
|
/**
|
|
* Tag height place holder
|
|
*
|
|
* @private
|
|
* @type {string}
|
|
* @memberof OverlayTag
|
|
*/
|
|
private _height;
|
|
/**
|
|
*Creates an instance of OverlayTag.
|
|
* @memberof OverlayTag
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Put the tag on top of the virtual desktop environment
|
|
*
|
|
* @protected
|
|
* @memberof OverlayTag
|
|
*/
|
|
protected init(): void;
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @param {*} [d]
|
|
* @memberof OverlayTag
|
|
*/
|
|
protected reload(d?: any): void;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set the width of the tag, the tag width should be in form of:
|
|
* `100px` of `80%`
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the tag width
|
|
*
|
|
* @memberof OverlayTag
|
|
*/
|
|
set width(v: string);
|
|
get width(): string;
|
|
/**
|
|
* Setter:
|
|
*
|
|
* Set the tag height, the tag height should be in form of:
|
|
* `100px` of `80%`
|
|
*
|
|
* Getter:
|
|
*
|
|
* Get the tag height
|
|
*
|
|
* @memberof OverlayTag
|
|
*/
|
|
set height(v: string);
|
|
get height(): string;
|
|
/**
|
|
* Calibrate the element when mounting
|
|
*
|
|
* @protected
|
|
* @returns {void}
|
|
* @memberof OverlayTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* Calibrate the width and height of the tag
|
|
*
|
|
* @returns {void}
|
|
* @memberof OverlayTag
|
|
*/
|
|
calibrate(): void;
|
|
/**
|
|
* Layout definition of the tag
|
|
*
|
|
* @protected
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof OverlayTag
|
|
*/
|
|
protected layout(): TagLayoutType[];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* A stack pannel allows to navigate back and forth between pannels
|
|
* (container widget). Each container widget in the stack should be
|
|
* composed inside a [[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<TabContainerTabType>);
|
|
/**
|
|
* 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<WindowTag>}
|
|
* @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<any>}
|
|
* @memberof DesktopTag
|
|
*/
|
|
refresh(): Promise<any>;
|
|
/**
|
|
* 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<any>[]);
|
|
/**
|
|
* 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<any>} v an element data
|
|
* @returns
|
|
* @memberof FloatListTag
|
|
*/
|
|
push(v: GenericObject<any>): 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<application.BaseApplication>}
|
|
* @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<Date>}
|
|
* @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<Date>);
|
|
/**
|
|
* Mount the current widget to the DOM tree
|
|
*
|
|
* @protected
|
|
* @memberof CalendarTag
|
|
*/
|
|
protected mount(): void;
|
|
/**
|
|
* This function triggers the date select event
|
|
*
|
|
* @private
|
|
* @param {TagEventType} e AFX tag event data [[TagEventType]]
|
|
* @returns {void}
|
|
* @memberof CalendarTag
|
|
*/
|
|
private dateselect;
|
|
/**
|
|
* Calibrate the layout of the tag
|
|
*
|
|
* @protected
|
|
* @memberof CalendarTag
|
|
*/
|
|
protected calibrate(): void;
|
|
/**
|
|
* Display the previous month of the current month
|
|
*
|
|
* @private
|
|
* @memberof CalendarTag
|
|
*/
|
|
private prevmonth;
|
|
/**
|
|
* Display the next month of the current month
|
|
*
|
|
* @private
|
|
* @returns
|
|
* @memberof CalendarTag
|
|
*/
|
|
private nextmonth;
|
|
/**
|
|
* Visualize the calendar base on input date
|
|
*
|
|
* @private
|
|
* @param {Date} date
|
|
* @memberof CalendarTag
|
|
*/
|
|
private calendar;
|
|
/**
|
|
* Layout definition of the widget
|
|
*
|
|
* @protected
|
|
* @returns {TagLayoutType[]}
|
|
* @memberof CalendarTag
|
|
*/
|
|
protected layout(): TagLayoutType[];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
namespace GUI {
|
|
namespace tag {
|
|
/**
|
|
* A 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<any>}
|
|
* @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<any>}
|
|
* @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<any>[]);
|
|
/**
|
|
* 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<any>} 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 type VFSFileHandleClass = {
|
|
new (...args: any[]): OS.API.VFS.BaseFileHandle;
|
|
};
|
|
interface String {
|
|
/**
|
|
* Convert a string to VFS file handle.
|
|
*
|
|
* This function will create a file handle object from the string
|
|
* with the help of [[VFS.findHandles]]
|
|
*
|
|
* @returns {OS.API.VFS.BaseFileHandle}
|
|
* @memberof String
|
|
*/
|
|
asFileHandle(): OS.API.VFS.BaseFileHandle;
|
|
}
|
|
declare namespace OS {
|
|
namespace API {
|
|
/**
|
|
* User permission data type
|
|
*
|
|
* @export
|
|
* @interface UserPermissionType
|
|
*/
|
|
interface UserPermissionType {
|
|
read: boolean;
|
|
write: boolean;
|
|
exec: boolean;
|
|
}
|
|
/**
|
|
* VFS file meta-data data type
|
|
*
|
|
* @export
|
|
* @interface FileInfoType
|
|
*/
|
|
interface FileInfoType {
|
|
/**
|
|
* File mime type
|
|
*
|
|
* @type {string}
|
|
* @memberof FileInfoType
|
|
*/
|
|
mime: string;
|
|
/**
|
|
* File size
|
|
*
|
|
* @type {number}
|
|
* @memberof FileInfoType
|
|
*/
|
|
size: number;
|
|
/**
|
|
* File name
|
|
*
|
|
* @type {string}
|
|
* @memberof FileInfoType
|
|
*/
|
|
name: string;
|
|
/**
|
|
* File path
|
|
*
|
|
* @type {string}
|
|
* @memberof FileInfoType
|
|
*/
|
|
path: string;
|
|
/**
|
|
* File type:
|
|
* - `file`
|
|
* - `dir`
|
|
* - `app`
|
|
*
|
|
* @type {string}
|
|
* @memberof FileInfoType
|
|
*/
|
|
type: string;
|
|
/**
|
|
* File permission
|
|
*
|
|
* @type {{
|
|
* group: UserPermissionType;
|
|
* owner: UserPermissionType;
|
|
* other: UserPermissionType;
|
|
* }}
|
|
* @memberof FileInfoType
|
|
*/
|
|
perm?: {
|
|
/**
|
|
* Group permission
|
|
*
|
|
* @type {UserPermissionType}
|
|
*/
|
|
group: UserPermissionType;
|
|
/**
|
|
* Owner permission
|
|
*
|
|
* @type {UserPermissionType}
|
|
*/
|
|
owner: UserPermissionType;
|
|
/**
|
|
* Other permission
|
|
*
|
|
* @type {UserPermissionType}
|
|
*/
|
|
other: UserPermissionType;
|
|
};
|
|
/**
|
|
* Creation time
|
|
*
|
|
* @type {string}
|
|
* @memberof FileInfoType
|
|
*/
|
|
ctime?: string;
|
|
/**
|
|
* Modification time
|
|
*
|
|
* @type {string}
|
|
* @memberof FileInfoType
|
|
*/
|
|
mtime?: string;
|
|
/**
|
|
* Group id
|
|
*
|
|
* @type {number}
|
|
* @memberof FileInfoType
|
|
*/
|
|
gid?: number;
|
|
/**
|
|
* User id
|
|
*
|
|
* @type {number}
|
|
* @memberof FileInfoType
|
|
*/
|
|
uid?: number;
|
|
[propName: string]: any;
|
|
}
|
|
/**
|
|
* This namespace is dedicated to all APIs related to
|
|
* AntOS Virtual File System (VFS)
|
|
*/
|
|
namespace VFS {
|
|
/**
|
|
* Placeholder stores VFS file protocol patterns and its attached file handle class.
|
|
*
|
|
*/
|
|
const handles: GenericObject<VFSFileHandleClass>;
|
|
/**
|
|
* Register a protocol to a handle class
|
|
*
|
|
* @export
|
|
* @param {string} protos VFS protocol pattern
|
|
* @param {VFSFileHandleClass} cls handle class
|
|
*/
|
|
function register(protos: string, cls: VFSFileHandleClass): void;
|
|
/**
|
|
* Load custom VFS handles if the package vfsx available
|
|
*
|
|
* @export
|
|
* @param {boolean} [force] force load the file
|
|
* @return {*} {Promise<any>}
|
|
*/
|
|
function loadVFSX(force?: boolean): Promise<any>;
|
|
/**
|
|
* Looking for a attached file handle class of a string protocol
|
|
*
|
|
* When converting a string to file handle, the system will look
|
|
* for a protocol pattern in the string, if the protocol found,
|
|
* its attached handle class (found in [[VFS.handles]]) will be
|
|
* used to initialize a file handle object from the string
|
|
*
|
|
* ```typescript
|
|
* "home://data/test.txt".asFileHandle() // -> an instance of RemoteFileHandle
|
|
* ```
|
|
* @export
|
|
* @param {string} proto protocol string
|
|
* @returns {VFSFileHandleClass[]}
|
|
*/
|
|
function findHandles(proto: string): VFSFileHandleClass[];
|
|
/**
|
|
* Abstract prototype of all all VFS file handle definition.
|
|
*
|
|
* This prototype provides a standardized interface to access
|
|
* to different underlay file systems such as remote file,
|
|
* cloud file (Dropbox, Google drive, etc.), URL or memory-based file
|
|
*
|
|
* @export
|
|
* @abstract
|
|
* @class BaseFileHandle
|
|
*/
|
|
abstract class BaseFileHandle {
|
|
/**
|
|
* Flag indicates whether the file is dirty
|
|
*
|
|
* @type {boolean}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
dirty: boolean;
|
|
/**
|
|
* Once read, file content will be cached in this placeholder
|
|
*
|
|
* @private
|
|
* @type {*}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
private _cache;
|
|
/**
|
|
* Flag indicated whether the file meta-data is loaded
|
|
*
|
|
* @type {boolean}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
ready: boolean;
|
|
/**
|
|
* File path
|
|
*
|
|
* @type {string}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
path: string;
|
|
/**
|
|
* File protocol e.g:
|
|
* - `os://`
|
|
* - `home://`
|
|
*
|
|
* @type {string}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protocol: string;
|
|
/**
|
|
* List of path segments
|
|
*
|
|
* @type {string[]}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
genealogy: string[];
|
|
/**
|
|
* File base name
|
|
*
|
|
* @type {string}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
basename: string;
|
|
/**
|
|
* Once loaded, [[ready]] will be set to true and
|
|
* file meta-data will be stored in this place holder
|
|
*
|
|
* @type {FileInfoType}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
info: FileInfoType;
|
|
/**
|
|
* File extension
|
|
*
|
|
* @type {string}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
ext: string;
|
|
/**
|
|
*
|
|
* File type
|
|
* @type {string}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
type: string;
|
|
/**
|
|
*Creates an instance of BaseFileHandle.
|
|
* @param {string} path file path
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
constructor(path: string);
|
|
/**
|
|
* Set a file path to the current file handle
|
|
*
|
|
* @param {string} p
|
|
* @returns {void}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
setPath(p: string): void;
|
|
/**
|
|
* Getter: Get the file basename
|
|
* Setter: set the file name
|
|
*
|
|
* @returns {string}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
get filename(): string;
|
|
set filename(v: string);
|
|
/**
|
|
* Getter: Get the file cache
|
|
* Setter: set the file cache
|
|
*
|
|
* @returns {any}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
get cache(): any;
|
|
set cache(v: any);
|
|
/**
|
|
* Set data to the file cache
|
|
*
|
|
* @param {*} v data object
|
|
* @returns {BaseFileHandle}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
setCache(v: any): BaseFileHandle;
|
|
/**
|
|
* Return the object itself
|
|
*
|
|
* @returns {BaseFileHandle}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
asFileHandle(): BaseFileHandle;
|
|
/**
|
|
* Check whether the current file is the root of the file tree
|
|
*
|
|
* @returns {boolean}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
isRoot(): boolean;
|
|
/**
|
|
* Check whether the current file is a hidden file
|
|
*
|
|
* @returns {boolean}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
isHidden(): boolean;
|
|
/**
|
|
* Get hash number of the current file path
|
|
*
|
|
* @returns {number}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
hash(): number;
|
|
/**
|
|
* Convert the current file cache to Base64
|
|
*
|
|
* @protected
|
|
* @param {string} t type of the file cache:
|
|
* - `object`
|
|
* - `mime type`
|
|
* @returns {(Promise<string | ArrayBuffer>)} promise on the converted data
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected b64(t: string): Promise<string | ArrayBuffer>;
|
|
/**
|
|
* Get the parent file handle of the current file
|
|
*
|
|
* @returns {BaseFileHandle}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
parent(): BaseFileHandle;
|
|
/**
|
|
* Load the file meta-data before performing
|
|
* any task
|
|
*
|
|
* @returns {Promise<FileInfoType>} a promise on file meta-data
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
onready(): Promise<FileInfoType>;
|
|
/**
|
|
* Public read operation
|
|
*
|
|
* This function calls the [[_rd]] function to perform the operation.
|
|
*
|
|
* If the current file is a directory, then the operation
|
|
* will return the meta-data of all files inside of the directory.
|
|
* Otherwise, file content will be returned
|
|
*
|
|
* @param {any} formal t data type
|
|
* - jsonp: the response is an json object
|
|
* - script: the response is a javascript code
|
|
* - xml, html: the response is a XML/HTML object
|
|
* - text: plain text
|
|
* - binary
|
|
* - other user case may be user specific data
|
|
*
|
|
* @returns {Promise<any>} a promise on the file content
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
read(t?: any): Promise<any>;
|
|
/**
|
|
* Write the file cache to the actual file
|
|
*
|
|
* This function calls the [[_wr]] function to perform the operation
|
|
*
|
|
* @param {string} t data type
|
|
* - `base64`
|
|
* - `object`
|
|
* - `mime type`
|
|
*
|
|
* @returns {Promise<RequestResult>} promise on the operation result
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
write(t: string): Promise<RequestResult>;
|
|
/**
|
|
* Sub-directory creation
|
|
*
|
|
* This function calls the [[_mk]] function to perform the operation
|
|
*
|
|
* @param {string} d sub directory name
|
|
* @returns {Promise<RequestResult>} promise on the operation result
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
mk(d: string): Promise<RequestResult>;
|
|
/**
|
|
* Delete the file
|
|
*
|
|
* This function calls the [[_rm]] function to perform the operation
|
|
* @param {any} d user data
|
|
* @returns {Promise<RequestResult>} promise on the operation result
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
remove(data?: any): Promise<RequestResult>;
|
|
/**
|
|
* Upload a file to the current directory
|
|
*
|
|
* Only work when the current file is a directory
|
|
*
|
|
* This function calls the [[_up]] function to perform the operation
|
|
*
|
|
* @returns {Promise<RequestResult>} promise on the operation result
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
upload(): Promise<RequestResult>;
|
|
/**
|
|
* Share the file by publish it.
|
|
*
|
|
* Only work with file
|
|
*
|
|
* This function calls the [[_pub]] function to perform the operation
|
|
*
|
|
* @returns {Promise<RequestResult>} promise on operation result
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
publish(): Promise<RequestResult>;
|
|
/**
|
|
* Download the file.
|
|
*
|
|
* Only work with file
|
|
*
|
|
* This function calls the [[_down]] function to perform the operation
|
|
*
|
|
* @returns {Promise<any>} Promise on the operation result
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
download(): Promise<any>;
|
|
/**
|
|
* Move the current file to another location
|
|
*
|
|
* This function calls the [[_mv]] function to perform the operation
|
|
*
|
|
* @param {string} d destination location
|
|
* @returns {Promise<RequestResult>} promise on the operation result
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
move(d: string): Promise<RequestResult>;
|
|
/**
|
|
* Execute the current file.
|
|
*
|
|
* This action depends on each file protocol
|
|
*
|
|
* This function calls the [[_exec]] function to perform the operation
|
|
*
|
|
* @returns {Promise<any>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
execute(): Promise<any>;
|
|
/**
|
|
* Get an accessible link to the file
|
|
* that can be accessed from the browser
|
|
*
|
|
* @returns {string}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
getlink(): string;
|
|
/**
|
|
* Helper function returns a promise on unsupported action
|
|
*
|
|
* @param {string} t action name
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected unsupported(t: string): Promise<RequestResult>;
|
|
/**
|
|
* trigger cache changed event
|
|
*
|
|
* This function triggered when the file cached changed
|
|
*
|
|
* @protected
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _cache_changed(): void;
|
|
/**
|
|
* Low level protocol-specific read operation
|
|
*
|
|
* This function should be overridden on the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @protected
|
|
* @param {any} t data type, see [[read]]
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _rd(t: any): Promise<RequestResult>;
|
|
/**
|
|
* Low level protocol-specific write operation
|
|
*
|
|
* This function should be overridden by the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @protected
|
|
* @param {string} t data type, see [[write]]
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _wr(t: string): Promise<RequestResult>;
|
|
/**
|
|
* Low level protocol-specific sub-directory creation
|
|
*
|
|
* This function should be overridden by the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @protected
|
|
* @param {string} d sub directory name
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _mk(d: string): Promise<RequestResult>;
|
|
/**
|
|
* Low level protocol-specific delete operation
|
|
*
|
|
* This function should be overridden by the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @param {*} [d] any user data
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _rm(d: any): Promise<RequestResult>;
|
|
/**
|
|
* Low level protocol-specific move operation
|
|
*
|
|
* This function should be overridden by the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @protected
|
|
* @param {string} d
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _mv(d: string): Promise<RequestResult>;
|
|
/**
|
|
* Low level protocol-specific upload operation
|
|
*
|
|
* This function should be overridden by the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _up(): Promise<RequestResult>;
|
|
/**
|
|
* Low level protocol-specific download operation
|
|
*
|
|
* This function should be overridden by the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @returns {Promise<any>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _down(): Promise<any>;
|
|
/**
|
|
* Low level protocol-specific execute operation
|
|
*
|
|
* This function should be overridden by the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _exec(): Promise<RequestResult>;
|
|
/**
|
|
* Low level protocol-specific share operation
|
|
*
|
|
* This function should be overridden by the file handle class
|
|
* that supports the operation
|
|
*
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
protected _pub(): Promise<RequestResult>;
|
|
/**
|
|
* Read the current file meta-data
|
|
*
|
|
* should be implemented by subclasses
|
|
*
|
|
* @abstract
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BaseFileHandle
|
|
*/
|
|
abstract meta(): Promise<RequestResult>;
|
|
}
|
|
/**
|
|
* Remote file handle allows to perform file operation
|
|
* on AntOS remote server files. Its protocol is defined
|
|
* by the following pattern:
|
|
*
|
|
* ```
|
|
* ^(home|desktop|os|Untitled)$
|
|
* ```
|
|
*
|
|
* @class RemoteFileHandle
|
|
* @extends {BaseFileHandle}
|
|
*/
|
|
class RemoteFileHandle extends BaseFileHandle {
|
|
/**
|
|
*Creates an instance of RemoteFileHandle.
|
|
* @param {string} path file path
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
constructor(path: string);
|
|
/**
|
|
* Read remote file meta-data
|
|
*
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
meta(): Promise<RequestResult>;
|
|
/**
|
|
* Remote file access link
|
|
*
|
|
* @returns {string}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
getlink(): string;
|
|
/**
|
|
* Read remote file content.
|
|
*
|
|
* If the current file is a directory, then the operation
|
|
* will return the meta-data of all files inside of the directory.
|
|
* Otherwise, file content will be returned
|
|
*
|
|
* @protected
|
|
* @param {string} t data type see [[read]]
|
|
* @returns {Promise<any>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
protected _rd(t: string): Promise<any>;
|
|
/**
|
|
* Write file cache to the remote file
|
|
*
|
|
* @protected
|
|
* @param {string} t data type see [[write]]
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
protected _wr(t: string): Promise<RequestResult>;
|
|
/**
|
|
* Create sub directory
|
|
*
|
|
* Only work on directory file handle
|
|
*
|
|
* @protected
|
|
* @param {string} d sub directory name
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
protected _mk(d: string): Promise<RequestResult>;
|
|
/**
|
|
* Delete file/folder
|
|
*
|
|
* @protected
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
protected _rm(): Promise<RequestResult>;
|
|
/**
|
|
* Move file/folder
|
|
*
|
|
* @protected
|
|
* @param {string} d
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
protected _mv(d: string): Promise<RequestResult>;
|
|
/**
|
|
* Upload a file
|
|
*
|
|
* Only work with directory file handle
|
|
*
|
|
* @protected
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
protected _up(): Promise<RequestResult>;
|
|
/**
|
|
* Download a file
|
|
*
|
|
* only work with file
|
|
*
|
|
* @protected
|
|
* @returns {Promise<void>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
protected _down(): Promise<void>;
|
|
/**
|
|
* Publish a file
|
|
*
|
|
* @protected
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof RemoteFileHandle
|
|
*/
|
|
protected _pub(): Promise<RequestResult>;
|
|
}
|
|
/**
|
|
* Package file is remote file ([[RemoteFileHandle]]) located either in
|
|
* the local user packages location or system packages
|
|
* location, it should be in the following format:
|
|
*
|
|
* ```
|
|
* pkg://PKG_NAME/path/to/file
|
|
*
|
|
* ```
|
|
*
|
|
* The system will locale the package name PKG_NAME either in the system domain
|
|
* or in user domain and return the correct path to the package
|
|
*
|
|
* @export
|
|
* @class PackageFileHandle
|
|
* @extends {RemoteFileHandle}
|
|
*/
|
|
class PackageFileHandle extends RemoteFileHandle {
|
|
/**
|
|
*Creates an instance of PackageFileHandle.
|
|
* @param {string} pkg_path package path in string
|
|
* @memberof PackageFileHandle
|
|
*/
|
|
constructor(pkg_path: string);
|
|
}
|
|
/**
|
|
* Application file is an AntOS special file allowing to
|
|
* refer to an application as a regular file. Its protocol
|
|
* pattern is defined as:
|
|
*
|
|
* ```typescript
|
|
* "^app$" // e.g. app://Setting
|
|
* ```
|
|
*
|
|
* @class ApplicationHandle
|
|
* @extends {BaseFileHandle}
|
|
*/
|
|
class ApplicationHandle extends BaseFileHandle {
|
|
/**
|
|
*Creates an instance of ApplicationHandle.
|
|
* @param {string} path file path
|
|
* @memberof ApplicationHandle
|
|
*/
|
|
constructor(path: string);
|
|
/**
|
|
* Read application meta-data
|
|
*
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof ApplicationHandle
|
|
*/
|
|
meta(): Promise<RequestResult>;
|
|
/**
|
|
* If the current file is root (e.g. `app://`), the operation
|
|
* will return all system packages meta-data.
|
|
*
|
|
* Otherwise, an error will be thrown
|
|
*
|
|
* @protected
|
|
* @param {string} t
|
|
* @returns {Promise<any>}
|
|
* @memberof ApplicationHandle
|
|
*/
|
|
protected _rd(t: string): Promise<any>;
|
|
}
|
|
/**
|
|
* A buffer file handle represents a virtual file that is stored
|
|
* on the system memory. Its protocol pattern is defined as:
|
|
*
|
|
* ```typescript
|
|
* "^mem$" // e.g. mem://test.txt
|
|
* ```
|
|
*
|
|
* @class BufferFileHandle
|
|
* @extends {BaseFileHandle}
|
|
*/
|
|
class BufferFileHandle extends BaseFileHandle {
|
|
/**
|
|
*Creates an instance of BufferFileHandle.
|
|
* @param {string} path file path
|
|
* @param {string} mime file mime-type
|
|
* @param {*} data file data
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
constructor(path: string, mime: string, data: any);
|
|
/**
|
|
* init the mem file tree if necessary
|
|
*/
|
|
private init_file_tree;
|
|
/**
|
|
* cache changed handle
|
|
*/
|
|
protected _cache_changed(): void;
|
|
/**
|
|
* Read the file meta-data
|
|
*
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
meta(): Promise<RequestResult>;
|
|
/**
|
|
* Load the file meta-data before performing
|
|
* any task
|
|
*
|
|
* @returns {Promise<FileInfoType>} a promise on file meta-data
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
onready(): Promise<FileInfoType>;
|
|
/**
|
|
* Read file content stored in the file cached
|
|
*
|
|
* @protected
|
|
* @param {string} t data type see [[read]]
|
|
* @returns {Promise<any>}
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
protected _rd(t: string): Promise<any>;
|
|
/**
|
|
* Write data to the file cache
|
|
*
|
|
* @protected
|
|
* @param {string} t data type, see [[write]]
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
protected _wr(t: string): Promise<RequestResult>;
|
|
/**
|
|
* Create sub directory
|
|
*
|
|
* Only work on directory file handle
|
|
*
|
|
* @protected
|
|
* @param {string} d sub directory name
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
protected _mk(d: string): Promise<RequestResult>;
|
|
/**
|
|
* Delete file/folder
|
|
*
|
|
* @protected
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
protected _rm(): Promise<RequestResult>;
|
|
setPath(p: string): void;
|
|
private updatePath;
|
|
/**
|
|
* Move file/folder
|
|
*
|
|
* @protected
|
|
* @param {string} d
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
protected _mv(d: string): Promise<RequestResult>;
|
|
/**
|
|
* Download the buffer file
|
|
*
|
|
* @protected
|
|
* @returns {Promise<void>}
|
|
* @memberof BufferFileHandle
|
|
*/
|
|
protected _down(): Promise<void>;
|
|
}
|
|
/**
|
|
* URL file handle represents a HTTP/HTTPs link url
|
|
* as an AntOS VFS file handle. Its protocol is defined as
|
|
*
|
|
* ```
|
|
* ^(http|https|ftp)$
|
|
* ```
|
|
*
|
|
* @class URLFileHandle
|
|
* @extends {BaseFileHandle}
|
|
*/
|
|
class URLFileHandle extends BaseFileHandle {
|
|
/**
|
|
*Creates an instance of URLFileHandle.
|
|
* @param {string} path
|
|
* @memberof URLFileHandle
|
|
*/
|
|
constructor(path: string);
|
|
/**
|
|
* Read file meta-data
|
|
*
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof URLFileHandle
|
|
*/
|
|
meta(): Promise<RequestResult>;
|
|
/**
|
|
* Read URL content
|
|
*
|
|
* @protected
|
|
* @param {string} t data type see [[read]]
|
|
* @returns {Promise<any>}
|
|
* @memberof URLFileHandle
|
|
*/
|
|
protected _rd(t: string): Promise<any>;
|
|
}
|
|
/**
|
|
* Shared file handle represents all AntOS shared file.
|
|
* Its protocol is defined as:
|
|
*
|
|
* ```
|
|
* ^shared$
|
|
* ```
|
|
*
|
|
* @class SharedFileHandle
|
|
* @extends {API.VFS.BaseFileHandle}
|
|
*/
|
|
class SharedFileHandle extends API.VFS.BaseFileHandle {
|
|
/**
|
|
*Creates an instance of SharedFileHandle.
|
|
* @param {string} path file path
|
|
* @memberof SharedFileHandle
|
|
*/
|
|
constructor(path: string);
|
|
/**
|
|
* Read file meta-data
|
|
*
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof SharedFileHandle
|
|
*/
|
|
meta(): Promise<RequestResult>;
|
|
/**
|
|
* Read file content
|
|
*
|
|
* @protected
|
|
* @param {string} t data type, see [[read]]
|
|
* @returns {Promise<any>}
|
|
* @memberof SharedFileHandle
|
|
*/
|
|
protected _rd(t: string): Promise<any>;
|
|
/**
|
|
* write data to shared file
|
|
*
|
|
* @protected
|
|
* @param {string} t data type, see [[write]]
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof SharedFileHandle
|
|
*/
|
|
protected _wr(t: string): Promise<RequestResult>;
|
|
/**
|
|
* Un-publish the file
|
|
*
|
|
* @protected
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof SharedFileHandle
|
|
*/
|
|
protected _rm(): Promise<RequestResult>;
|
|
/**
|
|
* Download shared file
|
|
*
|
|
* @protected
|
|
* @returns {Promise<void>}
|
|
* @memberof SharedFileHandle
|
|
*/
|
|
protected _down(): Promise<void>;
|
|
/**
|
|
* Un publish the file
|
|
*
|
|
* @protected
|
|
* @returns {Promise<RequestResult>}
|
|
* @memberof SharedFileHandle
|
|
*/
|
|
protected _pub(): Promise<RequestResult>;
|
|
}
|
|
/**Utilities global functions */
|
|
/**
|
|
* Read a file content from a zip archive
|
|
*
|
|
* The content type should be:
|
|
* - base64 : the result will be a string, the binary in a base64 form.
|
|
* - text (or string): the result will be an unicode string.
|
|
* - binarystring: the result will be a string in “binary” form, using 1 byte per char (2 bytes).
|
|
* - array: the result will be an Array of bytes (numbers between 0 and 255).
|
|
* - uint8array : the result will be a Uint8Array. This requires a compatible browser.
|
|
* - arraybuffer : the result will be a ArrayBuffer. This requires a compatible browser.
|
|
* - blob : the result will be a Blob. This requires a compatible browser. *
|
|
* If file_name is not specified, the first file_name in the zip archive will be read
|
|
* @export
|
|
* @param {string} file zip file
|
|
* @param {string} type content type to read
|
|
* @param {string} [file_name] the file should be read from the zip archive
|
|
* @return {*} {Promise<any>}
|
|
*/
|
|
function readFileFromZip(file: string, type: string, file_name?: string): Promise<any>;
|
|
/**
|
|
* Cat all files to a single out-put
|
|
*
|
|
* @export
|
|
* @param {string[]} list list of VFS files
|
|
* @param {string} data input data string that will be cat to the files content
|
|
* @param {string} join_by join on files content by this string
|
|
* @return {*} {Promise<string>}
|
|
*/
|
|
function cat(list: string[], data: string, join_by?: string): Promise<string>;
|
|
/**
|
|
* Read all files content on the list
|
|
*
|
|
* @export
|
|
* @param {string[]} list list of VFS files
|
|
* @param {GenericObject<string>[]} contents content array
|
|
* @return {void}
|
|
*/
|
|
function read_files(list: string[]): Promise<GenericObject<string>[]>;
|
|
/**
|
|
* Copy files to a folder
|
|
*
|
|
* @export
|
|
* @param {string[]} files list of files
|
|
* @param {string} to destination folder
|
|
* @return {*} {Promise<any[]>}
|
|
*/
|
|
function copy(files: string[], to: string): Promise<any[]>;
|
|
/**
|
|
* Create a zip archive from a folder
|
|
*
|
|
* @export
|
|
* @param {string} src source file/folder
|
|
* @param {string} dest destination archive
|
|
* @return {*} {Promise<void>}
|
|
*/
|
|
function mkar(src: string, dest: string): Promise<void>;
|
|
/**
|
|
* Create a list of directories
|
|
*
|
|
* @export
|
|
* @param {string[]} list of directories to be created
|
|
* @param {boolen} sync sync/async of directory creation
|
|
* @return {*} {Promise<any>}
|
|
*/
|
|
function mkdirAll(list: string[], sync?: boolean): Promise<any>;
|
|
/**
|
|
*
|
|
*
|
|
* @export Extract a zip fle
|
|
* @param {string} zfile zip file to extract
|
|
* @param {(zip:any) => Promise<string>} [dest_callback] a callback to get extraction destination
|
|
* @return {*} {Promise<void>}
|
|
*/
|
|
function extractZip(zfile: string | API.VFS.BaseFileHandle, dest_callback: (zip: any) => Promise<string>): Promise<void>;
|
|
/**
|
|
* Make files from a set of template files
|
|
*
|
|
* @export
|
|
* @param {Array<string[]>} list mapping paths between templates files and created files
|
|
* @param {string} path files destination
|
|
* @param {(data: string) => string} callback: pre-processing files content before writing to destination files
|
|
* @return {*} {Promise<any[]>}
|
|
*/
|
|
function mktpl(list: Array<string[]>, path: string, callback: (data: string) => string): Promise<any[]>;
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
/**
|
|
* This namespace is dedicated to everything related to the
|
|
* global system settings
|
|
*/
|
|
namespace setting {
|
|
/**
|
|
* User setting type definition
|
|
*
|
|
* @export
|
|
* @interface UserSettingType
|
|
*/
|
|
interface UserSettingType {
|
|
/**
|
|
* User full name
|
|
*
|
|
* @type {string}
|
|
* @memberof UserSettingType
|
|
*/
|
|
name: string;
|
|
/**
|
|
* User name
|
|
*
|
|
* @type {string}
|
|
* @memberof UserSettingType
|
|
*/
|
|
username: string;
|
|
/**
|
|
* User id
|
|
*
|
|
* @type {number}
|
|
* @memberof UserSettingType
|
|
*/
|
|
id: number;
|
|
/**
|
|
* User groups
|
|
*
|
|
* @type {{ [index: number]: string }}
|
|
* @memberof UserSettingType
|
|
*/
|
|
group?: {
|
|
[index: number]: string;
|
|
};
|
|
[propName: string]: any;
|
|
}
|
|
/**
|
|
* Virtual desktop setting data type
|
|
*
|
|
* @export
|
|
* @interface DesktopSettingType
|
|
*/
|
|
interface DesktopSettingType {
|
|
/**
|
|
* Desktop VFS path
|
|
*
|
|
* @type {string}
|
|
* @memberof DesktopSettingType
|
|
*/
|
|
path: string;
|
|
/**
|
|
* Desktop menu, can be added automatically by applications
|
|
*
|
|
* @type {GUI.BasicItemType[]}
|
|
* @memberof DesktopSettingType
|
|
*/
|
|
menu: GUI.BasicItemType[];
|
|
/**
|
|
* Show desktop hidden files
|
|
*
|
|
* @type {boolean}
|
|
* @memberof DesktopSettingType
|
|
*/
|
|
showhidden: boolean;
|
|
[propName: string]: any;
|
|
}
|
|
/**
|
|
* Wallpaper setting data type
|
|
*
|
|
* @export
|
|
* @interface WPSettingType
|
|
*/
|
|
interface WPSettingType {
|
|
/**
|
|
* Repeat wallpaper:
|
|
* - `repeat`
|
|
* - `repeat-x`
|
|
* - `repeat-y`
|
|
* - `no-repeat`
|
|
*
|
|
* @type {string}
|
|
* @memberof WPSettingType
|
|
*/
|
|
repeat: string;
|
|
/**
|
|
* Wallpaper size
|
|
* - `contain`
|
|
* - `cover`
|
|
* - `auto`
|
|
*
|
|
* @type {string}
|
|
* @memberof WPSettingType
|
|
*/
|
|
size: string;
|
|
/**
|
|
* VFS path to the wallpaper image
|
|
*
|
|
* @type {string}
|
|
* @memberof WPSettingType
|
|
*/
|
|
url: string;
|
|
}
|
|
/**
|
|
* Theme setting data type
|
|
*
|
|
* @export
|
|
* @interface ThemeSettingType
|
|
*/
|
|
interface ThemeSettingType {
|
|
/**
|
|
* Theme name, this value is used for looking
|
|
* theme file in system asset
|
|
*
|
|
* @type {string}
|
|
* @memberof ThemeSettingType
|
|
*/
|
|
name: string;
|
|
/**
|
|
* Theme user-friendly text
|
|
*
|
|
* @type {string}
|
|
* @memberof ThemeSettingType
|
|
*/
|
|
text: string;
|
|
}
|
|
/**
|
|
* Appearance setting data type
|
|
*
|
|
* @export
|
|
* @interface AppearanceSettingType
|
|
*/
|
|
interface AppearanceSettingType {
|
|
/**
|
|
* Current theme name
|
|
*
|
|
* @type {string}
|
|
* @memberof AppearanceSettingType
|
|
*/
|
|
theme: string;
|
|
/**
|
|
* All themes available in the system
|
|
*
|
|
* @type {ThemeSettingType[]}
|
|
* @memberof AppearanceSettingType
|
|
*/
|
|
themes: ThemeSettingType[];
|
|
/**
|
|
* Current wallpaper setting
|
|
*
|
|
* @type {WPSettingType}
|
|
* @memberof AppearanceSettingType
|
|
*/
|
|
wp: WPSettingType;
|
|
/**
|
|
* All wallpapers available in the system
|
|
*
|
|
* @type {string[]}
|
|
* @memberof AppearanceSettingType
|
|
*/
|
|
wps: string[];
|
|
}
|
|
/**
|
|
* VFS Mount points setting data type
|
|
*
|
|
* @export
|
|
* @interface VFSMountPointSettingType
|
|
*/
|
|
interface VFSMountPointSettingType {
|
|
/**
|
|
* Path to the mount point
|
|
*
|
|
* @type {string}
|
|
* @memberof VFSMountPointSettingType
|
|
*/
|
|
path: string;
|
|
/**
|
|
* User friendly mount point name
|
|
*
|
|
* @type {string}
|
|
* @memberof VFSMountPointSettingType
|
|
*/
|
|
text: string;
|
|
[propName: string]: any;
|
|
}
|
|
/**
|
|
* VFS setting data type
|
|
*
|
|
* @export
|
|
* @interface VFSSettingType
|
|
*/
|
|
interface VFSSettingType {
|
|
/**
|
|
* mount points setting
|
|
*
|
|
* @type {VFSMountPointSettingType[]}
|
|
* @memberof VFSSettingType
|
|
*/
|
|
mountpoints: VFSMountPointSettingType[];
|
|
[propName: string]: any;
|
|
}
|
|
/**
|
|
* Global system setting data type
|
|
*
|
|
* @export
|
|
* @interface SystemSettingType
|
|
*/
|
|
interface SystemSettingType {
|
|
/**
|
|
* System error report URL
|
|
*
|
|
* @type {string}
|
|
* @memberof SystemSettingType
|
|
*/
|
|
error_report: string;
|
|
/**
|
|
* Current system locale e.g. `en_GB`
|
|
*
|
|
* @type {string}
|
|
* @memberof SystemSettingType
|
|
*/
|
|
locale: string;
|
|
/**
|
|
* System menus
|
|
*
|
|
* @type {API.PackageMetaType[]}
|
|
* @memberof API.PackageMetaType
|
|
*/
|
|
menu: API.PackageMetaType[];
|
|
/**
|
|
* Packages meta-data
|
|
*
|
|
* @type {{ [index: string]: API.PackageMetaType }}
|
|
* @memberof SystemSettingType
|
|
*/
|
|
packages: {
|
|
[index: string]: API.PackageMetaType;
|
|
};
|
|
/**
|
|
* Path to the installed packages
|
|
*
|
|
* @type {{
|
|
* user: string;
|
|
* system: string;
|
|
* }}
|
|
* @memberof SystemSettingType
|
|
*/
|
|
pkgpaths: {
|
|
/**
|
|
* User specific packages install location
|
|
*
|
|
* @type {string}
|
|
*/
|
|
user: string;
|
|
/**
|
|
* System packages install location
|
|
*
|
|
* @type {string}
|
|
*/
|
|
system: string;
|
|
};
|
|
/**
|
|
* Package repositories setting.
|
|
* This configuration is used by [[MarketPlace]]
|
|
* for package management
|
|
*
|
|
* @type {{
|
|
* text: string;
|
|
* url: string;
|
|
* }[]}
|
|
* @memberof SystemSettingType
|
|
*/
|
|
repositories: {
|
|
/**
|
|
* Repository name
|
|
*
|
|
* @type {string}
|
|
*/
|
|
text: string;
|
|
/**
|
|
* Repository uri
|
|
*
|
|
* @type {string}
|
|
*/
|
|
url: string;
|
|
}[];
|
|
/**
|
|
* Startup applications and services
|
|
*
|
|
* @type {{
|
|
* apps: string[];
|
|
* services: string[];
|
|
* }}
|
|
* @memberof SystemSettingType
|
|
*/
|
|
startup: {
|
|
/**
|
|
* List of application names
|
|
*
|
|
* @type {string[]}
|
|
*/
|
|
apps: string[];
|
|
/**
|
|
* List of service names
|
|
*
|
|
* @type {string[]}
|
|
*/
|
|
services: string[];
|
|
/**
|
|
* List of pinned applications
|
|
*
|
|
* @type {string[]}
|
|
*/
|
|
pinned: string[];
|
|
};
|
|
}
|
|
/**
|
|
* User settings
|
|
*/
|
|
var user: UserSettingType;
|
|
/**
|
|
* Application settings
|
|
*/
|
|
var applications: GenericObject<any>;
|
|
/**
|
|
* Desktop settings
|
|
*/
|
|
var desktop: DesktopSettingType;
|
|
/**
|
|
* Appearance settings
|
|
*/
|
|
var appearance: AppearanceSettingType;
|
|
/**
|
|
* VFS settings
|
|
*/
|
|
var VFS: VFSSettingType;
|
|
/**
|
|
* System settings
|
|
*/
|
|
var system: SystemSettingType;
|
|
}
|
|
/**
|
|
* Reset the system settings to default values
|
|
*
|
|
* @export
|
|
*/
|
|
function resetSetting(): void;
|
|
/**
|
|
* Apply the input parameter object to system settings.
|
|
* This object could be an object loaded from
|
|
* setting JSON file saved on the server.
|
|
*
|
|
* @export
|
|
* @param {*} conf
|
|
*/
|
|
function systemSetting(conf: any): void;
|
|
}
|
|
/// <reference types="jquery" />
|
|
declare namespace OS {
|
|
namespace application {
|
|
/**
|
|
* Services are processes that run in the background and
|
|
* are waken up in certain circumstances such as by global
|
|
* events or user interactions.
|
|
*
|
|
* Each service takes an entry in the system tray menu
|
|
* located on the system panel. This menu entry is used
|
|
* to access to service visual contents such as: options,
|
|
* task performing based on user interaction, etc.
|
|
*
|
|
* Services are singleton processes, there is only
|
|
* one process of a service at a time
|
|
*
|
|
* @export
|
|
* @abstract
|
|
* @class BaseService
|
|
* @extends {BaseModel}
|
|
*/
|
|
abstract class BaseService extends BaseModel {
|
|
/**
|
|
* The service icon shown in the system tray
|
|
*
|
|
* @type {string}
|
|
* @memberof BaseService
|
|
*/
|
|
icon: string;
|
|
/**
|
|
* CSS class of the service icon shown in the system tray
|
|
*
|
|
* @type {string}
|
|
* @memberof BaseService
|
|
*/
|
|
iconclass: string;
|
|
/**
|
|
* Text of the service shown in the system tray
|
|
*
|
|
* @type {string | 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 [[watch]].
|
|
*
|
|
* @private
|
|
* @type {number}
|
|
* @memberof BaseService
|
|
*/
|
|
private timer;
|
|
/**
|
|
* Placeholder for service select callback
|
|
*
|
|
* @memberof BaseService
|
|
*/
|
|
onmenuselect: (d: OS.GUI.TagEventType<GUI.tag.MenuEventData>) => 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<HTMLElement>;
|
|
/**
|
|
* 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<GUI.tag.MenuEventData>): void;
|
|
/**
|
|
* Do nothing
|
|
*
|
|
* @protected
|
|
* @param {BaseEvent} evt
|
|
* @memberof BaseService
|
|
*/
|
|
protected cleanup(evt: BaseEvent): void;
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
namespace API {
|
|
/**
|
|
* Data type exchanged via
|
|
* the global Announcement interface
|
|
*
|
|
* @export
|
|
* @interface AnnouncementDataType
|
|
*/
|
|
interface AnnouncementDataType<T> {
|
|
/**
|
|
* message string
|
|
*
|
|
* @type {string| FormattedString}
|
|
* @memberof AppAnnouncementDataType
|
|
*/
|
|
message: string | FormattedString;
|
|
/**
|
|
* Process ID
|
|
*
|
|
* @type {number}
|
|
* @memberof AppAnnouncementDataType
|
|
*/
|
|
id: number;
|
|
/**
|
|
* App name
|
|
*
|
|
* @type {string | FormattedString}
|
|
* @memberof AppAnnouncementDataType
|
|
*/
|
|
name: string | FormattedString;
|
|
/**
|
|
* Icon file
|
|
*
|
|
* @type {string}
|
|
* @memberof AppAnnouncementDataType
|
|
*/
|
|
icon?: string;
|
|
/**
|
|
* App icon class
|
|
*
|
|
* @type {string}
|
|
* @memberof AppAnnouncementDataType
|
|
*/
|
|
iconclass?: string;
|
|
/**
|
|
* User specific data
|
|
*
|
|
* @type {*}
|
|
* @memberof AppAnnouncementDataType
|
|
*/
|
|
u_data?: T;
|
|
}
|
|
/**
|
|
* Observable entry type definition
|
|
*
|
|
* @export
|
|
* @interface ObservableEntryType
|
|
*/
|
|
interface ObservableEntryType {
|
|
/**
|
|
* A Set of callbacks that should be called only once.
|
|
* These callbacks will be removed after the first
|
|
* occurrence of the corresponding event
|
|
*
|
|
* @memberof ObservableEntryType
|
|
*/
|
|
one: Set<(d: any) => void>;
|
|
/**
|
|
* A Set of callbacks that should be called
|
|
* every time the corresponding event is triggered
|
|
*
|
|
* @memberof ObservableEntryType
|
|
*/
|
|
many: Set<(d: any) => void>;
|
|
}
|
|
/**
|
|
* Announcement listener type definition
|
|
*
|
|
* @export
|
|
* @interface AnnouncerListenerType
|
|
*/
|
|
interface AnnouncerListenerType {
|
|
/**
|
|
* The event name
|
|
*
|
|
* @type {string}
|
|
*/
|
|
e: string;
|
|
/**
|
|
* The event callback
|
|
*
|
|
*/
|
|
f: (d: any) => void;
|
|
}
|
|
/**
|
|
* This class is the based class used in AntOS event
|
|
* announcement system.
|
|
* It implements the observer pattern using simple
|
|
* subscribe/publish mechanism
|
|
* @export
|
|
* @class Announcer
|
|
*/
|
|
class Announcer {
|
|
/**
|
|
* The observable object that stores event name
|
|
* and its corresponding callback in [[ObservableEntryType]]
|
|
*
|
|
* @type {GenericObject<ObservableEntryType>}
|
|
* @memberof Announcer
|
|
*/
|
|
observable: GenericObject<ObservableEntryType>;
|
|
/**
|
|
* Enable/disable the announcer
|
|
*
|
|
* @type {boolean}
|
|
* @memberof Announcer
|
|
*/
|
|
enable: boolean;
|
|
/**
|
|
*Creates an instance of Announcer.
|
|
* @memberof Announcer
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Disable the announcer, when this function is called
|
|
* all events and their callbacks will be removed
|
|
*
|
|
* @returns
|
|
* @memberof Announcer
|
|
*/
|
|
disable(): boolean;
|
|
/**
|
|
* Subscribe to an event, the callback will be called
|
|
* every time the corresponding event is trigged
|
|
*
|
|
* @param {string} evtName event name
|
|
* @param {(d: any) => void} callback The corresponding callback
|
|
* @returns {void}
|
|
* @memberof Announcer
|
|
*/
|
|
on(evtName: string, callback: (d: any) => void): void;
|
|
/**
|
|
* Subscribe to an event, the callback will
|
|
* be called only once and then removed from the announcer
|
|
*
|
|
* @param {string} evtName event name
|
|
* @param {(d: any) => void} callback the corresponding callback
|
|
* @returns {void}
|
|
* @memberof Announcer
|
|
*/
|
|
one(evtName: string, callback: (d: any) => void): void;
|
|
/**
|
|
* Unsubscribe the callback from an event
|
|
*
|
|
* @param {string} evtName event name
|
|
* @param {(d: any) => void} [callback] the callback to be unsubscribed.
|
|
* When the `callback` is `*`, all callbacks related to `evtName` will be
|
|
* removed
|
|
* @memberof Announcer
|
|
*/
|
|
off(evtName: string, callback?: (d: any) => void): void;
|
|
/**
|
|
* Trigger an event
|
|
*
|
|
* @param {string} evtName event name
|
|
* @param {*} data data object that will be send to all related callback
|
|
* @returns {void}
|
|
* @memberof Announcer
|
|
*/
|
|
trigger(evtName: string, data: any): void;
|
|
}
|
|
}
|
|
/**
|
|
* This namespace defines every thing related to the system announcement.
|
|
*
|
|
* The system announcement provides a global way to communicate between
|
|
* processes (applications/services) using the subscribe/publish
|
|
* mechanism
|
|
*/
|
|
namespace announcer {
|
|
/**
|
|
* The global announcer object that manages global events
|
|
* and callbacks
|
|
*/
|
|
var observable: API.Announcer;
|
|
/**
|
|
* This variable is used to allocate the `id` of all messages
|
|
* passing between publishers and subscribers in the
|
|
* system announcement
|
|
*/
|
|
var quota: 0;
|
|
/**
|
|
* Placeholder of all global events listeners
|
|
*/
|
|
var listeners: Map<BaseModel | 0, API.AnnouncerListenerType[]>;
|
|
/**
|
|
* Subscribe to a global event
|
|
*
|
|
* @export
|
|
* @param {string} e event name
|
|
* @param {(d: API.AnnouncementDataType<any>) => void} f event callback
|
|
* @param {GUI.BaseModel} a the process (Application/service) related to the callback
|
|
*/
|
|
function on(e: string, f: (d: API.AnnouncementDataType<any>) => void, a?: BaseModel): void;
|
|
/**
|
|
* Subscribe to a global event once
|
|
*
|
|
* @export
|
|
* @param {string} e event name
|
|
* @param {(d: API.AnnouncementDataType<any>) => void} f event callback
|
|
*/
|
|
function one(e: string, f: (d: API.AnnouncementDataType<any>) => void): void;
|
|
/**
|
|
* Trigger a global event
|
|
*
|
|
* @export
|
|
* @param {string} e event name
|
|
* @param {*} d data passing to all related callback
|
|
*/
|
|
function trigger(e: string, d: any): void;
|
|
/**
|
|
* Report system fail. This will trigger the global `fail`
|
|
* event
|
|
*
|
|
* @export
|
|
* @param {(string | FormattedString)} m message string
|
|
* @param {Error} e error to be reported
|
|
*/
|
|
function osfail(m: string | FormattedString, e: Error): void;
|
|
/**
|
|
* Report system error. This will trigger the global `error`
|
|
* event
|
|
*
|
|
* @export
|
|
* @param {(string | FormattedString)} m message string
|
|
* @param {Error} e error to be reported
|
|
*/
|
|
function oserror(m: string | FormattedString, e: Error): void;
|
|
/**
|
|
* Trigger system notification (`info` event)
|
|
*
|
|
* @export
|
|
* @param {(string | FormattedString)} m notification message
|
|
*/
|
|
function osinfo(m: string | FormattedString): void;
|
|
/**
|
|
*
|
|
*
|
|
* @export
|
|
* @param {string} e event name
|
|
* @param {(string| FormattedString)} m event message
|
|
* @param {*} [d] user data
|
|
*/
|
|
function ostrigger(e: string, m: string | FormattedString, d?: any): void;
|
|
/**
|
|
* Unregister a process (application/service) from
|
|
* the global announcement system
|
|
*
|
|
* @export
|
|
* @param {GUI.BaseModel} app reference to the process
|
|
* @returns {void}
|
|
*/
|
|
function unregister(app: BaseModel): void;
|
|
/**
|
|
* Allocate message id
|
|
*
|
|
* @export
|
|
* @returns {number}
|
|
*/
|
|
function getMID(): number;
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
namespace API {
|
|
/**
|
|
* Simple Virtual Database (VDB) application API.
|
|
*
|
|
* This API abstracts and provides a standard way to
|
|
* connect to a server-side relational database (e.g. sqlite).
|
|
*
|
|
* Each user when connected has their own database previously
|
|
* created. All VDB operations related to that user will be
|
|
* performed on this database.
|
|
*
|
|
* The creation of user database need to be managed by the server-side API.
|
|
* The VDB API assumes that the database already exist. All operations
|
|
* is performed in tables level
|
|
*
|
|
* @export
|
|
* @class DB
|
|
*/
|
|
class DB {
|
|
/**
|
|
* A table name on the user's database
|
|
*
|
|
* @private
|
|
* @type {string}
|
|
* @memberof DB
|
|
*/
|
|
private table;
|
|
/**
|
|
*Creates an instance of DB.
|
|
* @param {string} table table name
|
|
* @memberof DB
|
|
*/
|
|
constructor(table: string);
|
|
/**
|
|
* Save data to the current table. The input
|
|
* data must conform to the table record format.
|
|
*
|
|
* On the server side, if the table doest not
|
|
* exist yet, it should be created automatically
|
|
* by inferring the data structure of the input
|
|
* object
|
|
*
|
|
* @param {GenericObject<any>} d data object represents a current table record
|
|
* @returns {Promise<API.RequestResult>}
|
|
* @memberof DB
|
|
*/
|
|
save(d: GenericObject<any>): Promise<API.RequestResult>;
|
|
/**
|
|
* delete record(s) from the current table by
|
|
* a conditional object
|
|
*
|
|
* @param {*} c conditional object, c can be:
|
|
*
|
|
* * a `number`: the operation will delete the record with `id = c`
|
|
* * a `string`: The SQL string condition that selects record to delete
|
|
* * a conditional object represents a SQL condition statement as an object,
|
|
* example: `pid = 10 AND cid = 2` is represented by:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* exp: {
|
|
* "and": {
|
|
* pid: 10,
|
|
* cid: 2
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* @returns {Promise<API.RequestResult>}
|
|
* @memberof DB
|
|
*/
|
|
delete(c: GenericObject<any> | number | string): Promise<API.RequestResult>;
|
|
/**
|
|
* Get a record in the table by its primary key
|
|
*
|
|
* @param {number} id the primary key value
|
|
* @returns {Promise<GenericObject<any>>} Promise on returned record data
|
|
* @memberof DB
|
|
*/
|
|
get(id: number): Promise<GenericObject<any>>;
|
|
/**
|
|
* Find records by a condition
|
|
*
|
|
* @param {GenericObject<any>} cond conditional object
|
|
*
|
|
* a conditional object represents a SQL condition statement as an object,
|
|
* example: `pid = 10 AND cid = 2 ORDER BY date DESC` is represented by:
|
|
*
|
|
* ```typescript
|
|
* {
|
|
* exp: {
|
|
* "and": {
|
|
* pid: 10,
|
|
* cid: 2
|
|
* }
|
|
* },
|
|
* order: {
|
|
* date: "DESC"
|
|
* }
|
|
* }
|
|
* ```
|
|
* @returns {Promise<GenericObject<any>[]>}
|
|
* @memberof DB
|
|
*/
|
|
find(cond: GenericObject<any>): Promise<GenericObject<any>[]>;
|
|
}
|
|
}
|
|
}
|
|
declare namespace OS {
|
|
/**
|
|
* This namespace dedicated to all operations related to system
|
|
* process management
|
|
*/
|
|
namespace PM {
|
|
/**
|
|
* A process is either an instance of an application or a service
|
|
*/
|
|
type ProcessType = application.BaseApplication | application.BaseService;
|
|
/**
|
|
* Alias to all classes that extends [[BaseModel]]
|
|
*/
|
|
type ModelTypeClass = {
|
|
new <T extends BaseModel>(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<BaseModel[]>;
|
|
/**
|
|
* Create a new process of application or service
|
|
*
|
|
* @export
|
|
* @param {string} app class name string
|
|
* @param {ProcessTypeClass} cls prototype class
|
|
* @param {GUI.AppArgumentsType[]} [args] process arguments
|
|
* @returns {Promise<ProcessType>} a promise on the created process
|
|
*/
|
|
function createProcess(app: string, cls: ModelTypeClass, args?: AppArgumentsType[]): Promise<ProcessType>;
|
|
/**
|
|
* 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;
|
|
}
|
|
}
|