dany/antosdk-apps
1
0
Fork 0
mirror of https://github.com/antos-rde/antosdk-apps.git synced 2024-11-09 15:08:27 +01:00
Code Issues Packages Projects Releases Wiki Activity
ed38552cd8
antosdk-apps/libantosdk/core/ts/antos.d.ts
Dany LE b5eb1a78b8 update API
2021-11-24 22:42:19 +01:00

10153 lines
334 KiB
TypeScript
Raw Blame History

declare namespace OS {
namespace GUI {
/**
* the SubWindow class is the abstract prototype of all
* modal windows or dialogs definition in AntOS
*
* @export
* @abstract
* @class SubWindow
* @extends {BaseModel}
*/
abstract class SubWindow extends BaseModel {
/**
* Placeholder indicates whether the sub window is in
* modal mode. This value is reserver for future use
*
* @type {boolean}
* @memberof SubWindow
*/
modal: boolean;
/**
* Reference to the parent of the current sub-window
*
* @type {(BaseModel | typeof GUI)}
* @memberof SubWindow
*/
parent: BaseModel | typeof GUI;
/**
*Creates an instance of SubWindow.
* @param {string} name SubWindow (class) name
* @memberof SubWindow
*/
constructor(name: string);
/**
* Exit the sub-window
*
* @returns {void}
* @memberof SubWindow
*/
quit(): void;
/**
* Init the sub-window, this function is called
* on creation of the sub-window object. It is used
* to render the sub-window UI.
*
* Need to be implemented by subclasses
*
* @abstract
* @memberof SubWindow
*/
abstract init(): void;
/**
* Main entry point after rendering of the sub-window
*
* @abstract
* @memberof SubWindow
*/
abstract main(): void;
/**
* Return the parent meta-data of the current
* sub-window
*
* @returns {API.PackageMetaType}
* @memberof SubWindow
*/
meta(): API.PackageMetaType;
/**
* Show the sub-window
*
* @memberof SubWindow
*/
show(): void;
/**
* Hide the sub-window
*
* @returns {void}
* @memberof SubWindow
*/
hide(): void;
}
/**
* Abstract prototype of all AntOS dialogs widget
*
* @export
* @abstract
* @class BaseDialog
* @extends {SubWindow}
*/
abstract class BaseDialog extends SubWindow {
/**
* Placeholder for the dialog callback on exit
*
* @memberof BaseDialog
*/
handle: (d: any) => void;
/**
* Placeholder of the dialog input data
*
* @type {GenericObject<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;
}
/**
* A basic dialog renders a dialog widget using the UI
* scheme provided in it constructor or defined in its
* class variable `scheme`
*
* @export
* @class BasicDialog
* @extends {BaseDialog}
*/
class BasicDialog extends BaseDialog {
/**
* Placeholder for the UI scheme to be rendered. This can
* be either the string definition of the scheme or
* the VFS file handle of the scheme file
*
* @protected
* @type {(string | OS.API.VFS.BaseFileHandle)}
* @memberof BasicDialog
*/
protected markup: string | OS.API.VFS.BaseFileHandle;
/**
* If the `markup` variable is not provided, then
* the [[init]] function will find the scheme definition
* in this class variable
*
* @static
* @type {string}
* @memberof BasicDialog
*/
static scheme: string;
/**
*Creates an instance of BasicDialog.
* @param {string} name dialog name
* @param {(string | OS.API.VFS.BaseFileHandle)} [markup] UI scheme definition
* @memberof BasicDialog
*/
constructor(name: string, markup?: string | OS.API.VFS.BaseFileHandle);
/**
* Render the dialog using the UI scheme provided by either
* the `markup` instance variable or the `scheme` class variable
*
* @returns {void}
* @memberof BasicDialog
*/
init(): void;
/**
* Main entry point for the dialog
*
* @memberof BasicDialog
*/
main(): void;
}
/**
* The namespace `dialogs` is dedicated to all Dialog definition
* in AntOS
*/
namespace dialogs {
/**
* Simple prompt dialog to get user input text.
* The input data of the dialog:
*
* ```typescript
* {
* title: string, // window title
* label: string, // label text
* value: string, // user input text
* type: string // input type: text or password
* }
* ```
*
* The data passing from the dialog to the callback function is
* in the string text of the user input value
*
* @export
* @class PromptDialog
* @extends {BasicDialog}
*/
class PromptDialog extends BasicDialog {
/**
*Creates an instance of PromptDialog.
* @memberof PromptDialog
*/
constructor();
/**
* Main entry point
*
* @memberof PromptDialog
*/
main(): void;
}
/**
* A text dialog is similar to a [[PromptDialog]] nut allows
* user to input multi-line text.
*
* Refer to [[PromptDialog]] for the definition of input and callback data
* of the dialog
*
* @export
* @class TextDialog
* @extends {BasicDialog}
*/
class TextDialog extends BasicDialog {
/**
*Creates an instance of TextDialog.
* @memberof TextDialog
*/
constructor();
/**
* Main entry point
*
* @memberof TextDialog
*/
main(): void;
}
/**
* A Calendar dialog allows user to select a date
*
* Input data:
*
* ```typescript
* {
* title: string // window title
* }
* ```
*
* @export
* @class CalendarDialog
* @extends {BasicDialog}
*/
class CalendarDialog extends BasicDialog {
/**
* Creates an instance of CalendarDialog.
*
* Callback data: a Date object represent the selected date
*
*
* @memberof CalendarDialog
*/
constructor();
/**
*
*
* @memberof CalendarDialog
*/
main(): void;
}
/**
* Color picker dialog
*
* Input data:
*
* ```typescript
* {
* title: string // window title
* }
* ```
* Callback data: [[ColorType]] object
*
* @export
* @class ColorPickerDialog
* @extends {BasicDialog}
*/
class ColorPickerDialog extends BasicDialog {
/**
*Creates an instance of ColorPickerDialog.
* @memberof ColorPickerDialog
*/
constructor();
/**
*
*
* @memberof ColorPickerDialog
*/
main(): void;
}
/**
* Show key-value pair of the input object
*
* Input data:
*
* ```typescript
* {
* title: string, // window title
* [propName:string]: any
* }
* ```
*
* No data for callback
*
* @export
* @class InfoDialog
* @extends {BasicDialog}
*/
class InfoDialog extends BasicDialog {
/**
*Creates an instance of InfoDialog.
* @memberof InfoDialog
*/
constructor();
/**
*
*
* @memberof InfoDialog
*/
main(): void;
}
/**
* A simple confirm dialog
*
* Input data:
*
* ```typescript
* {
* title: string, // window title
* icon?: string, // label icon
* iconclass?: string, // label iconclass
* text: string // label text
* }
* ```
*
* Callback data: `boolean`
*
* @export
* @class YesNoDialog
* @extends {BasicDialog}
*/
class YesNoDialog extends BasicDialog {
/**
*Creates an instance of YesNoDialog.
* @memberof YesNoDialog
*/
constructor();
/**
* Main entry point
*
* @memberof YesNoDialog
*/
main(): void;
}
/**
* A selection dialog provide user with a list of options to
* select.
*
* Input data:
*
* ```typescript
* {
* title: string, // window title
* data:
* {
* text: string,
* [propName:string]: any
* } [] // list data
* ```
*
* Callback data: the selected data in the input list
*
* @export
* @class SelectionDialog
* @extends {BasicDialog}
*/
class SelectionDialog extends BasicDialog {
/**
*Creates an instance of SelectionDialog.
* @memberof SelectionDialog
*/
constructor();
/**
* Main entry
*
* @memberof SelectionDialog
*/
main(): void;
}
/**
* An About dialog is dedicated to show the parent
* application meta-data
*
* Input data: no
*
* Callback data: no
*
* @export
* @class AboutDialog
* @extends {BasicDialog}
*/
class AboutDialog extends BasicDialog {
/**
*Creates an instance of AboutDialog.
* @memberof AboutDialog
*/
constructor();
/**
* Main entry point
*
* @returns {void}
* @memberof AboutDialog
*/
main(): void;
}
/**
* File dialog allows user to select a file/folder
*
* Input data:
*
* ```typescript
* {
* title: string, // window title
* root?: string, // the root path folder of the file view
* type?: "file"|"dir"|"app", // file type to be selected
* mimes?: string[], // mime types of file to be selected
* hidden?: boolean, // show/hide hidden file
* file?: string // file name
*
* }
* ```
*
* Callback data:
*
* ```typescript
* {
* file: string, // selected file path
* name: string // user input file name
* }
* ```
*
* @export
* @class FileDialog
* @extends {BasicDialog}
*/
class FileDialog extends BasicDialog {
/**
*Creates an instance of FileDialog.
* @memberof FileDialog
*/
constructor();
/**
* Store the last opened directory
*
* @static
* @type {string}
* @memberof FileDialog
*/
static last_opened: string;
/**
*
*
* @returns {void}
* @memberof FileDialog
*/
main(): void;
}
/**
* Generic & dynamic key-value dialog. The content
* of the dialog consist of an array of label and input elements
* which are generated based on the input model
*
* The input data of the dialog should be:
*
* ```typescript
* {
* title: string, // window title
* model: {
* [propName:string]: string
* },
* data: {
* [propName:string]: string
* },
* allow_empty: boolean
* }
* ```
* Where:
* - keys of `model` are data fields, each key correspond to an input element
* - values of `model` are description texts of fields, each value correspond to a label text
* - data is the input data object in the format of model (optional)
*
* ```
* Example:
* {
* title: "Greeting",
* model: {
* name: "Your name",
* email: "Your email"
* },
* allow_empty: false
* }
*```
* The data passing from the dialog to the callback function is
* the user input data corresponding to the input model
*
* Example of callback data for the above model:
*
* ```
* {
* name: "John Doe",
* email: "jd@mail.com"
* }
* ```
*
* @export
* @class MultiInputDialog
* @extends {BasicDialog}
*/
class MultiInputDialog extends BasicDialog {
/**
* References to all the input fields in the
* dialog
*
* @private
* @type {HTMLElement[]}
* @memberof MultiInputDialog
*/
private inputs;
/**
*Creates an instance of MultiInputDialog.
* @memberof MultiInputDialog
*/
constructor();
/**
* Generate the scheme before rendering
*
* @memberof MultiInputDialog
*/
init(): void;
/**
* Main entry point
*
* @memberof MultiInputDialog
*/
main(): void;
}
/**
* Generic dynamic key-value dialog
*
* Allow user to input any data key-value based object:
*
* {
* [prop:string]: string;
* }
*
* @export
* @class KeyValueDialog
* @extends {BasicDialog}
*/
class KeyValueDialog extends BasicDialog {
/**
* Reference to the form container
*
* @private
* @type {HTMLDivElement}
* @memberof KeyValueDialog
*/
private container;
/**
* Creates an instance of KeyValueDialog.
* @memberof KeyValueDialog
*/
constructor();
/**
* Main entry point
*
* @memberof KeyValueDialog
*/
main(): void;
/**
* Add new input key-value field to the dialog
*
* @private
* @memberof KeyValueDialog
*/
private addField;
}
}
}
}
/// <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 {
/**
* AntOS keyboard shortcut type definition
*
* @export
* @interface ShortcutType
*/
interface ShortcutType {
/**
* Placeholder for all shortcut callbacks, example:
* ```typescript
* fn_193462204.c = function() {..}
* // this function will be called when the hotkey `ALT-C` is triggered
* // fn_${"ALT".hash()} is fn_193462204
* ```
*
* @memberof ShortcutType
*/
[propName: string]: GenericObject<(e: JQuery.KeyDownEvent) => void>;
}
/**
* Basic item type definition which is usually used by some UI element
* such as list view, tree view, menu and grid view
*
*
* @export
* @interface BasicItemType
*/
interface BasicItemType {
/**
* Item text
*
* @type {(string | FormattedString)}
* @memberof BasicItemType
*/
text: string | FormattedString;
/**
* Item children, usually used by tree view or menu item
* This property is keep for compatibility purposes only.
* Otherwise, the [[nodes]] property should be used
*
* @type {BasicItemType[]}
* @memberof BasicItemType
*/
children?: BasicItemType[];
/**
* Item children, usually used by tree view or menu item
*
* @type {BasicItemType[]}
* @memberof BasicItemType
*/
nodes?: BasicItemType[];
[propName: string]: any;
}
/**
* Element id of the virtual desktop, used by JQuery
*/
var workspace: string;
/**
* Indicate whether the system is in fullscreen mode
*/
var fullscreen: boolean;
/**
* Reference to the current system dialog, only one dialog
* is allowed at a time. A dialog may have sub dialog
*/
var dialog: BaseDialog;
/**
* Convert an application html scheme to
* UI elements, then insert this UI scheme to the DOM tree.
*
* This function renders the UI of the application before calling the
* application's [[main]] function
*
* @export
* @param {string} html html scheme string
* @param {BaseModel} app reference to the target application
* @param {(Element | string)} parent
* The parent HTML element where the application is rendered.
* This is usually the reference to the virtual desktop element.
*/
function htmlToScheme(html: string, app: BaseModel, parent: Element | string): void;
/**
* Load an application scheme file then render
* it with [[htmlToScheme]]
*
* @export
* @param {string} path VFS path to the scheme file
* @param {BaseModel} app the target application
* @param {(HTMLElement | string)} parent The parent HTML element where the application is rendered.
*/
function loadScheme(path: string, app: BaseModel, parent: HTMLElement | string): void;
/**
* Clear the current system theme
*
* @export
*/
function clearTheme(): void;
/**
* Load a theme based on its name, then refresh the
* system UI theme
*
* @export
* @param {string} name name of the theme e.g. `antos_dark`
* @param {boolean} force force to clear the system theme before applying the new one
*/
function loadTheme(name: string, force: boolean): void;
/**
* Open a system dialog.
*
* @export
* @param {(BaseDialog | string)} d a dialog object or a dialog class name
* @param {GenericObject<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>;
/**
* 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): 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>;
}
}
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 {
[index: number]: {
/**
* The event name
*
* @type {string}
*/
e: string;
/**
* The event callback
*
*/
f: (d: any) => void;
}[];
}
/**
* This class is the based class used in AntOS event
* announcement system.
* It implements the observer pattern using simple
* subscribe/publish mechanism
* @export
* @class Announcer
*/
class Announcer {
/**
* The observable object that stores event name
* and its corresponding callback in [[ObservableEntryType]]
*
* @type {GenericObject<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: 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;
/**
* 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 {
/**
* 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
*/
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;
}
}
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 {
/**
* 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}
* @memberof BaseService
*/
text: string;
/**
* Reference to the menu entry DOM element attached
* to the service
*
* @type {HTMLElement}
* @memberof BaseService
*/
domel: HTMLElement;
/**
* Reference to the timer that periodically executes the callback
* defined in [[watch]].
*
* @private
* @type {number}
* @memberof BaseService
*/
private timer;
/**
* Reference to the system tray menu
*
* @type {HTMLElement}
* @memberof BaseService
*/
holder: HTMLElement;
/**
* Placeholder for service select callback
*
* @memberof BaseService
*/
onmenuselect: (d: OS.GUI.TagEventType<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;
/**
* Attach the service to a menu element
* such as the system tray menu
*
* @param {HTMLElement} h
* @memberof BaseService
*/
attach(h: HTMLElement): void;
/**
* Set the callback that will be called periodically
* after a period of time.
*
* Each service should only have at most one watcher
*
* @protected
* @param {number} t period time in seconds
* @param {() => void} f callback function
* @returns {number}
* @memberof BaseService
*/
protected watch(t: number, f: () => void): number;
/**
* This function is called when the service
* is exited
*
* @protected
* @param {BaseEvent} evt exit event
* @returns
* @memberof BaseService
*/
protected onexit(evt: BaseEvent): JQuery<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 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
*
* @type {*}
* @memberof BaseFileHandle
*/
cache: any;
/**
* Flag indicated whether the file meta-data is loaded
*
* @type {boolean}
* @memberof BaseFileHandle
*/
ready: boolean;
/**
* File path
*
* @type {string}
* @memberof BaseFileHandle
*/
path: string;
/**
* File protocol e.g:
* - `os://`
* - `home://`
*
* @type {string}
* @memberof BaseFileHandle
*/
protocol: string;
/**
* List of path segments
*
* @type {string[]}
* @memberof BaseFileHandle
*/
genealogy: string[];
/**
* File base name
*
* @type {string}
* @memberof BaseFileHandle
*/
basename: string;
/**
* Once loaded, [[ready]] will be set to true and
* file meta-data will be stored in this place holder
*
* @type {FileInfoType}
* @memberof BaseFileHandle
*/
info: FileInfoType;
/**
* File extension
*
* @type {string}
* @memberof BaseFileHandle
*/
ext: string;
/**
*
* File type
* @type {string}
* @memberof BaseFileHandle
*/
type: string;
/**
*Creates an instance of BaseFileHandle.
* @param {string} path file path
* @memberof BaseFileHandle
*/
constructor(path: string);
/**
* Set a file path to the current file handle
*
* @param {string} p
* @returns {void}
* @memberof BaseFileHandle
*/
setPath(p: string): void;
/**
* Getter: Get the file basename
* Setter: set the file name
*
* @returns {string}
* @memberof BaseFileHandle
*/
get filename(): string;
set filename(v: string);
/**
* Set data to the file cache
*
* @param {*} v data object
* @returns {BaseFileHandle}
* @memberof BaseFileHandle
*/
setCache(v: any): BaseFileHandle;
/**
* Return the object itself
*
* @returns {BaseFileHandle}
* @memberof BaseFileHandle
*/
asFileHandle(): BaseFileHandle;
/**
* Check whether the current file is the root of the file tree
*
* @returns {boolean}
* @memberof BaseFileHandle
*/
isRoot(): boolean;
/**
* Check whether the current file is a hidden file
*
* @returns {boolean}
* @memberof BaseFileHandle
*/
isHidden(): boolean;
/**
* Get hash number of the current file path
*
* @returns {number}
* @memberof BaseFileHandle
*/
hash(): number;
/**
* Convert the current file cache to Base64
*
* @protected
* @param {string} t type of the file cache:
* - `object`
* - `mime type`
* @returns {(Promise<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 {string} t data type
* - jsonp: the response is an json object
* - script: the response is a javascript code
* - xml, html: the response is a XML/HTML object
* - text: plain text
* - binary
*
* @returns {Promise<any>} a promise on the file content
* @memberof BaseFileHandle
*/
read(t?: string): 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
*
* @returns {Promise<RequestResult>} promise on the operation result
* @memberof BaseFileHandle
*/
remove(): 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>;
/**
* Low level protocol-specific read operation
*
* This function should be overridden on the file handle class
* that supports the operation
*
* @protected
* @param {string} t data type, see [[read]]
* @returns {Promise<RequestResult>}
* @memberof BaseFileHandle
*/
protected _rd(t: string): 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]]
* @param {*} [d]
* @returns {Promise<RequestResult>}
* @memberof BaseFileHandle
*/
protected _wr(t: string, d?: any): 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
*
* @returns {Promise<RequestResult>}
* @memberof BaseFileHandle
*/
protected _rm(): 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);
/**
* Read the file meta-data
*
* @returns {Promise<RequestResult>}
* @memberof BufferFileHandle
*/
meta(): Promise<RequestResult>;
/**
* 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]]
* @param {*} d data
* @returns {Promise<RequestResult>}
* @memberof BufferFileHandle
*/
protected _wr(t: string, d: any): 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]]
* @param {string} d file data
* @returns {Promise<RequestResult>}
* @memberof SharedFileHandle
*/
protected _wr(t: string, d: 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[]>;
}
}
}
/// <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;
/**
* Reference to the system application menu located
* on the system panel
*
* @type {GUI.tag.MenuTag}
* @memberof BaseApplication
*/
appmenu: GUI.tag.MenuTag;
/**
*Creates an instance of BaseApplication.
* @param {string} name application name
* @param {AppArgumentsType[]} args application arguments
* @memberof BaseApplication
*/
constructor(name: string, args: AppArgumentsType[]);
/**
* Init the application, this function is called when the
* application process is created and docked in the application
* dock.
*
* The application UI will be rendered after the execution
* of this function.
*
* @returns {void}
* @memberof BaseApplication
*/
init(): void;
/**
* Render the application UI by first loading its scheme
* and then mount this scheme to the DOM tree
*
* @protected
* @returns {void}
* @memberof BaseApplication
*/
protected loadScheme(): void;
/**
* API function to perform an heavy task.
* This function will trigger the global `loading`
* event at the beginning of the task, and the `loaded`
* event after finishing the task
*
* @protected
* @param {Promise<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
*
* @private
* @param {string} name locale name e.g. `en_GB`
* @returns {void}
* @memberof BaseApplication
*/
protected updateLocale(name: string): void;
/**
* Execute the callback subscribed to a
* keyboard shortcut
*
* @param {string} fnk meta or modifier key e.g. `CTRL`, `ALT`, `SHIFT` or `META`
* @param {string} c a regular key
* @param {JQuery.KeyDownEvent} e JQuery keyboard event
* @returns {boolean} return whether the shortcut is executed
* @memberof BaseApplication
*/
shortcut(fnk: string, c: string, e: JQuery.KeyDownEvent): boolean;
/**
* Apply a setting to the application
*
* @protected
* @param {string} k the setting name
* @memberof BaseApplication
*/
protected applySetting(k: string): void;
/**
* Apply all settings to the application
*
* @protected
* @memberof BaseApplication
*/
protected applyAllSetting(): void;
/**
* Set a setting value to the application setting
* registry
*
* @protected
* @param {string} k setting name
* @param {*} v setting value
* @returns {void}
* @memberof BaseApplication
*/
protected registry(k: string, v: any): void;
/**
* Show the appliation
*
* @returns {void}
* @memberof BaseApplication
*/
show(): void;
/**
* Blur the application
*
* @returns {void}
* @memberof BaseApplication
*/
blur(): void;
/**
* Hide the application
*
* @returns {void}
* @memberof BaseApplication
*/
hide(): void;
/**
* Maximize or restore the application window size
* and its position
*
* @returns {void}
* @memberof BaseApplication
*/
toggle(): void;
/**
* Get the application title
*
* @returns {(string| FormattedString)}
* @memberof BaseApplication
*/
title(): string | FormattedString;
/**
* Function called when the application exit.
* If the input exit event is prevented, the application
* process will not be killed
*
*
* @protected
* @param {BaseEvent} evt exit event
* @memberof BaseApplication
*/
protected onexit(evt: BaseEvent): void;
/**
* Get the application meta-data
*
* @returns {API.PackageMetaType}
* @memberof BaseApplication
*/
meta(): API.PackageMetaType;
/**
* Base menu definition. This function
* returns the based menu definition of all applications.
* Other application specific menu entries
* should be defined in [[menu]] function
*
* @protected
* @returns {GUI.BasicItemType[]}
* @memberof BaseApplication
*/
protected baseMenu(): GUI.BasicItemType[];
/**
* The main application entry that is called after
* the application UI is rendered. This application
* must be implemented by all subclasses
*
* @abstract
* @memberof BaseApplication
*/
abstract main(): void;
/**
* Application specific menu definition
*
* @protected
* @returns {GUI.BasicItemType[]}
* @memberof BaseApplication
*/
protected menu(): GUI.BasicItemType[];
/**
* The cleanup function that is called by [[onexit]] function.
* Application need to override this function to perform some
* specific task before exiting or to prevent the application
* to be exited
*
* @protected
* @param {BaseEvent} e
* @memberof BaseApplication
*/
protected cleanup(e: BaseEvent): void;
}
}
}
/**
* Reference to the global this
*/
declare const Ant: typeof globalThis;
/**
* Extend the String prototype with some API
* functions used by AntOS API
*
* @interface String
*/
interface String {
/**
* Simple string hash function
*
* @returns {number}
* @memberof String
*/
hash(): number;
/**
* Parse the current string and convert it
* to an object of type [[Version]] if the string
* is in the format recognized by [[Version]],
* e.g.: `1.0.1-a`
*
* @returns {OS.Version}
* @memberof String
*/
__v(): OS.Version;
/**
* Convert the current string to base 64 string
*
* @returns {string}
* @memberof String
*/
asBase64(): string;
/**
* Unescape all escaped characters on the
* string using `\`
*
* @returns {string}
* @memberof String
*/
unescape(): string;
/**
* Escape the current string using backslash
*
* @returns {string}
* @memberof String
*/
escape(): string;
/**
* Convert the current string to uint8 array
*
* @returns {Uint8Array}
* @memberof String
*/
asUint8Array(): Uint8Array;
/**
* Format the current using input parameters.
* The current string should be a formatted string
* in the following form:
*
* ```typescript
* "example string: {0} and {1}".format("hello", "world")
* // return "example string: hello and world"
* ```
*
* @param {...any[]} args
* @returns {string}
* @memberof String
*/
format(...args: any[]): string;
/**
* Create a [[FormattedString]] object using the current
* string and the input parameters
*
* @param {...any[]} args
* @returns {OS.FormattedString}
* @memberof String
*/
f(...args: any[]): OS.FormattedString;
/**
* Check if the current string is translatable, if it
* is the case, translate the string to the language specified
* in the current system locale setting.
*
* A translatable string is a string in the following
* form: `"__(example string)"`
*
* @returns {string}
* @memberof String
*/
__(): string;
/**
* Translate current string to the language specified
* by the system locale setting
*
* @returns {string}
* @memberof String
*/
l(): string;
/**
* Trim left of a string by a mask string
*
* @param {string} arg specifies a sub-string to be removed
* @returns {string}
* @memberof String
*/
trimFromLeft(arg: string): string;
/**
* Trim right of a string by a mask string
*
* @param {string} arg specifies a sub-string to be removed
* @returns {string}
* @memberof String
*/
trimFromRight(arg: string): string;
/**
* Trim both left and right of a string by a mask string
*
* @param {string} arg specifies a sub-string to be removed
* @returns {string}
* @memberof String
*/
trimBy(arg: string): string;
}
/**
* Extend the Data prototype with the
* [[timestamp]] function
*
* @interface Date
*/
interface Date {
/**
* Return the timestamp of the current Date object
*
* @returns {number}
* @memberof Date
*/
timestamp(): number;
}
/**
* Generic key-value pair object interface
*
* @interface GenericObject
* @template T
*/
interface GenericObject<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]
*
* e.g.: 1.2.3-r means that:
* - version major number is 1
* - version minor number is 2
* - patch version is 3
* - the current branch is release `r`
* ```
*
* @export
* @class Version
*/
class Version {
/**
* The version string
*
* @type {string}
* @memberof Version
*/
string: string;
/**
* The current branch
* - 1: `a` - alpha branch
* - 2: `b` - beta branch
* - 3: `r` - release branch
*
* @private
* @type {number}
* @memberof Version
*/
private branch;
/**
* Version major number
*
* @type {number}
* @memberof Version
*/
major: number;
/**
* Version minor number
*
* @type {number}
* @memberof Version
*/
minor: number;
/**
* Version patch number
*
* @type {number}
* @memberof Version
*/
patch: number;
/**
*Creates an instance of Version.
* @param {string} string string represents the version
* @memberof Version
*/
constructor(string: string);
/**
* Compare the current version with another version.
*
* The comparison priority is `branch>major>minor>patch`.
*
* For the branch, the priority is `r>b>a`
*
* @param {(string | Version)} o version string or object
* @returns {(0 | 1 | -1)}
* Return 0 if the two versions are the same, 1 if
* the current version is newer than the input version,
* otherwise return -1
* @memberof Version
*/
compare(o: string | Version): 0 | 1 | -1;
/**
* Check if the current version is newer than
* the input version
*
* @param {(string | Version)} o version string or object
* @returns {boolean}
* @memberof Version
*/
nt(o: string | Version): boolean;
/**
* Check if the current version is older than
* the input version
*
* @param {(string | Version)} o version string or object
* @returns {boolean}
* @memberof Version
*/
ot(o: string | Version): boolean;
/**
* Return itself
*
* @returns {Version}
* @memberof Version
*/
__v(): Version;
/**
* Convert Version object to string
*
* @returns {string}
* @memberof Version
*/
toString(): string;
}
/**
* Variable represents the current AntOS version, it
* is an instance of [[Version]]
*/
const VERSION: Version;
/**
* Register a model prototype to the system namespace.
* There are two types of model to be registered, if the model
* is of type [[SubWindow]], its prototype will be registered
* in the [[dialogs]] namespace, otherwise, if the model type
* is [[Application]] or [[Service]], its prototype will be
* registered in the [[application]] namespace.
*
* When a model is loaded in the system, its prototype is registered
* for later uses
*
* @export
* @param {string} name class name
* @param {*} x the corresponding class
* @returns {*}
*/
function register(name: string, x: PM.ModelTypeClass): void;
/**
* This function cleans up the entire system and
* makes sure the system is in a new and clean session.
* It performs the following operations:
*
* - Kill all running processes
* - Unregister all global events and reset the global
* announcement system
* - Clear the current theme
* - Reset process manager and all system settings
*
* @export
*/
function cleanup(): void;
/**
* Booting up AntOS. This function checks whether the user
* is successfully logged in, then call [[startAntOS]], otherwise
* it shows the login screen
*
* @export
*/
function boot(): void;
/**
* Placeholder for all the callbacks that are called when the system
* exits. These callbacks are useful when an application or service wants
* to perform a particular task before shuting down the system
*/
const cleanupHandles: {
[index: string]: () => 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 {
/**
* Application argument type definition
*
* @export
* @interface AppArgumentsType
*/
interface AppArgumentsType {
/**
* File type to be open by the app
*
* @type {string}
* @memberof AppArgumentsType
*/
type?: string;
/**
* File path to be opened
*
* @type {string}
* @memberof AppArgumentsType
*/
path: string;
/**
* Any other object
*/
[propName: string]: any;
}
/**
* Enum definition of different model types
*
* @export
* @enum {number}
*/
enum ModelType {
/**
* Applications
*/
Application = 0,
/**
* Services
*/
Service = 1,
/**
* Sub-window such as dialogs
*/
SubWindow = 2
}
/**
* Base AntOS event definition
*
* @export
* @class BaseEvent
*/
class BaseEvent {
/**
* The event name placeholder
*
* @type {string}
* @memberof BaseEvent
*/
name: string;
/**
* Placeholder indicates whether the event is forced to
* be happen
*
* @private
* @type {boolean}
* @memberof BaseEvent
*/
private force;
/**
* Placeholder indicates whether the event is prevented.
* This value has not effect if `force` is set to `true`
*
* @type {boolean}
* @memberof BaseEvent
*/
prevent: boolean;
/**
*Creates an instance of BaseEvent.
* @param {string} name event name
* @param {boolean} force indicates whether the event is forced
* @memberof BaseEvent
*/
constructor(name: string, force: boolean);
/**
* Prevent the current event. This function
* has no effect if `force` is set to true
*
* @memberof BaseEvent
*/
preventDefault(): void;
}
/**
* The root model of all applications, dialogs or services
* in the system
*
* @export
* @abstract
* @class BaseModel
*/
abstract class BaseModel {
/**
* The class name
*
* @type {string}
* @memberof BaseModel
*/
name: string;
/**
* The argument of the model
*
* @type {AppArgumentsType[]}
* @memberof BaseModel
*/
args: AppArgumentsType[];
/**
* Each model has its own local announcement system
* to handle all local events inside that model.
*
* This observable object is propagate to all the
* UI elements ([[AFXTag]]) inside the model
*
* @protected
* @type {API.Announcer}
* @memberof BaseModel
*/
protected _observable: API.Announcer;
/**
* Reference to the core API namespace
*
* @protected
* @type {typeof API}
* @memberof BaseModel
*/
protected _api: typeof API;
/**
* Reference to the core GUI namespace
*
* @protected
* @type {typeof GUI}
* @memberof BaseModel
*/
protected _gui: typeof GUI;
/**
* Reference to the model's dialog
*
* @type {GUI.BaseDialog}
* @memberof BaseModel
*/
dialog: GUI.BaseDialog;
/**
* The HTML element ID of the virtual desktop
*
* @protected
* @type {string}
* @memberof BaseModel
*/
protected host: string;
/**
* The process number of the current model.
* For sub-window this number is the number
* of the parent window
*
* @type {number}
* @memberof BaseModel
*/
pid: number;
/**
* Reference the DOM element of the UI scheme belong to
* this model
*
* @type {HTMLElement}
* @memberof BaseModel
*/
scheme: HTMLElement;
/**
* Reference to the system setting
*
* @protected
* @type {typeof setting}
* @memberof BaseModel
*/
protected systemsetting: typeof setting;
/**
* Placeholder for the process creation timestamp
*
* @type {number}
* @memberof BaseModel
*/
birth: number;
/**
* Different model type
*
* @static
* @type {ModelType}
* @memberof BaseModel
*/
static type: ModelType;
/**
* Allow singleton on this model
*
* @static
* @type {boolean}
* @memberof BaseModel
*/
static singleton: boolean;
/**
* The javascript or css files that the model depends on. All dependencies
* will be loaded before the model is rendered
*
* @static
* @type {string[]} list of VFS paths of dependencies
* @memberof BaseModel
*/
static dependencies: string[];
/**
* Reference to the CSS Element of the model
*
* @static
* @type {(HTMLElement | string)}
* @memberof BaseModel
*/
static style: HTMLElement | string;
/**
* Place holder for model meta-data
*
* @static
* @type {API.PackageMetaType}
* @memberof BaseModel
*/
static meta: API.PackageMetaType;
/**
*Creates an instance of BaseModel.
* @param {string} name class name
* @param {AppArgumentsType[]} args arguments
* @memberof BaseModel
*/
constructor(name: string, args: AppArgumentsType[]);
/**
* Getter: get the local announcer object
*
* @readonly
* @type {API.Announcer}
* @memberof BaseModel
*/
get observable(): API.Announcer;
/**
* Update the model locale
*
* @protected
* @param {string} name
* @memberof BaseModel
*/
protected updateLocale(name: string): void;
/**
* Render the model's UI
*
* @protected
* @param {string} p VFS path to the UI scheme definition
* @returns {void}
* @memberof BaseModel
*/
protected render(p: string): void;
/**
* Exit the model
*
* @param {boolean} force set this value to `true` will bypass the prevented exit event by user
* @returns {void}
* @memberof BaseModel
*/
quit(force: boolean): void;
/**
* Model meta data, need to be implemented by
* subclasses
*
* @abstract
* @returns {API.PackageMetaType}
* @memberof BaseModel
*/
abstract meta(): API.PackageMetaType;
/**
* VFS path to the model asset
*
* @returns {string}
* @memberof BaseModel
*/
path(): string;
/**
* Execute a server side script and get back the result
*
* @protected
* @param {GenericObject<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
*
* @protected
* @param {string} e event name
* @param {*} [d] event data
* @returns {void}
* @memberof BaseModel
*/
trigger(e: string, d?: any): void;
/**
* subscribe to an event on the global announcement system
*
* @protected
* @param {string} e event name
* @param {(d: 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 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 {
namespace GUI {
/**
*
* Interface for an application dock item
*
* @export
* @interface AppDockItemType
*/
interface AppDockItemType {
/**
* Reference to the application process represented
* by the dock item
*
* @type {application.BaseApplication}
* @memberof AppDockItemType
*/
app: application.BaseApplication;
/**
* Reference to the DOM element of
* the owner dock item
*
* @type {AFXTag}
* @memberof AppDockItemType
*/
domel?: AFXTag;
[propName: string]: any;
}
namespace tag {
/**
* This class define the AntOS system application dock tag
*
* @export
* @class AppDockTag
* @extends {AFXTag}
*/
class AppDockTag extends AFXTag {
/**
* variable holds the application select event
* callback handle
*
* @private
* @type {TagEventCallback<any>}
* @memberof AppDockTag
*/
private _onappselect;
/**
* Items data of the dock
*
* @private
* @type {AppDockItemType[]}
* @memberof AppDockTag
*/
private _items;
/**
* Reference to the currently select application
* process in the dock
*
* @private
* @type {AppDockItemType}
* @memberof AppDockTag
*/
private _selectedItem;
/**
*Creates an instance of AppDockTag.
* @memberof AppDockTag
*/
constructor();
/**
* Implementation of the abstract function: Update the current tag.
* It do nothing for this tag
*
* @protected
* @param {*} [d]
* @memberof AppDockTag
*/
protected reload(d?: any): void;
/**
* Init the tag before mounting
*
* @protected
* @memberof AppDockTag
*/
protected init(): void;
/**
* The tag layout, it is empty on creation but elements will
* be added automatically to it in operation
*
* @protected
* @returns {TagLayoutType[]}
* @memberof AppDockTag
*/
protected layout(): TagLayoutType[];
/**
* getter to get the dock items
*
* @readonly
* @type {AppDockItemType[]}
* @memberof AppDockTag
*/
get items(): AppDockItemType[];
/**
* Setter:
*
* set the selected application in the dock
* this will trigger two event:
* - `focus`: on the selected application
* - `blur`: on all other applications on the dock
*
* Getter:
*
* Get the current selected application
* on the dock
*
* @memberof AppDockTag
*/
set selectedApp(v: application.BaseApplication);
get selectedApp(): application.BaseApplication;
/**
* Get selected item of the dock
*
* @readonly
* @type {AppDockItemType}
* @memberof AppDockTag
*/
get selectedItem(): AppDockItemType;
/**
* When a new application process is created, this function
* will be called to add new application entry to the dock.
* The added application will becomes the current selected
* application
*
* @param {AppDockItemType} item an application dock item entry
* @memberof AppDockTag
*/
newapp(item: AppDockItemType): void;
/**
* Delete and application entry from the dock.
* This function will be called when an application
* is exit
*
* @param {BaseApplication} a the application to be removed from the dock
* @memberof AppDockTag
*/
removeapp(a: application.BaseApplication): void;
/**
* Mount the current dock tag
*
* @protected
* @memberof AppDockTag
*/
protected mount(): void;
}
}
}
}
declare namespace OS {
namespace GUI {
namespace tag {
/**
* 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[];
}
}
}
}
declare namespace OS {
namespace GUI {
namespace tag {
/**
* This class defines basic AFX label tag.
* A label contains a text and an icon (optional)
*
* @export
* @class LabelTag
* @extends {AFXTag}
*/
class LabelTag extends AFXTag {
/**
* placeholder of the text to be displayed
*
* @private
* @type {(string | FormattedString)}
* @memberof LabelTag
*/
private _text;
/**
*Creates an instance of LabelTag.
* @memberof LabelTag
*/
constructor();
/**
* this implementation does nothing in this tag
*
* @protected
* @memberof LabelTag
*/
protected mount(): void;
/**
* Refresh the text in the label
*
* @protected
* @param {*} d
* @memberof LabelTag
*/
protected reload(d: any): void;
/**
* Reset to default some property value
*
* @protected
* @memberof LabelTag
*/
protected init(): void;
/**
* This implementation of the function does nothing
*
* @protected
* @memberof LabelTag
*/
protected calibrate(): void;
/**
* Set the VFS path of the label icon
*
* @memberof LabelTag
*/
set icon(v: string);
/**
* Set the CSS class of the label icon
*
* @memberof LabelTag
*/
set iconclass(v: string);
/**
* Setter: Set the text of the label
*
* Getter: Get the text displayed on the label
*
* @memberof LabelTag
*/
set text(v: string | FormattedString);
get text(): string | FormattedString;
/**
* Lqbel layout definition
*
* @protected
* @returns {TagLayoutType[]}
* @memberof LabelTag
*/
protected layout(): TagLayoutType[];
}
}
}
}
declare namespace OS {
namespace GUI {
namespace tag {
/**
* 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;
}
}
}
}
/// <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 {
/**
* 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 TreeViewItemPrototype
*/
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;
}
}
}
}
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 {
/**
* 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 {
/**
* 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;
})[];
}[];
}
}
}
}
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;
/**
*Creates an instance of TabBarTag.
* @memberof TabBarTag
*/
constructor();
/**
* Init the tag
*
* @protected
* @memberof TabBarTag
*/
protected init(): void;
/**
* Do nothing
*
* @protected
* @param {*} [d]
* @memberof TabBarTag
*/
protected reload(d?: any): void;
/**
* Setter: Enable/disable a tab to be closed
*
* Getter: Check whether tabs can be closed
*
* @memberof TabBarTag
*/
set closable(v: boolean);
get closable(): boolean;
/**
* Add a tab in the end of the tab bar
*
* @param {GenericObject<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[];
/**
* 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 {
namespace tag {
/**
* A float list is a list of items in which each
* item can be moved (drag and drop) freely
*
* @export
* @class FloatListTag
* @extends {ListViewTag}
*/
class FloatListTag extends ListViewTag {
/**
* Update the current tag, do nothing
*
* @protected
* @param {*} [d]
* @memberof FloatListTag
*/
protected reload(d?: any): void;
/**
* Variable that hold the onready callback of
* the tag. This callback will be called after
* the tag is mounted
*
* @private
* @memberof FloatListTag
*/
private _onready;
/**
*Creates an instance of FloatListTag.
* @memberof FloatListTag
*/
constructor();
/**
* set the onready callback function to the tag.
* This callback will be called after
* the tag is mounted
*
* @memberof FloatListTag
*/
set onready(v: (e: FloatListTag) => void);
/**
* Setter:
*
* Set the direction of the list item layout.
* Two directions are available:
* - `vertical`
* - `horizontal`
*
* This setter acts as a DOM attribute
*
* Getter:
*
* Get the currently set direction of list
* item layout
*
* @memberof FloatListTag
*/
set dir(v: string);
get dir(): string;
/**
* Disable the dropdown option in this list
*
* @memberof FloatListTag
*/
set dropdown(v: boolean);
/**
* Disable the list buttons configuration in this
* list
*
* @memberof FloatListTag
*/
set buttons(v: GenericObject<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;
/**
* Enable drag and drop on the list
*
* @private
* @param {ListViewItemTag} el the list item DOM element
* @memberof FloatListTag
*/
private enable_drag;
/**
* Calibrate the view of the list
*
* @memberof FloatListTag
*/
calibrate(): void;
}
}
}
}
/**
* 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 {
/**
* 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>[];
/**
*Creates an instance of GridRowTag.
* @memberof GridRowTag
*/
constructor();
/**
* Mount the tag, do nothing
*
* @protected
* @memberof GridRowTag
*/
protected mount(): void;
/**
* Init the tag before mounting: reset the data placeholder
*
* @protected
* @memberof GridRowTag
*/
protected init(): void;
/**
* Empty layout
*
* @protected
* @returns {TagLayoutType[]}
* @memberof GridRowTag
*/
protected layout(): TagLayoutType[];
/**
* This function does nothing in this tag
*
* @protected
* @memberof GridRowTag
*/
protected calibrate(): void;
/**
* This function does nothing in this tag
*
* @protected
* @param {*} [d]
* @memberof GridRowTag
*/
protected reload(d?: any): void;
}
/**
* Event data used by grid cell
*/
type CellEventData = TagEventDataType<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;
/**
* Creates an instance of GridViewTag.
* @memberof GridViewTag
*/
constructor();
/**
* Init the grid view before mounting.
* Reset all the placeholders to default values
*
* @protected
* @memberof GridViewTag
*/
protected init(): void;
/**
* This function does nothing
*
* @protected
* @param {*} [d]
* @memberof GridViewTag
*/
protected reload(d?: any): void;
/**
* set the cell select event callback
*
* @memberof GridViewTag
*/
set oncellselect(v: TagEventCallback<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;
/**
* 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<CellEventData>} e
* @returns {void}
* @memberof GridViewTag
*/
private rowselect;
/**
* Check whether the grid has header
*
* @private
* @returns {boolean}
* @memberof GridViewTag
*/
private has_header;
/**
* Calibrate the grid
*
* @protected
* @memberof GridViewTag
*/
protected calibrate(): void;
/**
* Recalculate the size of each header cell, changing
* in header cell size will also resize the entire
* related column
*
* @private
* @returns {void}
* @memberof GridViewTag
*/
private calibrate_header;
/**
* Mount the grid view tag
*
* @protected
* @returns {void}
* @memberof GridViewTag
*/
protected mount(): void;
/**
* Layout definition of the grid view
*
* @protected
* @returns {TagLayoutType[]}
* @memberof GridViewTag
*/
protected layout(): TagLayoutType[];
}
}
}
}
declare namespace OS {
namespace GUI {
namespace tag {
/**
* 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: 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[];
}
}
}
}
/// <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.MenuTag} m The context menu element [[MenuTag]]
* @memberof HTMLElement
*/
contextmenuHandle(e: JQuery.MouseEventBase, m: OS.GUI.tag.MenuTag): void;
/**
* Mount the element and all the children on its DOM subtree. This action
* is performed in a top-down manner
*
* @memberof HTMLElement
*/
sync(): void;
/**
*
* This action allows to generated all the DOM nodes defined by all AFX tags
* in its hierarchy.
* It performs two operations, one top-down operation to generate all the
* necessary DOM nodes, another bottom-up operation to init all the AFX tag
* in the current element DOM hierarchy
*
* @param {OS.API.Announcer} o an AntOS observable object
* @memberof HTMLElement
*/
afxml(o: OS.API.Announcer): void;
/**
* Perform DOM generation ([[afxml]]) then mount ([[sync]]) all the
* elements.
*
* @param {OS.API.Announcer} o an AntOS observable object
* @param {boolean} [flag] indicates whether this is the top-most call of the operation
* @memberof HTMLElement
*/
uify(o: OS.API.Announcer, flag?: boolean): void;
/**
*
*
* @type {*}
* @memberof HTMLElement
*/
mozRequestFullScreen: any;
/**
*
*
* @type {*}
* @memberof HTMLElement
*/
webkitRequestFullscreen: any;
/**
*
*
* @type {*}
* @memberof HTMLElement
*/
msRequestFullscreen: any;
}
/**
*
*
* @interface Document
*/
interface Document {
mozCancelFullScreen: any;
webkitExitFullscreen: any;
cancelFullScreen: any;
}
declare namespace OS {
namespace GUI {
/**
* [[TagLayoutType]] interface using by AFX tags to defined
* its internal DOM hierarchy
*
* @export
* @interface TagLayoutType
*/
interface TagLayoutType {
/**
* Element tag name
*
* @type {string}
* @memberof TagLayoutType
*/
el: string;
/**
* Children layout of the current element
*
* @type {TagLayoutType[]}
* @memberof TagLayoutType
*/
children?: TagLayoutType[];
/**
* Reference name of the element used by AFX Tag
*
* @type {string}
* @memberof TagLayoutType
*/
ref?: string;
/**
* CSS class of the element
*
* @type {string}
* @memberof TagLayoutType
*/
class?: string;
/**
* this is the `data-id` attribute of the element,
* can be query by the [[aid]] Tag API function.
* Not to be confused with the DOM `id` attribute
*
* @type {(string | number)}
* @memberof TagLayoutType
*/
id?: string | number;
/**
* Tooltip text of the element
*
* @type {(string | FormattedString)}
* @memberof TagLayoutType
*/
tooltip?: string | FormattedString;
/**
* `data-width` of the element, not to be confused with
* the `width` attribute of the DOM element
*
* @type {number|string}
* @memberof TagLayoutType
*/
width?: number | string;
/**
** `data-height` of the element, not to be confused with
* the `height` attribute of the DOM element
*
* @type {number|string}
* @memberof TagLayoutType
*/
height?: number | string;
}
/**
* Data type for event issued by AFX tags
*
* @export
* @interface TagEventDataType
* @template T item template
*/
interface TagEventDataType<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;
}
/**
* 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;
/**
* Top most element z index value, start by 10
*/
var zindex: number;
/**
* Base abstract class for tag implementation, any AFX tag should be
* subclass of this class
*
* @export
* @abstract
* @class AFXTag
* @extends {HTMLElement}
*/
abstract class AFXTag extends HTMLElement {
/**
* The announcer object of the tag
*
* @type {API.Announcer}
* @memberof AFXTag
*/
observable: API.Announcer;
/**
* Reference to some of the tag's children
* element. This reference object is built
* based on the `ref` property found in the
* tag layout [[TagLayoutType]]
*
* @protected
* @type {GenericObject<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 {
/**
* 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 {
/**
* 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 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;
/**
* Init window tag
* - `shown`: false
* - `isMaxi`: false
* - `minimizable`: false
* - `resizable`: true
* - `apptitle`: Untitled
*
* @protected
* @memberof WindowTag
*/
protected init(): void;
/**
* Do nothing
*
* @protected
* @memberof WindowTag
*/
protected calibrate(): void;
/**
* Do nothing
*
* @protected
* @param {*} [d]
* @memberof WindowTag
*/
protected reload(d?: any): void;
/**
* Setter: Set the window width
*
* Getter: Get the window width
*
* @memberof WindowTag
*/
set width(v: number);
get width(): number;
/**
* Setter: Set the window height
*
* Getter: Get the window height
*
* @memberof WindowTag
*/
set height(v: number);
get height(): number;
/**
* Setter: enable/disable window minimizable
*
* getter: Check whether the window is minimizable
*
* @memberof WindowTag
*/
set minimizable(v: boolean);
get minimizable(): boolean;
/**
* Setter: enable/disable widow resizable
*
* Getter: Check whether the current window is resizable
*
* @memberof WindowTag
*/
set resizable(v: boolean);
get resizable(): boolean;
/**
* Setter: Set the window title
*
* Getter: Get window title
*
* @memberof WindowTag
*/
set apptitle(v: string | FormattedString);
get apptitle(): string | FormattedString;
/**
* Resize all the children of the window based on its width and height
*
* @private
* @memberof WindowTag
*/
private resize;
/**
* Mount the window tag and bind basic events
*
* @protected
* @returns {void}
* @memberof WindowTag
*/
protected mount(): void;
/**
* Set the window size
*
* @private
* @param {GenericObject<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 namespace OS {
namespace GUI {
namespace tag {
/**
* A tile layout organize it child elements
* in a fixed horizontal or vertical direction.
*
* The size of each child element is attributed based
* on its configuration of automatically based on the
* remaining space in the layout
*
*
* @export
* @class TileLayoutTag
* @extends {AFXTag}
*/
class TileLayoutTag extends AFXTag {
/**
*C reates an instance of TileLayoutTag.
* @memberof TileLayoutTag
*/
constructor();
/**
* Do nothing
*
* @protected
* @memberof TileLayoutTag
*/
protected init(): void;
/**
* Do nothing
*
* @protected
* @param {*} [d]
* @memberof TileLayoutTag
*/
protected reload(d?: any): void;
/**
* Setter: Set the name of the tile container, should be: `hbox` or `vbox`
*
* Getter: Get the name of the tile container
*
* @memberof TileLayoutTag
*/
set name(v: string);
get name(): string;
/**
* Setter:
*
* SET the layout direction, should be:
* - `row`: horizontal direction
* - `column`: vertical direction
*
* Getter:
*
* Get layout direction
*
* @memberof TileLayoutTag
*/
set dir(v: "row" | "column");
get dir(): "row" | "column";
/**
* Mount the element
*
* @protected
* @returns {void}
* @memberof TileLayoutTag
*/
protected mount(): void;
/**
* re-organize the layout
*
* @returns {void}
* @memberof TileLayoutTag
*/
calibrate(): void;
/**
* Organize the layout in horizontal direction, only work when
* the layout direction set to horizontal
*
* @private
* @returns {void}
* @memberof TileLayoutTag
*/
private hcalibrate;
/**
* Organize the layout in vertical direction, only work when
* the layout direction set to vertical
*
* @private
* @returns {void}
* @memberof TileLayoutTag
*/
private vcalibrate;
/**
* Layout definition
*
* @returns
* @memberof TileLayoutTag
*/
layout(): {
el: string;
ref: string;
}[];
}
/**
* A HBox organize its child elements in horizontal direction
*
* @export
* @class HBoxTag
* @extends {TileLayoutTag}
*/
class HBoxTag extends TileLayoutTag {
/**
* Creates an instance of HBoxTag.
* @memberof HBoxTag
*/
constructor();
/**
* Mount the tag
*
* @protected
* @memberof HBoxTag
*/
protected mount(): void;
}
/**
* A VBox organize its child elements in vertical direction
*
* @export
* @class VBoxTag
* @extends {TileLayoutTag}
*/
class VBoxTag extends TileLayoutTag {
/**
*Creates an instance of VBoxTag.
* @memberof VBoxTag
*/
constructor();
/**
* Mount the tag
*
* @protected
* @memberof VBoxTag
*/
protected mount(): void;
}
}
}
}
/// <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 {GenericObject<any>}
* @memberof ButtonTag
*/
data: GenericObject<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);
/**
* 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 {
/**
* 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 {
/**
* 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}
* @memberof ListViewItemTag
*/
protected abstract itemlayout(): TagLayoutType;
/**
* This function is called when the item data is changed.
* It should be implemented in all subclass of this class
*
* @protected
* @abstract
* @memberof ListViewItemTag
*/
protected abstract ondatachange(): void;
}
/**
* The layout of a simple list item contains only a
* AFX label
*
* @export
* @class SimpleListItemTag
* @extends {ListViewItemTag}
*/
class SimpleListItemTag extends ListViewItemTag {
/**
*Creates an instance of SimpleListItemTag.
* @memberof SimpleListItemTag
*/
constructor();
/**
* Reset some property to default
*
* @protected
* @memberof SimpleListItemTag
*/
protected init(): void;
/**
* Do nothing
*
* @protected
* @memberof SimpleListItemTag
*/
protected calibrate(): void;
/**
* Refresh the inner label when the item data
* is changed
*
* @protected
* @returns {void}
* @memberof SimpleListItemTag
*/
protected ondatachange(): void;
/**
* Re-render the list item
*
* @protected
* @memberof SimpleListItemTag
*/
protected reload(): void;
/**
* List item custom layout definition
*
* @protected
* @returns {TagLayoutType}
* @memberof SimpleListItemTag
*/
protected itemlayout(): TagLayoutType;
}
/**
* This tag defines a traditional or a dropdown list widget.
* It contains a collection of list items in which layout
* of each item may be variable
*
* @export
* @class ListViewTag
* @extends {AFXTag}
*/
class ListViewTag extends AFXTag {
/**
* placeholder of list select event handle
*
* @private
* @type {TagEventCallback<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;
/**
* 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 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 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
*
* @private
* @param {TagEventType} e tag event object
* @returns
* @memberof ListViewTag
*/
private idbclick;
/**
* This function triggers the list item select event
*
* @private
* @param {TagEventType} e tag event object
* @returns
* @memberof ListViewTag
*/
private iselect;
/**
* Mount the tag and bind some basic event
*
* @protected
* @returns {void}
* @memberof ListViewTag
*/
protected mount(): void;
/**
* This function triggers the item close event
*
* @private
* @param {TagEventType} e tag event object
* @returns {void}
* @memberof ListViewTag
*/
private iclose;
/**
* Show the dropdown list.
* This function is called only when the list is a dropdown
* list
*
* @protected
* @param {*} e
* @returns {void}
* @memberof ListViewTag
*/
protected showlist(e: any): void;
/**
* Hide the dropdown list.
* This function is called only when the list is a dropdown
* list
*
* @protected
* @param {*} e
* @memberof ListViewTag
*/
protected dropoff(e: any): void;
/**
* calibrate the list layout
*
* @protected
* @returns {void}
* @memberof ListViewTag
*/
protected calibrate(): void;
/**
* List view layout definition
*
* @protected
* @returns {TagLayoutType[]}
* @memberof ListViewTag
*/
protected layout(): TagLayoutType[];
}
}
}
}
declare namespace OS {
namespace GUI {
namespace tag {
/**
* 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;
/**
* 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;
/**
* Refresh the pinned applications menu
*
* @private
* @memberof SystemPanelTag
*/
private RefreshPinnedApp;
/**
* Check if the loading tasks ended,
* if it the case, stop the animation
*
* @private
* @memberof SystemPanelTag
*/
private animation_check;
/**
* Mount the tag bind some basic event
*
* @protected
* @memberof SystemPanelTag
*/
protected mount(): void;
}
}
}
}
declare namespace OS {
namespace GUI {
/**
* Tab container data type definition
*
* @export
* @interface TabContainerTabType
*/
interface TabContainerTabType {
/**
* Reference to the DOM element of the current container
*
* @type {HTMLElement}
* @memberof TabContainerTabType
*/
container: HTMLElement;
[propName: string]: any;
}
namespace tag {
/**
* A tab container allows to attach each tab on a [[TabBarTag]]
* with a container widget. The attached container widget should be
* composed inside a [[HBoxTag]]
*
* The tab bar in a tab container can be configured to display tabs
* in horizontal (row) or vertical (column) order. Default to vertical order
*
* Once a tab is selected, its attached container will be shown
*
* @export
* @class TabContainerTag
* @extends {AFXTag}
*/
class TabContainerTag extends AFXTag {
/**
* Reference to the currently selected tab DOM element
*
* @private
* @type {TabContainerTabType}
* @memberof TabContainerTag
*/
private _selectedTab;
/**
* Placeholder of the tab select event handle
*
* @private
* @type {TagEventCallback<TabContainerTabType>}
* @memberof TabContainerTag
*/
private _ontabselect;
/**
*Creates an instance of TabContainerTag.
* @memberof TabContainerTag
*/
constructor();
/**
* Init the tab bar direction to vertical (column)
*
* @protected
* @memberof TabContainerTag
*/
protected init(): void;
/**
* Do nothing
*
* @protected
* @param {*} [d]
* @memberof TabContainerTag
*/
protected reload(d?: any): void;
/**
* Set the tab select event handle
*
* @memberof TabContainerTag
*/
set ontabselect(f: TagEventCallback<TabContainerTabType>);
/**
* Get all tab items in the container
*
* @readonly
* @type {TabContainerTabType[]}
* @memberof TabContainerTag
*/
get tabs(): TabContainerTabType[];
/**
* Select a tab by its index
*
* @memberof TabContainerTag
*/
set selectedIndex(i: number);
/**
* Setter:
*
* Set the tab bar direction:
* - `row`: horizontal direction
* - `column`: vertical direction
*
* Getter:
*
* Get the tab bar direction
*
* @memberof TabContainerTag
*/
set dir(v: "row" | "column");
get dir(): "row" | "column";
/**
* Setter:
*
* Select a tab using the its tab data type.
* This will show the attached container to the tab
*
* Getter:
*
* Get the tab data of the currently selected Tab
*
* @memberof TabContainerTag
*/
set selectedTab(v: TabContainerTabType);
get selectedTab(): TabContainerTabType;
/**
* Set the tab bar width, this function only
* works when the tab bar direction is set to
* `row`
*
* @memberof TabContainerTag
*/
set tabbarwidth(v: number);
/**
* Set the tab bar height, this function only works
* when the tab bar direction is set to `column`
*
* @memberof TabContainerTag
*/
set tabbarheight(v: number);
/**
* Add a new tab with container to the container
*
* item should be in the following format:
*
* ```ts
* {
* text: string,
* icon?: string,
* iconclass?: string,
* container: HTMLElement
* }
* ```
*
* @param {GenericObject<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[];
}
}
}
}
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;
/**
* Reference to the currently selected file meta-data
*
* @private
* @type {API.FileInfoType}
* @memberof FileViewTag
*/
private _selectedFile;
/**
* Data placeholder of the current working directory
*
* @private
* @type {API.FileInfoType[]}
* @memberof FileViewTag
*/
private _data;
/**
* The path of the current working directory
*
* @private
* @type {string}
* @memberof FileViewTag
*/
private _path;
/**
* Header definition of the widget grid view
*
* @private
* @type {(GenericObject<string | number>[])}
* @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 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;
/**
* Get the current selected file
*
* @readonly
* @type {API.FileInfoType}
* @memberof FileViewTag
*/
get selectedFile(): API.FileInfoType;
/**
* Setter:
*
* Set the path of the current working directory.
* When called the widget will refresh the current
* working directory using the configured [[fetch]]
* function
*
* Getter:
*
* Get the path of the current working directory
*
* @memberof FileViewTag
*/
set path(v: string);
get path(): string;
/**
* Setter: Set the data of the current working directory
*
* Getter: Get the data of the current working directory
*
* @memberof FileViewTag
*/
set data(v: API.FileInfoType[]);
get data(): API.FileInfoType[];
/**
* Set the file drag and drop event handle. This allows application
* to define custom behavior of the event
*
* @memberof FileViewTag
*/
set ondragndrop(v: TagEventCallback<DnDEventDataType<TreeViewTag | ListViewItemTag>>);
/**
* 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 in New Issue View Git Blame Copy Permalink