6.1 Widgets and Libraries -- Done
The objectives of this phase are:
- The implementation of the basis of the architecture "Data model" - "Visualization" in the face of the modules of OpenSCADA system: "UI.VCAEngine" - "UI.Vision".
- Implementation of the basic functions of the data model of VCA in the module UI.VCAEngine:
- Organization of the storage of the model data of the module UI.VCAEngine in the databases available in OpenSCADA.
- Writing the scenarios of the data model control of the UI.VCAEngine module by means of the control interface of OpenSCADA.
- Creating an abstract class of widget (VCA::Widget).
- Creating the class of widgets library (VCA::WdgLib).
- Creating the representative classes of the library (VCA::LWidget) and container (VCA::CWidget) widget.
- Creating the business class of the terminal widget (VCA::PrWidget - the final visualization element).
- Creating the primary version of the library of the terminal widget, data model of the visualization primitives.
- Implementation of the basic functions of development framework of user interface in the visualization module UI.Vision:
- Building the basis of the user interface of developing on the QT library.
- Formation of the navigator through the libraries of widgets and tools for their management.
- Building inspector of the widget's attributes.
- Forming the dialogue of the editing the properties of the library.
- Forming the dialogue of the editing widget's properties.
- Formation of the graphic editor of the frames and the basis of the graphic editing of the final visualization elements(primitives).
As the result of our work the modules of the data model (UI.VCAEngine) and visualization (UI.Vision) was created. At this stage, the modules implement the mechanisms of UI elements formation. At next stage these elements will be used to form the full-fledged visualization and control interfaces.
Lets consider the results of the each stage's implementation:
The implementation of the basis of architecture "Data model" - "Presentation(visualization)"
In accordance with the static class diagram (Fig.4.10.1) and general requirements there have been implemented the modules "UI.VCAEngine" and "UI.Vision" for the OpenSCADA system. The "UI.VCAEngine" module implements the VCA data model and is the source for subsequent presentation of these data by different mechanisms of visualization. The "UI.Vision" module provides the means of presentation(visualization), based on QT library of version 4 of the 
Trolltech company.
Connection between the modules of the data model and presentation(visualization) is organized by direct calls (strong links). This method of connection is selected for preliminary abstraction of features of interaction and for concentration on core problems of implementation. Later it is planned the unification and construction of these links through the control interface of OpenSCADA system (weak links). As the result it will be achieved the opportunity of separation the data model and presentation(visualization), with possibility of simultaneous maintenance of different presentation(visualization) mechanisms with the single VCA data model. In addition, it will be possible to estimate the influence of the connection's(link's) type on the performance of the VCA.
Implementation of the basic functions of the VCA data model in the UI.VCAEngine module
The module of the data model(engine) of the VCA contains the container of widgets/frames library. The module provides the predefined library of basic widgets (primitives) with the primary realization of their own properties and processing logic of these properties.
Storage of the widgets' data and widgets' libraries is implemented in the database available in the OpenSCADA system. The database is organized on data ownership to the library. Ie the separate library is stored in the separate group of tables of the one or different databases. The list of libraries of widgets is stored in the index table of the libraries with the name "VCALibs" and with the structure "Libs", of the DB section. A copy of this table is created in each database, which stores data of this module, with the list of libraries contained in the given database. The structure of the tables of the belonging to the library widgets includes:
- {DB_TBL} -- Table of widgets belonging to the library (the structure "LibWigets", of the DB section ).
- {DB_TBL}_io -- Table with working properties of widgets in this library and embedded widgets of the container widgets (structure "LibWidgetIO", of the DB section ).
- {DB_TBL}_uio -- Table with user's properties of widgets of this library and embedded widgets of the container widgets (structure "LibWidgetUserIO", of theDB section ).
- {DB_TBL}_incl -- Table with the list of embedded widgets in the widgets-containers of the library (structure "LibWidgetIncl", of the DB section ).
- {DB_TBL}_mime -- Table with the resources of the library and its widgets (structure "LibWidgetMime", of the DB section ).
To control the widget library and the individual widgets the configuration scripts were written on the language of control interface of ~OpenSCADA. Currently, these scripts are designed to perform only the functions of the central configuration of the VCA engine elements, but later there is plans to expand them and give them the functions of processing requests to the data model from the presentation(visualization) modules to organize the "weak links" between the "Data model" and "Prepresentation(visualization)".
The basis of virtually all elements of the engine has become an object of the abstract visualization element (VCA::Widget). At its, abstract, level the object has the following properties:
- "Using" inheritance - the mechanism of inheritance of individual properties of another instance of the object. It is used for organizing the mechanism of secondary using, redefinition and definition of the elements of visualization.
- Storage the properties(attributes) of widgets with the mechanisms of "using" inheritance of the values. The mechanism of "using" inheritance does the inheritance of the properties' values from the root element and to the top one, with the ability to redefine the values at each level. In this case, the database stores only the values of modified properties.
- Support of the container mode. In this mode, the widget may include other(child) widgets, like the widget library contains widgets. It is used in library widgets that inherit properties of the primitive-container, such as the frame primitive "Box". Also, this property will be used in the session of the project to build the hierarchical tree of widgets(primitives) in the formation of the final image of frames' visualization.
- Support the mode of simple connection. This mode is used for the embedded widgets of the library. The feature of this mode is that it does not inherit the properties of the container, and therefore can not directly contain the embedded widgets (Figure 4.10.2).
- Contains the procedure of the internal logic of the widget on one of the languages of the OpenSCADA system?. The logic of this procedure can be used to organize the interaction of embedded widgets and container with each other to form the desired behavior.
- Providing of access to the resources, mime-data, taking into account the hierarchy of "using" inheritance.
For the presentation of thelibrary of widgets the class (VCA::WdgLib) is implemented. Its main function is to maintain the library of widgets, storage and loading them from the database, providing an access to the resources(Mime-data), as well as the separation of access.
Especially for the inclusion in the library of widgets the class of the library widget (VCA::LWidget) was created, which is based on an abstract widget's class (VCA::Widget) and provides additional functions: storing the widget data in tables of the library, the redefinition of the access to the resources on the table with the mime-data of the library and storage of the embedded container widget (VCA::CWidget).
In its turn, the class of the container widget (VCA::CWidget) provides the following functions: the storage of the container widget's data in the tables of the library, the redefinition of the access to the resources on the table with the mime-data of the library and the forced mode of the simple link for all container widgets.
On the basis of the library widget's class (VCA::LWidget) it was formed an abstract class of the terminal widget (VCA::PrWidget). And on its basis the implementations of primitives of basic widgets are formed, which form the library of basic widgets, which is created by the module at initialization. The values of the properties of the basic widgets, also can be stored in the database (tables of the widget's library), forming the desired templates. In addition, the basic library of primitives can improved by the extended primitives from the modules of the presentation(visualization) interfaces, for which the basic ones are not enough. But in this case it must be taken into account that such action - the way to an incompatibility between the modules of the presentation(visualization) interfaces!
Implementation of basic functions of the development framework of the user interface in the presentation(visualization) module UI.Vision
Interface of the user interfaces' development of the module is based on MDI (Multi Document Interface) interface. This approach allows you to simultaneously edit multiple frames of various sizes. The following arrangements for managing the development are used: the toolbar, menu and context menu. Most actions are duplicated in the different mechanisms, so you can quickly find the tool by the preferred method. Navigation interfaces are implemented by the attachable windows. The configuration of toolbars and attachable windows is saved on exit and restored at startup that lets you to configure an interface for yourself.
One of the elements of the user interface, implemented as the attachable window is the browser of the widget's library. With the browser you can quickly find the widget or the library and do the necessary operations on them. The following operations are implemented: addition, deleting, configuration of widgets and libraries, as well as visual editing of the widget.
For easy management of the properties of widgets/frames the inspector of attributes(properties) of widgets is implemented. Inspector of the attributes is implemented as the attachable window, which is activated when you select the frame or widget. Window of the inspector of attributes can be conveniently positioned by attaching it to one of the sides of working window. Inspector of attributes supports the group configuration of several widgets, as well as the grouping of similar properties.
For visual editing of the frames the primary support for editing of widgets and frames is implemented. In the editor the following functions are implemented:
- selection of widget and group of widgets on the frame;
- moving of widgets through the frame;
- resizing the selected widgets on the frame;
- editing the properties of the selected widgets;
- alignment and management of the levels of visualization of the selected widgets.
Example of the development window is shown in Fig. 6.1.1. At the figure you can see: the toolbar, navigator of widgets, inspector of attributes, editing window of the frame and status bar.
Fig.6.1.1 Development window of the UI.Vision module
To configure the widgets' objects and their libraries the two dialogues are implemented: the dialogue of the widget's configuration (Fig.6.1.2) and the configuration dialog of the widget's library configuration (Fig.6.1.3). The library configuration dialog allows to set the basic properties of the library and put the mime-data in the database for subsequent using in the widgets of the library. Widget's configuration dialog allows you to set: the basic properties of the widget. individually to set the values of attributes and configure the internal procedure for computing the widget with additional(user's) properties.
Fig.6.1.2 Dialog of the widget's library configuration.
Fig.6.1.3 Dialog of the widget's configuration.