Customizing Desktop

Desktop is a complex widget created with Webix Jet, the MV* framework for Webix Library. It is a ready-to-use application that needs minimal configuration and has an API for redefining the logic of inner modules.

Desktop is built as a Jet App and wrapped in a Webix view, so you can initialize it in either way.

Views

The interface of Desktop is split into parts (views). Each view is a class that extends the JetView class and has its own handlers for setting the configuration and logic.

The sources for interface parts (Jet Views) are located in the sources/views folder.

views
  desk.js
  menu.js
  ...

Models/Services

Desktop models contain the logic for loading and storing data, uploading avatars, working with templates etc. They are defined as Jet Services.

The sources for models (Jet Services) are located in the sources/models folder.

models
  Windows.js
  Helpers.js
  Local.js

You can get services using getService() method:

$$('mydesktop').getService('helpers');

When you customize a view, you can:

• override the config() method to change the UI
• override the init() method to change the UI and behavior
• override any existing method, but do it with caution
• add and call your own methods

Check the Class Map to find which view renders the part you want to modify.

To start, create your own view class and inherit it from one of the default views or from desktop.views.JetView:

class MyMenu extends desktop.views["menu"] {
    config() {
        //get JSON object with configuration
        const ui = super.config();
        ... //some changes depending on a particular view
        return ui;
    }
    init() {
        // call default logic
        super.init();
        // custom logic below
        this.doSomething();
    }
    doSomething() {
        // do something on init
    }
}

Then replace the default view via the override map:

webix.ui({
    view: "desktop",
    apps: myApps,
    systemParams: getParams(),
    override: new Map([[desktop.views["menu"], MyMenu]])
})

Notes

Hiding Components

We do not recommend removing any component from the interface as the inner logic might still try accessing it. Instead, hide the components.

class CustomToolbar extends desktop.views["toolbar"] {
    init(view) {
        // default logic
        super.init();
        // hide a button
        view.queryView('button').hide();
    }
}

Accessing Component Instances

Within a Jet view, you can access component instances in two ways.

Use the $$(id) method of JetView for an inner component that has the localId setting:

init() {
    // default logic
    super.init();
    // get instance of the component with "list" localId
    const list = this.$$("list");
}

Use queryView if localId is not defined:

init(view) {
    // default logic
    super.init();
    // get instance of the button
    const button = view.queryView("button");
}

Checking the Compact Mode

You can find out whether the app is currently compact from any view or service method:

const compact = this.getParam('compact', true);

Getting State Properties

You can get state properties from any view or service method:

const state = this.app.getState();
// or
const state = this.getParam('state');

By customizing Jet services, you can add and call your own methods. You can also override any existing method, but you should do it with caution.

The steps are the same as for customizing a view:

• create your own service class and inherit it from one of the default services;
• replace the default service via the override map.

Desktop is flexible. However, keep in mind the following:

• The inner logic of Desktop modules may change in future releases.
• We will try to maintain method signatures, but breaking changes might happen if they are necessary for further development of the widget.