RadixWare Programmer Guide/Definition Types/Application Definition Segment

From RadixWiki
Jump to: navigation, search

All business and presentation logic of the layer is implemented in the ADS segment. This section describes the definition types that can be included in the ADS modules.

Contents

Classes

Since RadixWare is an object-oriented programming environment, class is one of the basic notions which is commonly used. When compiling, RadixWare classes are translated into Java classes. Therefore, RadixWare classes have much in common with Java classes. Each class belongs to the certain runtime environment:

  • Server. The class runs in the RadixWare Server environment.
  • Desktop. The class runs in the RadixWare Explorer environment.
  • Web. The class runs in the RadixWare Web Presentation Server environment.
  • Client-Common. The class can run in any of the environments: Desktop, Web.
  • Common. The class can run in any environment.

The classes that run in the same environment are available for each class.

Example.jpgFor example, the server class cannot use the client classes. The classes that run in the Common environment can be used by both server and client classes. The classes that run in the Client-Common environment can be used by classes that run in the Desktop environment and classes that run in the Web environment.

The classes that represent the database entities always run on the server side, in the database.

Models of presentation definitions always run on the client side.

RadixWare class can have methods and properties.


Definition Context menu

For the common items of the context menu, refer to Definition Context Menu. Specific items of context menu for all definitions of classes are described in the following table:

Menu Item Description
Override… Opens the dialog box for creating the overriding members (refer to "Override Class Member" Dialog Box).
Implement Method/Property… Opens the dialog box for creating the members required by the interfaces that implement the class (refer to "Implement Method/Property" Dialog Box).
Synchronize with Wrapped Class… The menu item is available only for the wrapping classes. Opens the dialog box used to synchronize with wrapped methods of the wrapped class (refer to "Synchronize Class Wrapper" Dialog Box).
Inspect Hierarchy… Opens the Hierarchy pane displaying the inheritance hierarchy for this class (refer to View Hierarchy of Classes).

Class Editor

For the definitions of classes, the definition editor contains several common pages.

"General" Page

The page contains the following common parameters:

  • Description. The description of the purpose of a class.
  • Accessibility. The access mode to the class.
  • Super classes. The parameters group defining the classes the current class is inherited from:
    • Extends. The parent class.
    • Implements. A list of interfaces implemented by this class.
  • Upload mode. The mode of uploading the class to the ARTE. Available values:
    • On demand. The class will be uploaded the first time it is called. This can increase the response time the first time the class is called.
    • On startup. This class and all the classes used by it will be uploaded when the ARTE is loaded. This can increase the ARTE load time, but decrease the response time the first time the class is called.


"Header" Page

The page is used to define the code that will be inserted into the class header. Usually, this facility is used when the class must import some Java packages. The code inserted into the class header for each environment includes the code fragments meant for this environment. The page looks as follows:

Class-header.jpg

The left side of the page is used to define the list of fragments the code consists of. The control buttons are described in the following table:

Button Name Description
Add-anc.png Add new source part Creates a new code fragment.
Remove-anc.png Delete source part Deletes the selected fragment code.
Move-up.png Move source part up Moves the selected code fragment up in the list.
Move-down.png Move source part down Moves the selected code fragment down in the list

The right side of the page contains the fragment code with the following parameters:

  • Hint. The description of the code fragment displayed in the list. If the parameter is not defined, the list displays "Part #<number>".
  • Environment. The environment which the code fragment is meant for. Available values:
    • Client-Common. The code must be used for both client environments (Explorer or Web).
    • Explorer. The code must be used for the RadixWare Explorer environment.
    • Web. The code must be used for the RadixWare Web Presentation Server environment.

The parameter is available if the class is meant for the Client-Common environment and the Separate Client Runtime flag is set (refer to Dynamic Classes). Moreover, the parameter is available for the classes of the presentation models, forms and branches. For other classes, all the code fragments are meant for the same environment the class is meant for.


"Body" Page

The page is used to define the JML code inserted into the class body. The page functions are the same as those of the Header page.

"Override Class Member" Dialog Box

The Override Class Member dialog box enables to override members defined in the parent classes.

To open the dialog box, select the Override item from the class context menu in RadixWare Designer navigation tree.

Override-class-member-dialog.jpg

The dialog box contains the list of all parent class members that can be overridden (they have the access mode different from Private or Protected). Next to each member, there is a flag.

Clicking the OK button will create the overridden members marked with flags. The created members do not perform any actions except for calling the respective parent class members.

"Implement Method/Property" Dialog Box

The Implement Method/Property dialog box enables to implement the methods of interfaces implemented by the class.

To open the dialog box, select the Implement Method/Property item from the class context menu in RadixWare Designer navigation tree.

Implement-method-dialog.jpg

The dialog box contains the tree displaying the interfaces implemented by this class, their methods and properties. Next to each definition in the tree, there is a flag. Setting the flag for the interface automatically sets the flag for all its methods and properties. Clicking the OK button will implement all methods and properties marked with flags in the class.

"Synchronize Class Wrapper" Dialog Box

The Synchronize Class Wrapper is used to add the methods of the wrapped class in the class wrapper or exclude the existent wrapped methods.

To open this dialog box, select the Synchronize with Wrapped class item from the wrapped class context menu in RadixWare Designer navigation tree.

Sync-publihsed-class.png

The dialog box contains the table displaying the methods of the wrapped class. The table contains the following columns:

  • Platform Class Members. The method of the wrapped class.
  • Wrap. If the flag is set, the class method will be wrapped. If the flag is set, it is not possible to cancel this action. To exclude the method wrapping, set the flag in the Delete column.
  • Delete . If the flag is set, the method publishing will be deleted. The flag is not available if the flag in the Wrap column is not set.
  • Radix Class Members. RadixWare class wrapper method.

Clicking the OK button will create the method wraps marked with flags in the Wrap column and delete the method wraps marked with flags in the Delete column.

Methods

The class methods in RadixWare are similar to methods in Java. For each method, RadixWare Designer enables to define the scope (public, private, protected) and the flags: abstract, static, final, deprecated. The method body is implemented in JML.

The class methods executed on the client side and compatible with both runtime environments can be compatible only with one of the runtime environments or have different bodies for different runtime environments. Some of the methods are the constructors of dynamic classes.


Method Profile

The profile includes the general information about the method:

  • The method name.
  • A set of parameters. The name, type and description is stored for each parameter.
  • The type of the return value and its description.
  • The method description.


Definition Context Menu

The common context menu items are described in Definition Context Menu. The specific context menu items for the method definitions are described in the following table:

Menu Item Description
Profiling settings… Opens the dialog box of profiling settings for this method (refer to "Profiling Settings" Dialog Box).
Call Hierarchy... Opens the Call Hierarchy pane displaying the call hierarchy of this method (refer to View Hierarchy of Calls).
Change profile… Opens the dialog box used to set up the method profile (refer to Edit Method Profile).
Toggle breakpoint Enables / disables the breakpoint when entering this method.

Method Editor

The method editor looks as follows:

Method-editor.jpg

The editor contains the following parameters:

  • Method profile. Clicking the parameter opens the dialog box where it is possible to change the method profile (refer to Edit Method Profile).
  • Accessibility. The access mode to the method. Refer to Select Access Mode.
  • Reflective callable. If the flag is set, the method can be called by means of the reflection mechanism.
  • Override. The flag must be set for the methods overriding the parent class methods. Small-edit-definition.png and Small-goto-definition.png next to the parameter used to open the overridden method editor and select the overridden method respectively in RadixWare Designer navigation tree.
  • Overwrite. The flag must be set for the methods overwriting the overwritten class methods. Small-edit-definition.png and Small-goto-definition.png next to the parameter used to open the overwritten method editor and select the overwritten method in RadixWare Designer navigation tree.
  • Environment. The runtime environment for this method. Available values:
    • Client-Common. The method can be executed in any client environment.
    • Desktop. The method must be executed in RadixWare Explorer environment.
    • Web. The method must be executed in RadixWare Web Presentation Server environment.

It is displayed only for the methods of dynamic classes the Environment parameter of which has the Client-Common value.

  • Command. The full name of the command processed by this method. Small-edit-definition.png and Small-goto-definition.png next to the parameter used to open the command editor and select the command respectively in RadixWare Designer navigation tree. The parameter is displayed only for the methods which are command handlers. The parameter is not editable.
  • Widget, Signal. The name of the widget invoking the signal; the name of the signal. The parameters are displayed only for the methods which are event handlers in the dialog boxes and user widgets. The parameter is not editable.
  • Separate source code for Web and Desktop client. If the flag is set, the separate method body is defined for each of possible runtime environments. The parameter is available if the following conditions are fulfilled:
    • The Environment parameter has the Client-Common value in the class editor the method belongs to (refer to Dynamic Classes).
    • The Separate Client Runtime flag is set in the class editor the method belongs to.
    • The Environment method parameter has the Client-Common value.
  • JML Editor where the method body is edited. If the Separate source code for Web and Desktop client flag is set, two pages Explorer and Web are displayed.

"Profiling Settings" Dialog Box

The dialog box is used to select the timing section (refer to Profiling) the method must refer to. To open the dialog box, select the Profiling Settings item from the method context menu in RadixWare Designer navigation tree.

Profiling-settings-dialog.jpg

The dialog box contains the Timing section parameter. The parameter defines the timing section the method refers to. The value is selected from the predefined list.

Edit Method Profile

The Profile Editor dialog box is used to edit the method profile. The similar dialog box is used when creating the method. To open the dialog box, select the Change profile item from the method context menu in RadixWare Designer navigation tree.

Edit-method-profile.jpg

The dialog box contains the following parameters:

  • Name. The name of the method.
  • Return type. The type of the return value. Clicking the parameter or Dots.jpg next to it opens the dialog box for selecting the type (refer to Select Type). The Edit return value description button (Small-edit-definition.png) opens the dialog box used to edit the description of the return value. The Set return value type to "void" button (Profile-void-type.png) specifies the void type for the return value.
  • Parameters. A set of method parameters. For each parameter, the name, type and description are defined.
  • Thrown exceptions. A set of exceptions this method can invoke. For each possible exception, its type and description are defined.
  • Description. The method description.
  • API usage variant. The variant of using the method. The parameter value increases when the method works in an entirely different way if other attributes of the method profile are not changed at that.

To compare the method profile with the overridden method profile, click the Check overridden profile button. If the differences are detected, the respective message is displayed.

Properties

The property is a class field that can be used to store some attribute of this class. Some of the properties are persistent (i.e. they are stored in the database), others are dynamic ones. For all properties the developer can override get- and set- methods. The definition of the property describes the presentation of the property as well:


Inheritance of Property Values

If there is a relation between two objects, it makes sense not to define the values of some properties of the child object and take these values from the parent object properties.

Example.jpgLet's assume that the application has two entities: "Contract Type" and "Contract", and several contracts belong to one contract type. Then, it can be convenient to take some contract properties from the properties of the contract type. Therefore, the fees can be defined in the contract type or in the contract itself. If the fee is defined in the contract, this value must be used; otherwise - the value defined in the contract type must be used.

To solve this task, RadixWare enables to describe the inheritance of property values. For any persistent property, it is possible to define the rules according to which the property value must be inherited and the conditions that determine if it is necessary to use explicitly defined or inherited value. If several inheritance paths of the value are defined for the property, these paths are tried over by way of defining: if the attempt to receive the value by the first path failed, the second path will be checked, etc.


Types of properties

  • Dynamic properties. The class values which are not persistent, i.e. they are not stored in the database.
  • Column-based properties (innate properties). The properties of entity classes and application classes stored in the columns of a respective table.
  • Detail properties. The properties of the application classes stored in the columns of detail-tables.
  • User properties. The properties of entity classes and application classes stored in a separate database table. They are used when it is required to add the column-based property to the class without changing the structure of the respective table. Moreover, the additional Object data type is supported for user-defined properties. The properties of such type are stored in the records of special tables.
  • Parent properties. The properties of entity classes and application classes stored in the columns of the "parent" table (associated with this table by the "one-to-many" reference) or "predecessor"-table (for example, the table that is parent towards the parent table of this table).
  • Parent references. The properties of entity classes and application classes created by the reference between tables and providing the access to the related objects.

Example.jpgFor example, if the Employee entity class has the deptId column-based property that is a reference (foreign key) to the table row presented as the Department entity class, the department reference of the Employee entity class can present the Department class instance that the reference between tables refers to.

  • SQL-expression properties. The properties the values of which are calculated by means of the SQML expression defined by the developer. Later, it is possible to change the value of such property in a usual way but the value will not be saved in the database.
  • Presentation of properties. They are used in the client classes to work with the properties defined in the server classes. For details, refer to Presentations.

Some types of classes can also have the properties of the specific types.

Property Editor

The editor contains the Main, Inheritance and Presentation pages. For different property types, the editor can include additional pages.


"Main" Page

The page contains the following parameters:

  • Description. The description of the purpose of a property.
  • Accessibility. The access mode to the property. Refer to Select Access Mode.
  • Overwriting. The flag must be set for the properties that overwrite the properties of the overwritten class.
  • Overriding. The flag must be set for the properties that override the parent class properties of the same name.
  • Deprecated. If the flag is set, the property is considered deprecated. When compiling, the system will display a warning message each time such property is used.
  • Read only. If the flag is set, the property is read-only.
  • Type. The property type.
  • Init value. The initial value of the property.


"Inheritance" Page

The page is used to define the inheritance parameters of the value:

  • Allow value inheritance. If the flag is set, the inheritance of property values is available. If the flag is not set, the rest parameters on this page are not available.
  • Value initialization mode. The parameter determines if the property value must be defined when creating the object. Available values:
    • Don’t define. Does not define the property value.
    • Define if not inherited. Defines the property value if it was not inherited
    • Define always. Defines the property value always.
  • Value triggering inheritance. The property value specifying that the actual value must be inherited.

The following parameter is used to define the list of inheritance paths of the property value.


"Presentation" Page

The page contains the following parameters:

  • Presentable. If the parameter is not set, the property cannot be used in presentations.
  • Title. The title of the property in the supported languages.
  • Hint. The text of the pop-up hint for the property in the supported languages.
  • Editing. The parameters determine the way of editing the property from the client application:
    • Inherit. If the flag is set, the parameters are inherited from the overridden or overwritten property. The parameter is not available if the property does not override or overwrite another property.

*Display instead of <Not defined>. The text to be displayed instead of the property value when the latter is not defined.

    • The Edit mask button opens the input mask editor (refer to Input Mask Editor).
    • Custom dialog. The user editor for the property.
    • Not Null. If the flag is set, the property cannot be set to null.
    • Memo. If the flag is set, the multiline input field will be used for editing.
    • Store edit history. If the flag is set, the history of editing the values will be saved for the property.
    • Read Separately. If the flag is set, the property values will be read in a separate request when calling the property. It makes sense for the columns storing large data volume or calculated columns the calculation of which takes much time.
    • Title. The title of the property. The value can be inherited from the class the reference to which is a property or it can be inherited from the base class.
    • Hint. The po-pup hint for the property. The value can be inherited from the class the reference to which is a property or from the base class.
    • Edit possibility. Determines when it is possible to edit the property value. Available values:
      • Always. The property value is always editable.
      • Never. The property value is not editable.
      • Only existing. The property value is editable only if the object already exists.
      • Only in editor. The property value is editable only in the editor (not in the selector).
      • Only at creation. The property value is defined at object creation and then, is not editable.
      • Programmatically. The property value can be changed programmatically.


"Parent Ref" Page

The page is displayed only for the properties of the Parent Ref type.

The page contains the following parameters:

  • Parent selector presentation. The selector presentation that must be used to select the property value. It can be inherited from the base presentation.
  • From, Where. The FROM and WHERE clauses of SQL query that is used to select available values of the property. They can be inherited from the selector presentation specified in the Parent selector presentation parameter.
  • Format titles. The format of the object title. It can be inherited from the class.


"Restrictions" Page

The page is displayed only for the properties of the Parent Ref type.

The page contains the following parameters:

  • Parent selector prohibited actions. The operations that must be prohibited in the selector of parent object.
  • Parent editor prohibited actions:
    • Update. If the flag is set, the parent object is not editable.
    • Commands. If the flag is set, it is prohibited to call the commands for the parent object.

Input Mask Editor

The input mask editor looks as follows:

Input-mask-editor.jpg

The input mask editor contains the Use default mask flag, the radio button for selecting the mask type and parameters depending on the mask type. If the Use default mask flag is set, the default input mask will be used (depending on the field type), other parameters are not editable.

Some of the mask types are not available depending on the property type.

For some mask types, the Reset to DB restrictions button is displayed in the right side of the editor. The button sets the restriction on the input mask according to the restrictions on the value of the respective column in the database table (the restriction is defined in the table definition). The button is not available for the dynamic properties.

The parameters displaying to the right of the editor depending on the mask type are described below.


"Integer" Mask Type

The input mask type is used to enter the integer numbers. The right side of the dialog box contains the following parameters:

  • Number base. The number system base in which the number must be entered.
  • Minimum length. If the flag is set, specify the minimum length of the number and a pad character (the Pad character parameter).
  • Minimum value, Maximum value. The minimum and maximum number to be entered.
  • Step size. The interval by which the entered number can be changed using the buttons.
  • Triad delimiter type. The way the digits are separated. Available values:
    • None. Does not separate the digits.
    • Use locale defaults. Separates digits according to the user locale.
    • Specify. Uses the delimiter specified in the Triad delimiter parameter.


"Real number" Mask Type

The input mask type is used to enter the real numbers (arbitrary precision). The right side of the dialog box contains the following parameters:

  • Precision. The number of decimal places that can be entered.
  • Minimum value, Maximum value. The minimum and maximum number to be entered.
  • Scale. The multiplier for the entered value (for example, if Scale parameter is set 2, and the entered value is 7, the property value will be 3.5)
  • Triad delimiter type. The way the digits are separated. Available values:
    • None. Does not separate the digits.
    • Use locale defaults. Separates digits according to the user locale.
    • Specify. Uses the delimiter specified in the Triad delimiter parameter.


"String" Mask Type

The input mask type is used to enter the character strings. The right side of the dialog box contains the following parameters:

  • Qt mask. The current input mask in the format used by Qt. Refer to Qt 4.5: Qt Reference Documentation.
  • 'Do not use blank characte'r. If the flag is set, the blank characters will be deleted from the property value when saving it.

Example.jpgFor example, if the "-" blank character is defined in the mask, the --A---B---- string will be saved as the "AB". If the flag is not set (by default), the property value will be saved with blank characters. For example, the --A---B---- string will be saved as it is.

  • Password. If the flag is set, the characters entered into the input field will be displayed as asterisks. This makes sense for the properties containing the passwords and other confidential information.
  • Keep separators. If the flag is set, the separators defined by the input mask will be saved in the property value.

Example.jpgFor example, let the "ddd-dd-dd" input mask be defined and the user entered the "396-15-13" value". Then, if the Keep separators flag is set, the "396-15-13" value will be saved. If the flag is not set, the "3961513" will be saved.

  • Maximum length. The maximum length of the string being entered (by default - 1).


"Date/Time" Mask Type

The input mask is used to enter the date and time. The right side of the dialog box contains the following parameters:

  • Date style. The format of displaying the date. Available values:
    • Do not show. The date is not displayed.
    • Default. The default date format according to the user locale.
    • Short. The short date format according to the user locale.
    • Medium. The medium date format according to the user locale.
    • Long. The long date format according to the user locale.
    • Full. The full date format according to the user locale.
    • User defined. The date and time format specified in the Custom Qt mask parameter.
  • Time style. The format of displaying the time. Available values:
    • Do not show. The time is not displayed.
    • Default. The default time format according to the user locale.
    • Short. The short time format according to the user locale.
    • Medium. The medium time format according to the user locale.
    • Long. The long time format according to the user locale.
    • Full. The full time format according to the user locale.
    • User defined. The date and time format specified in the Custom Qt mask parameter.
  • Custom Qt mask. The mask of the date and time input in the format used by Qt (refer to Qt 4.5: Qt Reference Documentation). The parameter is available if the User defined format is selected in the Date style and Time style parameters.


"Time Interval" Mask Type

The mask type is used to enter the time intervals. The right side of the dialog box contains the following parameters:

  • Scale. The precision with which the interval must be set (the default value is seconds)
  • Qt mask. The input mask in the format used by Qt (refer to Qt 4.5: Qt Reference Documentation). If the Auto flag is set, the input mask will be set automatically.
  • Minimum value in seconds, Maximum value in seconds. The minimum and maximum length of the time interval.


"List" Mask Type

The input mask type can be used to enter any values. The user will be offered to select one value from the defined list.

To the right of the editor, there is a list with two columns (Value and Title) and a set of buttons: Add Row, Delete Row, Raise Selected Row, Lower selected row. These buttons are used to define a set of values that must be available for the user to select. If required, it is possible to define the value names in any supported language.


"Enumeration" Mask Type

The mask type is used to enter the values of enumeration type. The right side of the dialog box contains the following parameters:

  • Sort by. The order of enumeration values in the list from which the user must select the required value. Available values:
    • Order. The options are arranged in the order defined in the definition of enumeration.
    • Title. The options are sorted by titles.
    • Value. The options are sorted by values.
  • Item list correction. The parameter prohibits to select some options. Available values:
    • None. All options will be available for the user.
    • Exclude. The options marked with a flag in the list below will be not available for the user.
    • Include. Only the options marked with a flag in the list below are available for the user.

Types of Classes

Dynamic Classes

Dynamic classes in RadixWare are the classes that do not have persistent (stored in the database) properties. They correspond to the usual Java classes.

The dynamic class can be executed on the server side (server class), on the client side (explorer class, web class, client-common class) or in any environment (common class).

The dynamic class can have only methods and dynamic properties.


Dynamic Class Editor

The parameters common for the editors of all classes are described in Class Editor.

The General page in the definition editor of the dynamic class contains the following specific parameters:

  • Environment. The runtime environment where this class must be executed. Available values:
    • Desktop. The class must be executed in RadixWare Explorer environment.
    • Server. The class must be executed in RadixWare Server environment.
    • Common. The class can be executed in any environment.
    • Client-Common. The class can be executed in any client environment (Desktop or Web).
    • Web. The class must be executed in RadixWare Web Presentation Server environment.
  • Type arguments. A set of generic type parameters of this class.
  • Title. Class header in the languages supported by the layer.
  • Separate client runtime. If the flag is set, separate runtime files will be generated for this class for the Desktop and Web runtime environments. The parameter is available if the Environment parameter has the Client-Common value.

Interfaces

The interfaces in RadixWare are similar to those in Java. An interface declares that the classes implementing it must have a certain set of methods. Any class can implement one or several interfaces.


Interface Editor

The editor is similar to the editors of dynamic classes (refer to Dynamic Classes). Unlike the editor of dynamic classes, the interfaces editor does not have the Extends parameter.

Exception Classes

The exception classes are used to describe the non-standard types of exceptional cases. The exception classes in RadixWare are similar to dynamic classes.

The exception class can have the methods and dynamic properties.


Exception Class Editor

The editor is identical to the editor of dynamic classes (refer to Dynamic Classes).

Test Classes

The test classes are used to support the module testing of applications on the RadixWare platform. All test classes are the descendants of the Radix::Testing::TestCase class. The test class must override the execute() method returning the value of the Radix::Arte::EventSeverity type (this is a numeration containing such values as None, Alarm, Warning, Error, etc.) or throwing the exception.

The test class can be created only in the module marked as a test module.

The information about the test start (startup time, startup result, error message, etc.) is stored in the database. The tests are started by the user from RadixWare Explorer and automatically on the integration server.


Test Class Editor

The editor is identical to the editor of dynamic classes (refer to Dynamic Classes).

Entity Classes

The entity class is created on the basis of a table and encapsulates working with the table. Therefore, an entity class represents the database table in the product model.

The entity classes are descendants of Radix::Types::Entity class.

The entity class can contain:

  • methods
  • dynamic properties
  • column-based properties
  • parent properties
  • user properties
  • SQL-expression properties

The entity class based on the polymorphic table has access only to the columns of master table, but not to the columns of detail tables. RadixWare Designer enables to prohibit some operations on the entity class instances:

  • copying
  • multiple copying
  • creating
  • moving
  • deleting
  • editing


Definition context menu

Common items of definition context menu are described in Definition Context Menu.

The table below provides the specific context menu items of definitions of entity classes:

Menu Item Description
Create Command Handlers… Opens the dialog box for creating the command handler methods.
Update Rights System Presentations Recreates the editor presentations and server methods for the specified entities according to the access partition family defined in the layer. It is available only for the classes Radix::Acs::User2Role, Radix::Acs::UserGroup2Role and their overridings in the overlying layers.
Create/Update Instance Loading Methods Explicitly defines the methods for loading the class instance from the database.
Set up Column-Based Properties Opens the dialog box for synchronizing the table columns (refer to Dialog Box for Synchronizing Table Columns).
Create Entity Group Creates a class of entity groups based on this class in the same module (refer to Classes of Entity Groups).
Create Presentation Entity Adapter Class Creates the presentation adapter class based on this class in the same module (refer to Presentation Adapter Classes).

Entity Class Editor

The parameters common for the editors of all classes are described in Class Editor.

The entity class editor contains the specific parameters on the General page and additional on the Presentation and Access Areas pages.


"General" Page

The page contains the following specific parameters:

  • Client Environment. The environment for which the runtime files of the model classes for presentations having the set Use Default Model flag must be generated (refer to Editor of Selector Presentation, Editor Of Editor Presentation). Available values:
    • Client-Common. Generates runtime files for the Desktop and Web environments.
    • Desktop
    • Web
  • Table. The definition of the database table the current entity class is based on.
  • Prohibited actions. The flags prohibit to execute the respective commands on the instances of this entity class from the client application:
    • Copy
    • Multiple copy
    • Create
    • Move
    • Delete
    • Update
  • Allowed details. A list of the detail tables that must be available when creating the column-based properties of this class and its descendants. The parameter is displayed only for the entity classes based on the polymorphic tables.


"Presentation" Page

The page is used to define the parameters concerning the presentation of this entity class in the client application:

  • Title for singular, Title for plural. The name of the instances of this class in singular and plural respectively, on all the languages supported by the layer.
  • Icon. The icon that will be used to present the class in the client application.
  • Default selector presentation. The default presentation of the class.
  • Object title format. The template according to which the class instance name will be created. Each line of the list defines the property of the class instance that must be displayed in the instance name and the template according to which the property value must be formatted. To format the displayed values, the templates supported by the java.text.MessageFormat standard Java library are used. The special dialog box for editing the templates displays the examples of using the template. For details on the format of templates, refer to the java.text.MessageFormat library documentation.
  • Display instead of null. The note (in the languages supported by layer) that must be displayed in the client application, in the fields used for the instances of this class when the value is not defined.


"Access Areas" Page

The page is used to define the access areas for this class. If No is selected in the Access areas definition mode list, the access areas for the class are not defined. Otherwise, the list of access areas and a set of buttons to manage the list are displayed below:

  • Add Access Area. The user is asked to enter the name of the access area.
  • Add Access Partition. Adds the condition of creating the access area. In the dialog box that will open, it is required to specify the reference of this entity class to some access partition family.
  • Edit. Edits the selected item.
  • Delete. Deletes the selected item. The user is asked to confirm the action.
  • Attach Children. Adds the access areas associated with the current access partition family to all referred (child) classes.
  • Detach Children. Deletes the access area associated with the current access partition family from all referred (child) classes.

Example.jpgTo provide the administrator with the facility to restrict the access to the user accounts by groups, perform the following:

  1. Open the class editor Radix::Acs::User on the Access Areas page.
  2. In the Access areas definition mode list select Own.
  3. Click the Add Access area button and in the dialog box that will open, enter the name, for example, "UserGroup".
  4. Select the newly displayed access area in the list and click the Add Access Partition button.
  5. In the dialog box that will open, in the Family parameter, specify the Radix::Acs::UserGroup class. In the Path parameter, select the User | UserGroup (…) | name node and click OK.

Dialog Box for Synchronizing Table Columns

The dialog box is used to synchronize properties of entity class with the columns of the table the class is based on.

Arrange-db-props.jpg

The DDS Definition column contains a tree with two branches: Columns and Outgoing references. The Columns branch contains all table columns. The Outgoing references branch contains all table references with other tables.

The flag next to a record in the DDS Definition column indicates whether the class has the property based on this table column. Unset the flag to delete previously defined property. If the flag is set, it is possible to change the name of the created property in the ADS Property column.

Classes of Entity Groups

The class of the entity groups defines the way the groups of homogenous objects are processed.

Example.jpg For example, the command of exporting all the objects displayed in the selector can be defined in the class of the entity group.

All classes of entity groups are the descendants of the Radix::Types::EntityGroup class. When creating the definition of the class of the entity group, it is required to specify the entity class the objects of which are included in the groups.

The class of the entity group can contain:

  • overridings of the event handler methods (afterDelete(), afterUpdate(), beforeDelete(), beforeUpdate()) defined in the Types::EntityGroup class
  • other methods
  • dynamic properties
  • SQL expression properties
  • context commands
  • command handlers


Editor of Entity Group Class

The parameters common for the editors of all classes are described in Class Editor.

The editor of the class of entity group contains the specific Title parameter on the General page. The parameter defines the header for the group of instances of the entity class.

Moreover, the editor of the class of entity group contains the Entity page with the following parameters:

  • Table. The table the class is based on.
  • Basis. The entity class. Its instance groups must be presented by this class.

Presentation Adapter Classes

The presentation adapter classes are used to implement the logic of working with data. The logic must be executed only from the client application. The presentation adapter is a class delegating the method calls and property accesses to some entity class. When creating the presentation adapter class, the user is offered to specify the entity class the created class must delegate the properties and methods to.

Some adapter methods can be overridden. Moreover, the adapter can have its own methods and properties (only dynamic properties).


Editor Of Presentation Adapter Class

The editor is identical to the editor of dynamic classes (refer to Dynamic Classes).

Application Classes

The application class is a descendant of the entity class containing the specific logic. It is possible to create the tree of application classes basing on this class. The application classes can have the same property types as the entity classes. If the table on which the entity class is based is polymorphic the application class can have an access to the fields of some detail tables (such tables are called allowed details of the class). When inheriting from the application class, the list of the allowed details only expands.


Application Class Editor

The editor of the definition of the application class is similar to the editor of definition of the entity class (refer to Entity Class Editor). As opposed to the entity class editor, the Presentation page displays only the Title for singular parameter.


Definition Context Menu

The definitions of the application classes have the same specific context menu items as the entity classes, except for the Create entity group parameter that does not make sense for the application classes.

SQL Classes

SQL classes are used to get the direct access (without ORM) to the data in the database (or to change this data). Moreover, SQL classes provide cashing of SQL statement. The queries are written using SQML.


Types of SQL Classes


SQL Cursor Class

SQL cursor class is a "wrap" over SQL query of the SELECT type and it is inherited from the class Radix::Types::Cursor. SQL cursor class has the following methods:

  • open(). Creates SQL cursor in the database. A set of the method arguments coincides with a set of parameters defined by the developer of SQML query.
  • close(). Closes the cursor in the database.
  • next(), previous(). Receives the following (previous) record from the database and places the values of the record field to the values of the class instance.

A set of the class properties coincides with a set of fields selected from the database by the query defined by developer.

When working with SQL cursors, it is possible to use the reference to DB object; it can be loaded on the basis of cursor field values. The object is taken from the ARTE instance cache. If the object is not used in the current session, it will be read from the DB. To set correspondence between cursor fields and columns of a certain DB table, use the Reference Field property (for details, refer to Reference Field Property Editor).

SQL Statement Class

SQL statement class is a "wrap" over SQL query of the INSERT, UPDATE or DELETE type. The execute() method is executed by the query. A set of arguments of the execute() method coincides with a set of query parameters.


SQL Procedure Class

SQL procedure class is a "wrap" over PL/SQL procedure. The execute() method executes the procedure. As opposed to SQL statements, SQL procedure can have both input and output parameters.

SQL Classes Editor

SQL classes editor (SQL cursor classes, SQL statements, SQL procedures) looks as follows:

Cursor-editor.jpg

SQL class editor consists of three parts. The upper side contains the following parameters:

  • Accessibility.Refer to Select Access Mode.
  • Unidirectional. If the flag is not set, the cursor can be moved through the selection in both directions, otherwise - it can be moved only forwards.
  • Readonly. If the flag is set, the cursor (statement, procedure) is read only.
  • Prepared statements cache size. The cache size of the prepared SQL queries.
  • Description. The class description.

The left side of the editor contains a list of definitions used by the cursor:

  • Parameters. The cursor parameters (statements, procedures).
  • Fields. The cursor fields.
  • Tables. The tables used by cursor (by statement, procedure).
  • Packages. PL/SQL packages used by cursor (by statement, procedure).

The toolbar to the left of the editor is described in the following table:

Button Name Description
Add-anc.png Add… Opens the menu for adding the definition to the list.
Ins-tag.png Insert Tag by Selected Item Inserts a tag related to the selected definition into SQML editor to the cursor position.
Edit-selected.png Edit Selected Object Opens the selected definition in the editor.
Remove-anc.png Remove Selected Objects Removes the selected definition from the list.
Move-up.png Move Selected Parameter Up in List Moves the selected definition one position up in the list.
Move-down.png Move Selected Parameter Down in List Moves the selected definition one position down in the list.

If the reference between tables is selected in the list, the Insert Tag by Selected Item (Ins-tag.png) button enables to insert the JOIN clause of SQL query that is used to join the data from several tables employing the selected reference. At that, a special dialog box is used to specify the JOIN parameters. To the right of the list of referred definitions, there is a SQML editor used to define SQL query creating the cursor. This SQML editor has an extra feature. Pressing Alt+Insert in it, opens the menu used to add the parameter or the field of cursor (statement, procedure) to the class or insert it into the code.

Reference Field Property Editor

The Reference Field property editor looks as follows:

Field ref editor.jpg

The editor contains the following elements:

  • Description. The property description in all supported languages.
  • Access. The access mode to the property. Refer to Select Access Mode.
  • Type. The class of entity to whose objects the fields of SQL cursor will refer. The correspondence will be set using the column-based properties of the specified entity class (properties that are stored in the respective DB table).
  • Reference to. The parameter defines the DB table columns the SQL cursor properties will refer to. Available values:
    • Primary key. The table primary key will be used.
    • Secondary key (index). The specified index will be used. The index is selected from the drop-down list. Clicking the Open (Edit-selected.png) button next to the index selection field opens the editor of DDS segment table.
  • Fill PK/SK Columns. Use the button to add the columns used for uniqueness of values in the table (that is the columns that are the primary or secondary key, depending on the Reference to parameter value). These columns must be associated with the SQL cursor fields.
  • Add Column Binding. Use the button to add a random column to the list. The column is selected in the dialog box containing a list of all columns of the current DB table. Using additional columns allows to optimize the object loading and avoid additional queries to the DB when working with the properties of the loaded object.
Note.jpg Note that the value obtained from the cursor field is not checked for correctness. In this respect, the developer must make sure that the correspondence between the cursor field and entity class property is set correctly.
  • Remove Column Binding. Use the button to delete the selected column from the list. The command is available for the columns that do not indicate the value uniqueness in the DB table (columns that are not the primary key or specified index depending on the Reference to parameter value).

The lower part of the editor contains a list of correspondence between the DB columns and SQL cursor fields.

example.jpg

Let's consider that it is required to create a contextless command that will return the messages on events generated by the current user for the last hour. Follow the steps to implement this task:

1. Create SQL cursor (for example, EventLogSearcher) and add the following definitions in the cursor editor:

  • EventLog table with the EL alias
  • fromTime and toTime parameters with the DataTime data type
  • userName parameter with the Clob data type
  • fields corresponding to the EventLog table properties:
    • eventId with the Int data type
    • eventRaiseTime with the DataTime data type
    • eventCode with the Str data type
    • eventWordswith the Clob data type

2. In the cursor editor, write the SQL query code that defines the conditions for selecting the objects from the DB:

select EL.id This.eventId,

EL.raiseTime This.eventRaiseTime,
EL.code This.eventCode,
EL.words This.eventWords

from EventLog EL where EL.raiseTime >= :fromTime

and EL.raiseTime < :toTime
and EL.userName = :username

3. Add the SQL cursor property of the Reference Field type (for example, eventLogObj) and perform the following settings:

  • In the Type parameter, specify the table Radix::System::EventLog.
  • In the Reference to area, select the Primary key value.
  • Create a list of columns using the Fill PK/SK Columns and Add Column Binding buttons. Set correspondence between DB table columns and SQL cursor fields created at the step 1:
RefField ex1.jpg
To avoid additional queries to the DB, it is recommended to set correspondence for the code and words columns in addition to the primary key columns; these columns are used to create the messages on events (the message property of EventLog table). It is also possible to specify other columns in the list of correspondence; the values of these columns will be used when displaying the additional information from the event log.

4. Create and set up the contextless command. For this purpose, write the source code on the Code page (Note.jpg the example does not consider the settings of client and server interaction when executing the particular command):

//define the values of input parameter: toTime - current time, fromTime - current time -1 hour, userName - current user DateTime toTime = Arte::Arte.getCurrentLocalTime(); DateTime fromTime = new DateTime(toTime.getTime() - 60 * 60 * 1000); Str userName = Arte::Arte.getUserName();

EventLogSearcher searcher = EventLogSearcher.open(fromTime,toTime,userName);

while(searcher.next()) {

EventLog instance = searcher.eventLogObj;// the SQL cursor fields (for which the correspondence is set in the eventLogObj property editor) return the properties of EventLog table object selected from the DB according to the conditions specified in SQL cursor.
Str eventMessage = instance.message;//the text of message on event selected from the DB is written to the eventMessage line

//After that, write the code for displaying the text of event message on the screen

}

Algorithms

The algorithm tools are used to develop the application algorithms in a form of flowcharts. The classes of algorithms can be used to organize Workflow processes or used in any system part from the program code. All classes of algorithms are inherited from the Radix::Types::Algorithm class or from another class of algorithm. Each class of algorithm contains the algorithm flowchart and a certain standard set of methods (refer to Algorithm Methods). Moreover, the class of algorithm can contain the additional methods. When the class of algorithm is inherited, the algorithm flowchart and methods can either be inherited or be overridden.

The algorithm flowchart consists of blocks, variables and parameters. The block can have a name. Variables and parameters always have a name. JML code can call the blocks, variables and parameters by names, using the respective tags. In general, each block has several inputs and outputs. When executing the algorithm, the threads can be created in it and executed simultaneously. The thread execution is completed when exiting the algorithm, synchronization block (not always), block of finishing the thread or the process. When executing the thread in the process, the former can go into a state of waiting the external event or time. If all threads go into a wait state, the process saves its state in the database table and stops execution. When the event occurs, the process is activated, it reads its state in the database table and keeps on executing.

Workflow Process Algorithms

The algorithm of the workflow process is described in RadixWare Designer as the class of the respective type (see above). The algorithm is started by means of process types, at that additional parameters can be used. The process type is transferred to the algorithm and is used to create the process. To arrange the user operation within the Workflow process, the forms are used. To work with the forms, the algorithm uses the form blocks. Once the form is created, the process goes to the waiting mode and returns to the execution mode after the user fills the form. It is also possible to create the notification form that does not require to be filled. The algorithm class can implement a certain interface; this facility can be used when selecting the algorithm of a certain purpose for a certain type of process.

Replacement of Algorithms

For each algorithm, RadixWare enables to create or assign the replacement, i.e. the algorithm with the same set of parameters. The replacing algorithm must be the child of the replaced one. When executing or starting up the algorithm which is replaced, the instance of the replacing algorithm is created (in its turn, the instance can send the query further). The communication between the replaced and replacing algorithm is bidirectional. When such communication is present, it is prohibited to change the parameters of both algorithms.

Editor of Algorithm Class

The editor is almost identical to the editors of other classes (refer to Class Editor). The General page of the editor of the algorithm definitions contains the following specific parameters:

  • Replacement. The class of algorithm replacing the current one.
  • Replaced. The class of algorithm replaced by the current one.
  • Process. The class of the process within which the current algorithm is executed.

Moreover, the editor of algorithm classes contains the Parameters additional page. The page displays a list of the algorithm parameters and a set of buttons to manage the list. It is required to specify the following attributes for each algorithm parameter:

  • Name. The parameter name.
  • Column. The purpose of parameter. Available values:
    • Input. The input parameter.
    • Output. The output parameter.
    • Input/Output. The input and output parameter.
  • Type. The data type of the parameter.

The editor of the algorithm flowchart is located in the Flowchart child definition (refer to Algorithm Scheme Editor).

Process Types

The Workflow process type is an instance of applied class based on the Radix::Workflow::ProcessType entity class. The process type defines:

  • Algorithm class. The algorithm class for a certain type process is selected from the list of those implementing a certain interface.
  • Roles of administrator, user and other participants.
  • Default trace profile.
  • The completed process storage period.

The Radix::Workflow::ProcessType entity class has the startProcess() method that starts the Workflow process for execution. The applied classes of the process types can override this method, particularly, by defining various sets of its arguments. The process types are created and edited by the system administrator in the explorer.

Processes

The Workflow process is an instance of the applied class based on the Radix::Workflow::Process entity class. This entity class is used to store the states of workflow processes. A certain class of process is defined in the algorithm definition. The process class defines:

  • Additional properties of a process. They are used to present the process state to operators. These properties can include user-defined or dynamic properties of the applied class.
  • Process links to various system objects. They are used to trace the processes associated with a certain object. Within a process, a link is defined by role and index. The link role belongs to Radix::Workflow::ProcessLinkKind enumeration containing the following values:
    • Primary – primary object.
    • Secondary – secondary object.
    • Association – associated object.
    • Attachment – attachment.

The list can be extended.

  • Editor presentation used to display the process state.

Process State

The process can be in one of the following states:

  • New
  • Active
  • Finished
  • Excepted
  • Aborted

The completed process is stored in the DB for a specified period of time and after that, deleted. The storing period can be defined by the algorithm during the execution. If the storing period is not defined by the algorithm, the settings of the process type are used. While executing the algorithm, a process can be assigned the owner operator. The administrator can change the process owner. The information on the process owner can be used when assigning the forms created by the algorithm. The process ownership statistics can be used to estimate the operators workload.

Algorithm Methods

Startup

To start the algorithm for execution, the following methods can be used:

  • execute() - executes the algorithm synchronously. This method is effective for the algorithms that do not go into a wait state.
  • start() - starts up the algorithm for asynchronous execution as a part of Workflow process (the process type is specified in the type parameter).
  • startProcess() - starts up the algorithm for asynchronous execution in the context of already created Workflow process (the process in which context the algorithm is started up is defined in the process parameter).

All Output and Input/Output parameters are transferred to start() and startProcess() methods as Input. The execute() and start() methods are generated according to the algorithm description. The list of parameters is defined in the inputs and outputs description, the process class is defined in the Process parameter of the algorithm class editor.

Suspend and Resume

When all process threads reach the blocks of waiting for an external event or specific time, the process is suspended. At that, the beforeSuspend() method is called, and the whole context of the process is saved in the database table and restored when the execution resumes. The context contains the values of all variables as well as states of all process threads: call stack (class of the calling algorithm and GUID of algorithm call block) and current position (GUID of the current include scope block and wait block). The asynchronous process execution can be resumed by calling the onTimeout(), onEvent() methods. When they are executed, the process context is restored. The applied block is searched for in the onEvent() method and its resume() method is called. If the block is not found (for example, it is deleted in a new version), the process stops with an exception. The clientData parameter of onEvent() method can be used to transfer the information between the execution initiator and algorithm applied blocks. The onTimeout() method is similar to onEvent() method. The onTimeout(), onEvent() methods are published in the Algorithm base class. Before executing, the beforeStart() method is called. Before resuming the execution, the beforeResume() method is called. Before finishing (successful or not) the process, the beforeFinish() method is called. The methods of the algorithm event handlers in the Algorithm base class are blank, but in certain algorithms, they can be overridden.

Strobes

The process in a wait state can be activated by means of a strobe. Strobes are special class methods of the algorithms (for example, strob<StrobId>(processId)). In blocks that can be activated by a strobe, it is possible to specify the strobe to wait for. When calling the strobe method, all the process threads waiting for this strobe are activated.

Recommendations on Workflow Process Algorithm Development

The Workflow processes are developed on the basis of the description of the business process being implemented. The number of class definitions and their setup order depend on the requirements according to which the algorithm is being developed. In general, the order of actions can be as follows:

1. Creating and setting up process type class.

2. Creating class of process within which the algorithm will be executed. This stage is optional as in general case the algorithm can be executed within the Radix::Workflow::Process class (or within the class that overrides the particular class on the current layer or on one of its base layers). The class creation can be required to define the additional user-defined properties of the process and change a presentation.

3. Creating and setting up algorithm class.

4. If it is supposed to use the user-defined dialogs in the algorithm, create and set up the respective application class of Workflow process user-defined forms for each dialog:

  • define the user-defined properties and methods of a form
  • define the presentations used to view and change the form properties
  • define the roles to access the form (optionally)
The class of forms is the application class. For details on classes, refer to Forms.
Note.jpg Make sure that the required classes of forms are created and set up prior to setting up the respective block of forms in the algorithm block scheme.

5. Compiling the created classes of the Workflow process.

The definitions of classes can be created in a new or existing ADS module.

Creating and Setting up Class of Process Type

The process type class is the application class. It must be based on the class of the Radix::Workflow::ProcessType entity that contains main methods and parameters of the process type or on another class of process type. For a new class of the process type, it is possible to create the additional parameters and methods as well as override methods of the base class.

Note.jpg To use some certain class as a base one, add the module to which the particular class belongs to the dependencies of the current module. The list of ADS module dependencies is created on the General page of the module editor (the Dependencies and used definitions area).

The setup of the process type class comprises the following stages, the order of which is recommended, but not restricted and can be changed depending on the peculiarities of the Wofkflow process being developed:

1. To set up the process type parameters transferring to the Workflow process, override the getAlgoBaseClassId() method and specify the reference to the class of algorithm where the current Workflow process will be implemented. For this purpose, write the program code as follows in the method editor:

return idof[AlgoClass], where AlgoClass - class of algorithm where the current Workflow process will be implemented

Note.jpg This setting must be performed after the algorithm class creation.

2. To enable creation of the Workflow process type in RadixWare Explorer, perform the following settings:

  • On the Presentation page of the process type class editor, specify the class name in all languages supported by the layer.
  • Add the class of process type to the class catalog; the class will be shown in the catalog when creating the Workflow Process Type object in RadixWare Explorer. The class catalog can be changed in the editor of Class Catalogs definition (<Process Type Class> section | Presentations | Class Catalogs | All). For details, refer to Class Catalogs.

Creating and Setting up Algorithm Class

The algorithm class must be based on the Radix::Types::Algorithm class or any other class of the algorithm. The algorithm class setup comprises the following stages, the order of which is recommended, but not restricted and can be changed depending on the peculiarities of the Wofkflow process being developed:

1. Specify the class of process within which the algorithm will be executed. The process class is specified in the Process parameter on the General page of the algorithm class editor. When creating the algorithm class, the Process parameter defaults to the Radix::Workflow::Process class or to the class that overrides it on the current layer or on one of the base layers of the current layer (if such class exists).

2. In the algorithm class settings, add the input parameters (the Parameters page of the algorithm class editor):

  • Parameter that refers to the process type class used by the algorithm.
  • Parameter that refers to the object class within the context of which the Workflow process will be executed.

3. Create the flowchart describing the order of actions. The flowcharts are set up in the editor of Flowchart child definition. For details on flowchart creation and set up, refer to Algorithm Scheme Editor.

Algorithm Scheme Editor

To edit the algorithm flowchart, use the visual editor of the Flowchart child definition:

Schema-editor.jpg

When opening the visual editor of the algorithm flowchart, two additional panes are displayed in RadixWare Designer main window: Palette and Properties. The main part of the window displays the flowchart being created.

The Palette pane contains a list of all available blocks grouped by the purpose (algorithmic blocks and application blocks). The Properties pane displays the properties of the selected block. Moreover, it is possible to change the block properties in the dialog box that will open by double-clicking the block.

To add the blocks to the flowchart, drag them from the Palette pane to the main part of the dialog box.

To link two blocks, hold Ctrl and click the output of the first block, then move the mouse pointer to the input of the second block and release the mouse button. The blocks are connected by the control transition connectors. Double-clicking the line opens the dialog box to define the Trace block (on the flowchart, this block is marked with the Trace block icon.jpg icon); this block is executed when control passes through line. In the dialog box of block editing, define the trace level and JML code that returns the line (in the string format) that will appear in the trace. It is possible to add blocks of the following classes to the flowchart:

Editor Context Menu

The following table describes items of the context menu opened by right-clicking in the editor of the algorithm flowchart:

Menu Item Description
Edit Opens the dialog box for changing the properties of the selected block.
Profiling settings Opens the dialog box for selecting the timing section the selected block refers to.
Cut Cuts the selected block to the clipboard.
Copy Copies the selected block to the clipboard.
Paste Pastes the block from the clipboard.
Delete Deletes the selected block. The user will be asked to confirm the action.

Algorithmic Blocks

Main title: Algorithmic Blocks

Applied Blocks

Main title: Applied Blocks

Presentation Definitions

To distinguish between business logic and presentation logic, RadixWare uses the following model:

  • Business logic is defined in ADS and executed on the server side.
  • Presentation logic is defined in special ADS definitions called presentations and it is executed on the client side. The presentation consists of the two parts:
    • View - the description of the way the objects are displayed. Standard views are defined in a declarative form. If required, the developer can create a random non-standard view.
    • Model - the class containing the dialog logic, in particular, handlers of events that occur in a view.


Property Presentations

Since the presentation model is executed on the client side, it does not have any direct access to the properties of entity class or application class executed on the server side. To provide an access of the model to the class properties, the property presentations referring to the class properties can be defined in the model. The values of the property presentations are sent from the server to the client and backwards. The property presentations can be used to define get- and set- methods for the class properties executed on the server side.


Presentation Types

RadixWare uses the following presentation types:

Each application class or entity class can have any number of presentations.

Presentation Setup

RadixWare Designer creates the standard presentations that look like a list of the editable fields. It is possible to set up the presentations on several levels:

  1. It is possible to change the editor presentations for some separate fields by assigning the user property editor to these fields.
  2. The editor presentation can be completely overridden. At that, the View child definition is created in the presentation. This definition is editable by means of the visual editor.
  3. It is possible to change the behavior of the editor presentations by means of the user event handlers. When creating the user presentation, the events are defined in the visual editor. At that, the method handlers are automatically created in the model.

Inheritance of Presentations

To support a multitude of presentations containing the repeated attributes, it is possible to define a parent presentation for each presentation. Therefore, presentations form an inheritance tree. When inheriting the presentations, it is possible to specify which of the attributes of the parent presentation must be inherited and which ones must be overridden (it is called the inheritance mask):

  • The title and icon.
  • The custom view.
  • Class catalog.
  • A set of the selector columns.
  • Conditions of selecting the records.
  • A set of constraints.
  • The additional properties such as filters and sortings.
  • A set of the child presentations.
  • A set of the editor pages.
  • The presentation title and a format of the object titles.


Inheritance of Editor Pages

If the presentation does not inherit the whole set of editor pages, it can inherit separate pages. When inheriting the separate pages, it is possible to change their attributes.


Replacement of Editor Presentations

The editor presentation can replace any other presentation. The replacing presentation will be displayed in the presentations and navigation items referring to the replaced presentation.

Selector Presentations

The selector presentation defines:

  • The presentation title.
  • A set of the editor presentations available for using with this selector presentation.
  • The editor presentation used to create the objects from this presentation.
  • Class catalog.
  • A set of fields to be displayed in selector; it is possible to define the alignment and a sign for each field.
  • The conditions of selecting the records (the FROM and WHERE clauses of the SELECT SQL query used for selecting the records for the selector).
  • The sortings that can be used in this presentation.
  • The filters available for using in this presentation.
  • A set of exceptions.

Editor of Selector Presentation

The editor of selector presentations contains several pages.

All pages except for the General page have the Inherit flag. If the flag is set, all the parameters defined on the respective page will be inherited from the base presentation. The flag is not available for the presentations that do not have a base presentation.


"General" Page

The page contains the following parameters:

  • Base selector presentation. A base selector presentation for this presentation. The parameter is not available if this presentation is the only selector presentation of this class and its base classes.
  • Editor presentations for editing. A list of editor presentations available for using together with this selector presentation. The Used list contains the editor presentations selected by the developer as presentations allowed for using. The Available list contains all available presentations. To transfer the presentations from one list to another, use the buttons with arrows.
  • Editor presentations for creation. The editor presentation that must be used for creating the class instance from this selector presentation.
  • Creation class catalog. The class catalog that must be used when creating the instances of this class. If the Inherit creation class catalog flag is set, the class catalog will be inherited from the base selector presentation. The parameter is not available, if this selector presentation does not have the base one.
  • Use custom view for Explorer. If the flag is set, the model of this presentation has the View child definition in which the developer can describe the appearance of the presentation in RadixWare Explorer. When unsetting the flag, the View definition is deleted, therefore, the user is asked to confirm the action.
  • Use custom view for Web. If the flag is set, the model of this presentation has the WebView child definition in which the developer can describe the appearance of the presentation in the Web browser. When unsetting this flag, the WebView definition is deleted, therefore, the user is asked to confirm the action.
  • Inherit custom view. If the flag is set, the user view will be inherited from the base selector presentation. The parameter is not available if this presentation does not have a base one.
  • Client Environment. The execution environment for which the selector presentation is meant. Available values:
    • Client-Common. The selector presentation meant for any client environment (Desktop and Web).
    • Desktop
    • Web
  • Use default model. If the flag is set, the default model will be used for this presentation. Otherwise, the selector presentation acquires the Model child definition. It makes sense to set this flag for the selector presentation that does not contain any specific logic (for example, for the command handlers).
  • Enable auto expand. If the flag is set, the selector objects tree will be expanded when moving to the current selector presentation in RadixWare Explorer.
  • Enable position restore. If the flag is set, after the required action execution, the last position is restored in the selector presentation.
  • Accessibility. The access mode to the presentation.
  • Title. The presentation title. It can be inherited from the class itself or from the base presentation.
  • Icon. The presentation icon. It can be inherited from the class itself or from the base presentation.
  • Contextless commands. A list of the contextless commands that must be available from this presentation.


"Selector Columns" Page

The page is used to define a list of the columns to be included in the selector. Each row of the list of columns contains the following parameters:

  • Visibility. Available values:
    • Never. Does not display the column.
    • Initial. Displays the column by default.
    • Optional. Does not display the column by default but permits the user to enable displaying of the column.
  • Property. The class property displayed in the column.
  • Align. Aligns the cells in the column. Available values:
    • Default. Aligns the cells automatically.
    • Left
    • Right
    • Center
  • Size policy. The settings of selector column width definition. Available values:
    • Manual. The column width is set manually by dragging the column delimiter with the mouse.
    • By content. The column width is resized to fit the column content (the width cannot be changed manually).
    • Auto. The Manual or By Content value is set automatically (the By Content value is set if the system is able to identify that the text in the column does not contain more than 40 characters).
    • Stretch. The column is resized to fit the space remaining after the width of all the other columns is set. One visible column with this value must be always specified in the selector.

Moreover, the title in the supported languages is defined for each column.


"Condition" Page

The page contains the following parameters:

  • From. The FROM clause of the SQL query that selects the data for the selector presentation.
  • Where. The WHERE clause of the SQL query that selects the data for the selector presentation.


"Addons" Page

The page contains the following parameters:

  • Default color scheme. The color scheme used by default.
  • Default filter. The default filter used with this selector presentation.
  • Base filters. A set of the base filters available for using with this selector presentation. Available values:
    • Any base filter enabled. Enables to use any base filter.
    • Only specified base filters enabled. Enables to use only those filters marked with a flag in the list below.
  • Filter is obligatory. If the flag is set, this presentation cannot be used without a filter.
  • Enable custom filters. If the flag is set, the custom filters can be used with this selector presentation.
  • On filter absence. The parameters of sorting for the case if the presentation is used without a filter. The parameters are available if the Filter is obligatory flag is not set.
    • Default sorting. The default sorting used with this selector presentation.
    • Enable custom sortings. If the flag is set, custom sortings can be used with this presentation.
    • Base sortings. The base sortings used with this selector presentation (when it is used without a filter). Available values:
      • Any base sorting enabled. Enables to use any base sorting.
      • Only specified base sortings enabled. Enables to use only the sortings specified in the list below.
  • Default hint. A hint for the optimizer of the SQL queries. The hint will be used by default in the query selecting the data for the presentation.


"Restrictions" Page

The page contains the following parameters:

  • Prohibited actions. The flags prohibiting the respective actions with the instances of this class from this selector presentation:
    • Insert into tree. Prohibits to insert the items from the selector into the navigation tree of the client application.
    • Insert all into tree. Prohibits to insert all the items into the navigation tree of the client application at once.
    • Run editor. Prohibits to run the editor from the selector presentation.
    • Editor under selector. Prohibits to run the editor under the selector presentation.
    • Create. Prohibits to create the items.
    • Delete. Prohibits to delete the items.
    • Delete all. Prohibits to delete all the items at once.
    • Update. Prohibits to update the data.
    • Multiple copy. Prohibits to make multiple copies of the items.
    • Contextless Usage. Prohibits the use of contextless commands.
  • Allowed commands. A list of commands available for using in this presentation. It is available if the Allow only the following commands flag is set. Otherwise, it is permitted to use all the commands defined for this class.

Editor Presentations

The definition defines:

  • The presentation title and the format of the object title.
  • The constraints. It is possible to prohibit the use of this presentation when creating, editing or deleting the object. Moreover, it is possible to prohibit or permit the use of some commands defined for this class and contextless commands.
  • A set of editor pages. Several types of editor pages are supported:
    • Containers. They contain the embedded navigation tool.
    • Standard pages. They define a set of editable properties.
    • Custom pages. The view for such pages is entirely defined by the developer.

Moreover, the editor presentation can include a set of embedded navigation items.

Editor of Editor Presentation

The editor of the editor presentation contains several pages. It is possible to edit each page of the editor presentation (they are displayed as the child items of the Editor pages node in RadixWare Designer navigation tree) by means of the separate editor (refer to Editor of Editor Presentation Page).


"General" Page

The page contains the following parameters:

  • Base presentation. The base editor presentation for this presentation. The parameter is not available if this presentation is the only editor presentation of this class and its base classes.
  • Rights inheritance mode. The mode of inheriting the rights to this presentation. Available values:
    • None. The rights to this editor presentation are not inherited.
    • From defined presentation. The rights to this presentation are inherited from the presentation selected in the Inherits rights from parameter.
    • From replaced presentation. The rights to this presentation are inherited from the presentation selected in the Replaced presentation parameter. The value is not available, if the Replaced presentation parameter is not defined.
  • Inherit rights inheritance mode (from base presentation). If the flag is set, the values of the Rights inheritance mode drop-down list will be inherited from the base presentation (the parameter is not available in this case).
  • Replaced presentation. The presentation that is replaced by this editor presentation. The parameter is not available if this presentation is the only editor presentation of this class.
  • Inherit children. If the flag is set, all the child navigation items will be inherited from the base editor presentation. The parameter is not available if this editor presentation does not have a base one.
  • Use custom view for Explorer. If the flag is set, the model of this presentation has the View child definition in which the developer can describe the appearance of the presentation in RadixWare Explorer. When unsetting this flag, the View definition is deleted, therefore, the user is asked to confirm the action.
  • Use custom view for Web. If the flag is set, the model of this presentation has the WebView child definition in which the developer can describe the appearance of the presentation in the Web browser. When unsetting this flag, the WebView definition is deleted, therefore, the user is asked to confirm the action.
  • Inherit custom view. If the flag is set, the user view will be inherited from the base selector presentation. The parameter is not available if this editor presentation does not have a base one.
  • Inherit editor pages. If the flag is set, all the pages of the editor presentation will be inherited from the base presentation. The parameter is not available if this editor presentation doesn’t have a base one.
  • Client Environment. The execution environment for which the editor presentation is meant. Available values:
    • Client-Common. The editor presentation meant for any client environment (Desktop and Web).
    • Desktop
    • Web
  • Use default model. If the flag is set, the default model will be used for this presentation. Otherwise, the editor presentation acquires the Model child definition. It makes sense to set this flag for the editor presentations that do not contain any specific logic (for example, for the command handlers).
  • Accessibility. Refer to section Select Access Mode.
  • Title. The presentation title.
  • Icon. The presentation icon.
  • Inherit property presentation attributes. If the flag is set, the values of property presentation attributes will be inherited from the base presentation. The parameter is not available if this editor presentation does not have a base presentation. If the flag is set, it is possible to specify the attributes own values for the presentation properties. The list of properties is created using the Add, Remove and Clear All buttons. The following property attributes are available:
    • Presentable*. The facility to use the property on the client side. Available values:
      • inherited
      • true. Allows to use the property.
      • false. Prohibits to use the property.
    • Not null*. The facility to set null value. Available values:
      • inherited
      • true. Null value is prohibited.
      • false. Null value is allowed.
    • Visibility*. The rule of displaying the property value editor. Available values:
      • inherited
      • Always. The editor is always displayed.
      • Never. The editor is never displayed.
      • Only for new. The editor is displayed only at object creation.
      • Only for existent. The editor is displayed if an object already exists.
    • Edit possibility*. The facility to edit the property value. Available values:
      • inherited
      • Always. The property value is always editable.
      • Never. The property value is not editable.
      • On create. The property is defined at object creation and then, is not editable.
      • Only existing. The property value is editable only if the object already exists.
      • Programmatically. The property value can be changed programmatically.
    • Title. The facility to override the property title. To override the value, specify the property titles in the supported languages in the Edit Title dialog box (the Inherit Title flag must be set).

Note.jpgFor the attributes marked with the symbol "*", the inherited value allows to inherit the attribute value from the editor base presentation or from the property presentation settings, that is, the attribute won’t be overridden.

  • Contextless command. A list of the contextless commands that must be available from this presentation.


"Object title format" Page

The page is used to define the template according to which the editor title must be created. For the title templates, refer to Entity Class Editor. Moreover, the page contains the following parameters:

  • Display instead of null. The text to be displayed instead of the undefined value (it is defined for all supported languages).
  • Inherit. If the flag is set, all the parameters defined on this page will be inherited from the class itself.


"Restrictions" Page

The page is similar to the Restrictions page in the selector presentation editor.

Editor of Editor Presentation Page

Editor of editor presentation page contains the following parameters:

  • Accessibility. Refer to Select Access Mode.
  • Overwrite. The page that is overwritten by this page.
  • Override. The page that is overridden by this page.
  • Page type. The page type. Available values:
    • Container. The page contains the child navigation item (refer to Navigation Items).
    • Custom. The appearance and behavior of such page is completely defined by the developer in the visual editor of the View and WebView child definitions. When removing the Custom value, the View and WebView child definitions are deleted, therefore, the user is asked to confirm the action.
    • Standard. The page is created according to the set of editable properties defined by the developer.

The navigation items located below depend on the selected page type.


"Standard" Page Type

  • Title. The title of the editor page.
  • Icon.
  • Used properties, Available properties. The Used properties list contains the class properties that must be editable on this page, and the Available properties list contains the rest ones. It is possible to transfer the properties between the lists by means of the buttons with arrows. Add-column.png adds the column to the Used properties list and Del-column.png button deletes the selected column from it. The properties will be arranged on the editor page in the same way they are arranged in the Used properties list.


"Custom" Page Type

When selecting this value, the appearance and behavior of the editor page is entirely defined by the developer by means of the visual editors of the View and WebView child definitions.


"Container" Page Type

  • Embedded explorer item. The navigation item that must be embedded to the editor page. It is possible to select the child navigation items of this editor presentation.
  • Title. The title of the editor page.
  • Icon.

Filters

The selector presentation can display not all records but only those records that satisfy the condition. Such conditions are called filters.

The user is enabled to define a set of parameters for a filter. By default, the filter parameters are defined by means of the standard widgets, but the developer can define the editor presentation for specifying the filter parameters.

It is possible to use both the developer-defined and user-defined filters. In the selector presentation, the developer can specify a set of filters available for using with this filter presentation and either permit or prohibit the use of the user-defined filters. Moreover, the developer can prohibit the use of presentation without filter.

For the filter definition, the developer can define a set of sortings available for using with this filter and specify the sorting used with this filter by default. The developer can also permit or prohibit the use of the custom sortings with this filter.

The records are filtered by the database server (the WHERE SQL statement is used).

In addition to filters, the selector presentations in RadixWare Explorer provide the search facility. The search is executed on the client side and requires the whole set of records, therefore, the search procedure can be time consuming. It is recommended to define filters for the large tables so that the users can employ them instead of search.

Filter Editor

The filter editor looks as follows:

Filter-editor.jpg

The editor contains the following parameters:

  • Description. The filter description.
  • Accessibility. Refer to Select Access Mode.
  • Title. The filter title.
  • Use custom view for Explorer. If the flag is set, the appearance and behavior of the dialog box for specifying the filter parameters in RadixWare Explorer are completely defined by the developer in the visual editor of the View child definition. If the flag is not set, the dialog box will be created on basis of the child definitions from the Editor Pages branch.
  • Use custom view for Web. If the flag is set, the appearance and behavior of the dialog box for specifying the filter parameters in the Web browser are completely defined by the developer in the visual editor of the WebView child definition. If the flag is not set, the dialog box will be created on basis of the child definitions from the Editor Pages branch.
  • Contextless commands. A set of contextless commands available in filter.

Moreover, the filter editor contains the Conditions and Sortings pages.


"Conditions" Page

The page contains the following parameters:

  • Condition. The WHERE clause of the SQL query that selects the records.
  • Hint. A hint for the optimizer of SQL queries.


"Sortings" Page

The page contains the following parameters:

  • Default sorting. The sorting used with the filter by default.
  • Enable custom sortings. If the flag is set, the user is permitted to use custom sortings with this filter.
  • Base sortings. The parameter is similar to the respective parameter in the editor of selector presentation. (refer to Selector presentations).
  • Enabled base sorting hint. A hint for the optimizer of SQL queries. The hint is used for the sortings.

Sortings

The records in the selector presentation can be displayed in various order. The user can employ one of the sortings defined by the developer or define their own sorting. In the selector presentation, the developer can define a set of sortings available for using with this presentation of sortings and specify the default sorting. Moreover, the developer can either permit or prohibit the use of user-defined sortings.

The records are sorted by the database server (the ORDER BY statement is used).


Sorting Editor

The sorting editor contains the following parameters:

  • Description. The sorting description.
  • Accessibility. Refer to Select Access Mode.
  • Title. The sorting title.
  • Used properties, Available properties. A list of the class properties according to which the sorting must be executed. If the flag is set in the Desc column, the sorting by the respective property will be executed in descending order.
  • Hint. A hint to the optimizer of SQL queries. The hint must be used for sortings.

Class Catalogs

The user can create the records using the selector presentation of the entity class. If the tree of application classes exists (the classes are the descendants of this entity class), it is required to specify the class of the object before creating it. So that the user can select the required class, the class catalogs are used. The class catalog is a list of application classes arranged in a tree structure.

The class catalogs can be defined only in the entity classes the application classes can be based on (the Enable application classes flag is specified in the table definition, refer to Table Editor) and in application classes.

Extending Class Catalogs When creating a new application class based on the entity class defined in the lower layer, a new class is not added to the class catalogs automatically. To provide the user with the facility to create the instances of the new application class, perform the following:

  1. Override the class catalog in the application class defined in the parent entity class.
  2. Add a new application class to the overridden entity class.

When compiling, the class catalogs of the parent entity class will be merged with the class catalogs of all child application classes. Therefore, the user will be able to create the instances of all application classes specified in these catalogs.


Editor of Class Catalog

The editor of the class catalog looks as follows:

Class-catalog-editor.jpg

The editor of the class catalog contains the elements used to define the access mode (refer to Select Access Mode) to the catalog and to define the list of catalog elements. To the right to the list of elements, there is a set of buttons:

Button Description
Add-topic-button.jpg Adds a group of classes to the catalog.
Add-child-topic-button.jpg Adds a child group of classes to the selected group.
Add-class-button.jpg Adds an entity class or an application class to the selected group.
Add-child-class-button.jpg Adds an entity class or an application class as a child item.
Edit-button.jpg Opens the dialog box used to define the titles of the catalog item in the supported languages. For the classes, the titles of the catalog items are inherited from the classes by default.
Remove-small-button.jpg Removes the selected item from the catalog.

Commands

Context Commands

The context commands are used to execute non-standard actions in the context of the group of objects (in the selector presentation), in the context of the object (in the editor presentation) or object property.

The command settings are used to define the title, icon, accessibility (for example, for the existing object only), input and output parameters. The forms or XML documents corresponding to the certain XML schemas can function as the input and output parameters.

If the form is specified as an input parameter, this form will be displayed to the user before the command is started up; the filled form will be used as argument. If the form is specified as an output parameter, it will be filled in and displayed to the user when the command execution is finished.

It is possible to define the method handlers both in the server class and in the presentation models.


Context Command Editor

The context command editor contains the following parameters:

  • Title. The command title.
  • Description. The command description.
  • Accessibility. Defines when the command can be accessed. Available values:
    • Always. The command is always accessible.
    • Only new object. The command is accessible only for the newly created objects.
    • Only existent object. The command is accessible only for the already existing objects.
    • Only fixed object. The command is accessible only when all changes are saved in the editor. It makes sense to use it if the command reads or changes the object directly in the database.
  • Confirmation required. If the flag is set, the user will be asked to confirm the action before executing the command.
  • Do not send request to server. If the flag is set, the command will be executed only in the client application (it will be impossible to create the server handler of such command; the client command handler will not send the request to the server).
  • Show command button. If the flag is set, the button presenting the command will not be displayed in the client application.
  • Input. Input data for the command. Available values:
    • No value. No input data.
    • Xml. On the input, the command handler receives the XML document corresponding to the specified XML schema.
    • Form. The command runs the specified form. On the input, the command handler receives the data of the form.
  • Output. The output data of the command. Available values:
    • No value. No output data.
    • Xml. The command handler must return the XML document corresponding to the XML schema.
    • Form. The command handler must return the data for the form.

Contextless Commands

Sometimes it is required to provide the user with the facility to execute actions not associated with a certain object or a group of objects. For this purpose, the contextless commands are used. The contextless command handlers can be defined both on the server side and on the client side. The handler code executed on server is defined directly in the command editor. The handler on the client side is created in the presentation model in which the command is published.


Contextless Command Editor

The editor of the contextless command contains the General and Code pages. The General page is similar to that of the context command editor (refer to Context Commands), except for the following:

  • The editor of the contextless command does not have the Accessibility parameter.
  • The editor of the contextless command contains the Access parameter. The parameter defines the access mode to the command.
  • In the editor of the contextless command, the No request to server flag is absent.

The Code page contains the JML Editor used to define the code executed on the server side when starting up the command.


Definition Context Menu

For the common context menu items, refer to Definition Context Menu.

The table below provides the specific context menu items of contextless commands definitions:

Menu Item Description
Set up Roles Usage Opens the dialog box used to define the access of the various roles to this command execution (refer to Access to Definition).
Go to Client Side Command Handler Opens the dialog box for selecting the definition with a list of all handlers of this command on the client side. The selected definition will be opened in the editor.


Navigation Items

When the user connects to the server employing the client application, the system prompts to select one of the navigation trees to work with. The branches of the navigation trees are called navigation items.

The navigation item can be:

  • Branch.
  • Reference to the branch defined in other place.
  • Reference to the presentation of arbitrary entity class selector.
  • Reference to the presentation of parent entity editor.
  • Reference to the presentation of child entity selector.

Branches

The branch defines that part of navigation tree displayed in RadixWare Explorer. Some of the branches are marked as root ones. One of the root branches is selected when the client connects to the server. It is required to define general settings (title, icon) and a set of available contextless commands for the branch. A branch can contain child navigation items including other branches.


Branch Editor

The branch editor contains the following parameters:

  • Title. The branch title in supported languages.
  • The branch icon displayed in the navigation tree of the client application.
  • Accessibility. Refer to Select Access Mode.
  • Root. If the flag is set, the branch is root. One of the root branches is selected when the client connects to the server.
  • Environment. The runtime environment the branch is intended for. Available values:
    • Client-Common. The branch can be used in any client environment (Explorer or Web).
    • Explorer. The branch must be used only in RadixWare Explorer.
    • Web. The branch must be used only for the Web presentation.
  • Use custom view for Explorer. If the flag is set, the appearance and behavior of the branch is entirely defined by the developer in the visual editor of the View child definition.
  • Use custom view for Web. If the flag is set, the appearance and behavior of the branch in the browser is entirely defined by the developer in the visual editor of the WebView child definition.
  • Contextless commands. The list defines the contextless commands available in this branch.
  • Logo. The image to be displayed in the working area of the client application when opening the branch. As opposed to the icon, this image can be big. The Change button opens the dialog box for selecting the image (refer to Select Image). The Clear button deletes the image.


Definition Context Menu

The context menu of the branch definition contains one specific item: Set up Roles Usage. This item calls the dialog box where it is possible to set up the access of different roles to this branch (refer to Access to Definition).

Presentation of Arbitrary Entity Class Selector

The definition defines:

  • whether the item is displayed in RadixWare Explorer navigation tree.
  • Used selector presentation.
  • Presentation title (it can be inherited from the presentation being implemented).
  • Class catalog (it can be inherited too).
  • Constraints.
  • Conditions of selecting the objects - FROM and WHERE clauses of SQL query that selects the objects for the embedded presentation.

Presentation of Parent Entity Editor

The definitions of these type are used to view and/or edit the properties of parent object under the editor presentation of the child object. The definition defines:

  • If the item must be displayed in the navigation tree of the client application.
  • Title.
  • Which editor presentation of the parent class must be used.
  • Constraints: it is possible to prohibit to edit the parent object and/or command defined in the presentation being implemented. The constraints can be inherited from the presentation being implemented.

Presentation of Child Entity Selector

The definitions of this type are used to embed the selector presentations of the child object to the editor presentation of the parent object (in order to select one of the child objects). The definition defines:

  • whether the item is displayed in the navigation tree of the client application.
  • Which selector presentation must be used.
  • Presentation title (it can be inherited from the presentation being implemented).
  • Class catalog (it can be inherited too).
  • Constraints.
  • Conditions of selecting the objects - FROM and WHERE clauses of SQL query that selects the objects for the implemented presentation.


Advanced Means for Defining Dialog Interfaces

If it is required to arrange the dialog interfaces that cannot be described by the standard means (editor presentations, etc.), the definitions of the following types can be used:

  • Dialog Boxes
  • Property Editors
  • User Widgets
  • Forms

To edit the above-mentioned definitions, use the visual editor (refer to Visual Editor of Dialog Boxes).

Dialog Boxes

The dialog boxes are used to receive the arbitrary information from the user. The dialog box contains the model - a class, property and methods of which enable to control the dialog box. The class of the model is executed on the client side.

Property Editors

The property editors are almost identical to the dialog boxes, but they represent the developer-defined means of changing the value of the object property. When describing the property, it is possible to set up it for using the certain editor (the Custom dialog parameter on the Presentation page of the property editor; refer to Property Editor).

User Widgets

The user widgets are the parts of dialog boxes consisting of several standard widgets. It makes sense to define the user widgets if one constituent widget is used in several dialog boxes or property editors. The widgets contain the model too. The model is executed on the client side.

Forms

The form classes are used to exchange the information between the user and application server. The form class can have:

  • form properties
  • methods
  • dynamic properties
  • expression properties

The form class contains a set of editor presentations used to view the form properties and change them. The form properties are automatically transmitted between the application server and the client. Moreover, the form class contains a model executed on the client side. In general case, the form functions as follows:

  1. The application server code creates a form and fills in some form properties if required.
  2. The form is transmitted to the client side and displayed to the user.
  3. The user fills in the form. At that, the values of some form properties are changed.
  4. New values of the form properties are returned to the server side and become available for the code that created the form.


Form Class Editor

The editor is almost identical to the editors of the rest classes (refer to Class Editor). The Presentation page contains the following specific parameters:

Available values:

  • Client-Common. Generates the runtime files for the Explorer and Web environments.
  • Explorer
  • Web
Inherit Editor Pages. If the flag is set, the editor pages will be inherited from the base form class. The parameter is not available if the base class is not a form class.
  • Inherit Custom View. If the flag is set, the View child definition will be inherited from the base form class. The parameter is not available if the base class is not a form class.
  • Use Custom View for Explorer. If the flag is set, the form appearance and behavior is entirely defined by the developer in the visual editor of the View child definition.
  • Use Custom View for Web. If the flag is set, the appearance and behavior of the form is entirely defined by the developer in the visual editor of the WebView child definition.
  • Use Inherited Icon. If the flag is set, the form icon will be inherited from the base form class. The parameter is not available if the base class is not a form class.
  • Form icon.

Reports

The report definitions are used to generate printed documents on the basis of data from the database.

The report generation can be started:

  • Interactively, from RadixWare Explorer. To enable the interactive report generation, the report must be published in some context.
  • On schedule, as a scheduled task.

Reports can be single-file and multi-file. Execution of a multi-file report results in several files each containing the data grouped by a certain attribute. Reports can be generated in the following formats:

  • PDF
  • XML
  • CSV
  • TXT
  • XLS
  • XLSX

A report definition is used to describe an SQML query required to select the data for the report, and report design. To edit the report design, use a visual editor. For the visual editor description, refer to Report Designer.

The report definition can contain:

  • fields
  • reference fields
  • parameters
  • dynamic properties
  • SQL expression properties
  • methods
  • editor presentations to enter the parameters
  • commands available in the dialog box for entering the parameters
  • model of the dialog box for entering the parameters
  • custom view of the editor

The report fields contain the data to be displayed in the report. The fields can have any type of RadixWare data. The reference fields can contain the instance of any entity class. The data is selected from the database and transferred to the database by SQML query.

The report parameters are used to select the data to be included in the report. For example, if the report is used to display the data for the certain year, the year number must be the report number.

The report editor presentation is used to define the dialog box for entering the report parameters. The developer can define any presentation of the dialog box for entering the report parameters by means of the visual editor.

To define the non-standard actions in the dialog box for entering the report parameters, the commands defined in the report definition can be used.

The command handlers can be defined both in the report definition (the handlers are executed on the server side) and in the models of the report editor presentation (the handlers are executed on the client side).

The report definitions support two command types:

  • The commands associated with the object.
  • The commands associated with the object property.

The command handlers associated with the object receive the Map as an argument. The Map contains all identifiers and the property values of the reported object. The command handlers associated with the object property receive the command and the property identifier of the reported object for which this command was called.

The report model is similar to the models of editor presentations. It is executed on the client side and defines the presentation logic of the dialog box for entering the report parameters.

Definition Context Menu

The context menu of the report definition contains the Export to UDS Exchange File item. When selecting this menu item, the report is exported to an XML file.

XML Schemas

XML schemas define the formats of XML documents. The format of schemas is defined by XSD standard with some extensions.

Basing on the schemas, RadixWare generates Java classes employing XmlBeans. Therefore, the developer has an opportunity to call the data contained in an XML document as they are the properties and methods of Java class. For the description of API for the data access in an XML document, refer to XMLBeans Documentation.


XML Schema Editor

The editor contains:

  • The toolbar.
  • The elements used to define the access mode to the schema definition (refer to Select Access Mode).
  • The text field where XML syntax is highlighted and autocompleted (by pressing Ctrl+Space).

The table below provides the toolbar buttons of XML schema editor:

Button

Name

Description

edit-schema.png

Save Schema to File and Edit in External Editor

Saves the schema to the file and edits the saved file in the external editor.

load-schema.png

Load Schema from File

Loads the schema from the file.

save-schema.png

Unload Schema to Specified Directory

Saves the schema to the file.

save-schema-all.png

Unload Schema and All Schemes Imported by it to Specified directory

Saves the edited schema and all schemas imported by it to the specified directory.

find-selection.png

Find Selection

Finds the text selection in the code.

find-prev.png

Find Previous Occurrence

Finds the previous occurrence of the selection.

find-next.png

Find Next Occurrence

Finds the next occurrence of the selection.

search-hl.png

Toggle Highlight Search

The toggle button. Highlights all the occurrences of the required selection.

rest_select.jpg

Toggle Rectangular Selection

The toggle button. Selects the rectangle area.

unindent.png

Shift Line Left

Decreases the indent of the selected strings.

indent.png

Shift Line Right

Increases the indent of the selected strings.

check_xml.jpg

Check File

Checks the XML document for syntax or other errors.

validate_xml.jpg

Validate File

Checks the XML document for compliance.

xls_transformation.jpg

XSL Transformation

Transforms XML document to XSLT.

XSLT Transformations

XSLT transformation defines the transformation between different XML formats. The definitions of this type can be used from the application code.

The Radix::Explorer.Utils::DialogUtils class provides the facility for the user to edit XSLT transformations from RadixWare Explorer.

MSDL Schemas

MSDL (Message Structured Data Language) is a language used to describe the file formats and messages. The definitions of MSDL schemas enable to describe the file formats in a declarative way and access the data in the file (message) not using the low-level operations of parsing / merging the data. When compiling by MSDL schema, an XML schema is generated. The class is generated by XML schema employing XmlBeans. The class provides access to the data of the described format.

When parsing the data by MSDL schema, it is assumed that the data consists of records. The records consist of fields. The simple as well as compound fields are supported. The compound fields contain several other fields.

Therefore, MSDL schema describes the tree-like structure in a general case.

The following types of simple fields are supported:

  • Int – the integer number.
  • Num – the real number.
  • Str - the string.
  • BCH – each byte is a record of two numbers in hexadecimal form; the parsing result is the string.
  • Bin – the binary date; the parsing result has the Radix::Types::BinHex type.
  • Boolean – the logical field which is used only when describing the fields of DBF files.
  • DateTime - the time.

The compound fields can include one or several fields. The following types of compound fields are supported:

  • Choice. In the string being parsed, the field of this type must begin from the selector - the string. For each possible value of the selector, the description of the child field is defined. The data after selector will be parsed as field found by the selector value.
  • Sequence. The data is the record array. The record format is defined by the child fields.
  • Structure. The child fields can be formatted by one of the following ways:
  • Field sequence. The fields in the string follow each other, it is possible to define the separator.
  • Bitmap. The string starts with the binary data of 64 bits (bitmap) in length, the value of each bit indicates the presence / absence of the respective field. The field names must be as follows: F+field number. If the first bit (bitmap) is set, it is followed by another bitmap that defines the presence of the fields with numbers going by the list (the field number is greater by 64).
  • Named Fields. Each field starts with the field name in the defined format.
  • BerTLV. The field starts with the tag (identifier) of the field. It is followed by a byte of the message length. If the value of the length byte is 15, the following byte is read and the field length is created as a hexadecimal number consisting of 2 digits. The first digit of this number is equal to the first byte and the second - the value of the following byte. The field name must be as follows: T+record of hexadecimal number.
  • DBF. The data is stored in DBF format.


Field Structure

For each field, the structure is defined. If it is impossible to parse or merge the value according to the defined structure, the exception is thrown. RadixWare supports the following types of the field structure:

  • Fixed Length. The field has a defined length measured by chars, bytes, elements (it is applied for BCH field type). If the field length is less than a defined one, define the char / byte for padding the field to the required length. It is also possible to define the field alignment - left, right, none.
  • Separated. The start and end separator are defined (both are optional). The escape char is also defined. When parsing, the escape char is deleted and the next character is not interpreted as a separator. Moreover, the list of bytes is defined. The bytes must begin with the escape char on the output.
  • Embedded Length. The length is defined at the start of the field data. The field data can be formatted as a field with a fixed length or a separated field. It is also possible to define the parameter of including the length in the total field length and the unit of measuring the field length (chars or bytes).
  • None. The field data is read to the end of the message or record.


Inheritance of Parameter Values

Many parameters of fields can be inherited from the parameters of the superior structure. For example, the field length can be defined for the certain part of the compound field or for the whole compound field or for the whole message.

MSDL Schema Editor

Main Title: MSDL Schema Editor

Example of Format Defining

Let’s assume that it is required to define the message format which is based on UAMP and contains two fields: one string field and one numeric field. To define such format, perform the following:

1.Create new definition of MSDL schema.

2.On the left pane of the editor, on the Child Fields Format page, execute the following actions:

  • Set the Type parameter to Named Fields.
  • Set the Field Separator parameter to "10" in Hex encoding.
  • Set the Type parameter in the Field Name Format group to Separated.
  • Set the End Separator parameter to "3D" in Hex encoding (or "=" in ASCII encoding).
  • Set the Escape Char Format parameter to Hex.
  • Set the Escape Char parameter to "13" in Hex encoding.
  • Add the "1C" and "1D" bytes to the Escaped Bytes list.

3.On the Field Defaults | Str Field page, set the parameters as follows:

  • Encoding - ASCII.
  • Align - Left.
  • Pad - <space>.

4.On the Field Defaults | Int, Num Fields page, set the parameters as follows:

  • Encoding - ASCII.
  • Align - Right.
  • Pad - 0.

5.Create the StringField field of the Str type by selecting the New | Field item from the context menu of the Fields child definition of MSDL schema.

6.Specify the "STR" value in the Tag parameter of the editor of the created field.

7.Create the IntField field of the Int type by selecting the New | Field item from the context menu of the Fields child definition of MSDL schema.

8.Specify the "INT" value in the Tag parameter for the IntField field.

Usage of the created MSDL schema makes it possible to parse the message (the byte 0x10 is represented as "#")

STR=abc#INT=017

(53 54 52 3D 61 62 63 10 49 4E 54 3D 30 31 37 in the hexadecimal representation). The parsing of the message will result in creation of the class instance with the properties StringField = "abc" and IntField = 17.

Enumerations

The enumeration is a set of the fixed values which the class property of enumeration type can take. For each value in the enumeration, it is possible to define the name in the supported languages, the icon and domain.

The enumerations of three types are supported: integer (Int), string (Str) and character (Char).

Some enumerations are defined in the Kernel segment. Initially, such definitions are not available from the model, since they do not have their own GUID. To use such enumeration, it must be published. When publishing enumeration, define its name and header. It is possible to add new items to the enumerations being published. It is not possible to delete the existing items of the definition when publishing.

Each item of the published enumeration can be overridden. At that, it becomes possible to define the title, icon and domain the item belongs to.

Moreover, the enumerations defined in some development layer can partially or completely overwrite the enumerations of the lower layers. For example, the customer (in their own development layer) can add their own options to the "Transaction Type" enumeration defined by the vendor in the lower layer.

To avoid the intersection of the values when overwriting, set the range of values which can be overridden.

When overwriting the enumeration, it is not possible to delete the items of the source enumeration.

Enumeration Editor

The enumeration editor contains the following parameters:

  • Description. The enumeration description.
  • Title. The enumeration title.
  • The elements to control the access mode to the enumeration (refer to Select Access Mode).

If the enumeration is the published enumeration from the Kernel segment, the editor contains the additional fields:

  • Published Enumeration. The full name of the published enumeration. The parameter is not editable.
  • Extendable. If the flag is set, it is possible to add the extra items to the published enumeration.

Moreover, the editor contains the Values and Restrictions pages. The Synchronize button is used to update the published enumeration according to the changed definition of the Kernel segment.


"Values" Page

The list on the page defines the set of enumeration items. The enumeration item has the following parameters:

  • Name. The name of the enumeration item.
  • Value. The value of the enumeration item.
  • <Language> title. The titles of the enumeration items in the languages supported by the layer. By default, the titles are identical to the name of the enumeration item.
  • Icon

The Search text field is located above the list. It is used to search for items in the list of values. To search for the item, start entering the name of the required item in this field.

To the right side, there is a set of buttons to manage the list of items:

Button Description
Add-button-small.jpg Adds the item to the enumeration.
Remove-small-button.jpg Removes the item from the enumeration.
Up-button.jpg Moves the selected value one position up in the list.
Down-button.jpg Moves the selected value one position down in the list.
Overwrite-button.jpg Overwrites the selected value. The button is available only for the enumerations overwriting other enumerations.
Deprecate-button.jpg The toggle button. Marks the selected item as deprecated. When compiling, the system displays the warning message each time this item is used.
Used-by-button.jpg Finds all the usages of the selected enumeration item.
Duplicate-button.jpg Creates the enumeration item based on the selected one.
Edit-button.jpg Opens the dialog box for editing the enumeration item parameters.


"Restrictions" Page

The page contains the Overwritable ranges list that defines the enumeration ranges available for overwriting. When overwriting the current enumeration, it is possible to add the items with values only from this range. The range is defined by the maximum and minimum values.

For the enumerations of string type, the Eliminating expression parameter is displayed. When overwriting the enumeration, it is possible to add only the enumerations that comply with the regular expression specified in this parameter.

Domains

The domain is a named set of definitions or of their parts (for example, enumeration items). The domains are used to group the definitions (or their parts) by some attributes. For example, the items of the "Transaction Type" enumeration can be grouped into several domains: "debit transactions", "credit transactions", etc. It is possible to check from the program code whether the enumeration item belongs to the domain. Therefore, it is possible to shorten the code that checks the variable of the enumeration type. Moreover, when adding a new item to the enumeration, it is enough to add it to the respective domain. Then, the whole code working with this enumeration will take into consideration a new item.

Definitions of classes can relate to the domains too. The class can relate only to the domain defined in the same module as the class itself.

The domains create a tree.

User Roles

The role defines the functions performed by the user in the system. The permission to execute a certain action is given to the role, not to the certain user. Each user or a group of users can be assigned several roles. The roles can represent the inheritance tree. The settings of the parent roles are inherited by the child ones, but they can be explicitly overridden.

It is possible to assign the rights to the roles for:

  • Contextless commands.
  • Branches.
  • Entity classes and application classes.


Definition Context Menu

The context menu of the role definition contains the Export to UDS Exchange File specific item. When selecting this menu item, the report is exported to the XML file.

Role Editor

The role editor looks as follows:

role-editor.jpg


"General" Page

The page contains the following parameters:

  • Title. The role title in the supported languages.
  • Abstract. If the flag is set, the role is abstract. Such role cannot be assigned to the user. It can be used only as a parent role when inheriting the roles.
  • Deprecated. If the flag is set, the role is deprecated. When compiling, the system displays the warning message each time such role is used.
  • Description. The role description in the supported languages.

The Remove Incorrect Resources button (remove-incorr-resources.png) removes all references to the non-existent controlled resources from the role.


"Ancestors" Page

The page is used to define the ancestors for this definition. The page contains a toolbar and a list of the parent roles. The toolbar is described in the following table:

Button

Name

Description

add-anc.png

Add Ancestor...

Calls the dialog box for selecting the role definition to add it as an ancestor.

remove-anc.png

Delete Current Ancestor

Deletes the selected role from the list.

remove-all.png

Delete All Ancestors

Deletes all roles from the list. The user is asked to confirm the action.

select-in-tree.png

Select Role in Tree

Selects the role from the list of parent roles in RadixWare Designer navigation tree.


"Resources" Page

The page is used to define a set of resources to which this role has access. The page, in its turn, consists of the following pages: Server Resources, Explorer Roots, Presentations, Contextless Commands.

Each page contains a toolbar with the buttons described in the following table:

Button

Name

Description

allow-all.png

Allow Access to All …

Allows the role an access to all definitions from the list below.

remove-all.png

Delete Rights for All ...

Prohibit access to all definitions from the list below.

add-anc.png

Add …

Calls the dialog box for selecting the definition to add it to the list below.

remove-anc.png

Delete …

Deletes the selected definition from the list.

select-in-tree.png

Select … in Tree

Highlights the selected definition in RadixWare Designer navigation tree.

show-inherited.png / hide-inherited.png

Show/Hide Inherited Classes

The toggle button. Shows or hides the inherited classes from the list on the Presentations page.


"Resources | Server Resources" Page

The page is used to define the role access to the server resources. The list under the toolbar contains all server resources. The Inherited Rights column displays the resource access defined by the parent roles. The Own Rights column determines the access defined by this role. The Total Rights column displays the resulting access level. It is possible to change only the value in the Own Rights column. Available values:

  • Inherit. Inherits the access. At that, Total Rights = Inherited Rights.
  • Allowed. Allows the access. At that, Total Rights = Allowed.
  • Prohibited. Prohibits the access. At that, Total Rights = Prohibited.


"Resources | Explorer Roots" Page

The page is used to define the role access to the root branches. This page contains two lists. The first list defines whether the access to the root branch is allowed or prohibited. If some item is selected in the first list, the second one displays all navigation items of the selected root branch. The columns Inherited Rights, Own Rights and Total Rights work in a similar way as the respective columns on the Server Resources page.

allow-branch.png provides the role access to the navigation item selected in the second list and to all of its child items.

inherit-branch.png inherits the role access to the navigation item selected in the second list and all its child items from the parent roles.


"Resources | Presentations" Page

The page is used to define the role access to the editor and selector presentations. The list under the toolbar contains the classes. The access to the presentations of these classes is defined in the role. When selecting the class from the list, use the control elements below to define the role access to the particular class presentations.


"Resources | Presentations | Editor Presentations" Page

The page is used to define the role access to the editor presentations of the selected class. The list to the left contains all editor presentations of this class. The role has access only to the presentations with the set flag in the Own column. The list in the upper side of the page defines the role access to the particular actions with the presentation:

  • Access. Allows access to the presentation. If the flag is not set, it is not possible to set other flags.
  • Create. Allows to create the objects by means of presentation.
  • Delete. Allows to delete the objects by means of presentation.
  • Update. Allows to edit the objects by means of presentation.
  • View. Allows to view the objects by means of presentation.
  • Any Commands. Allows to use any context commands published in the presentation.
  • Any Children. Allows to use all child navigation items of the presentation.
  • Any Pages. Allows to use all pages of the presentation.

If the Any Commands flag is not set, the list on the Allowed Commands page is available. The list defines the role access to the particular commands published in the presentation.

If the Any Children flag is not set, the list on the Enabled Children page is available. The list defines the role access to the particular child navigation items of the presentation.

If the Any Pages flag is not set, the list on the Enabled Children page is available. The list defines the role access to the particular pages of the presentation.


"Resources | Presentations | Selector Presentations" Page

The page is used to define the role access to the selector presentations of the selected class. This page is similar to the previous one. The list of permissions in the upper side contains the following:

  • Access. Allows to open the presentation. If the flag is not set, it is not possible to set the rest flags.
  • Create. Allows to create the objects from the presentation.
  • Delete All. Allows to delete all objects from the presentation.
  • Any Command. Allows to use any context commands published in the presentation.

If the Any Command flag is not set, the list of commands below becomes available. This list defines the role access to the particular commands defined in this presentation.


"Resources | Contextless Commands" Page

The page defines the role access to the contextless commands. The list below the toolbar displays all contextless commands defined in the layer. The columns Inherited Rights, Own Rights and Total Rights work in a similar way as the respective columns on the Server Resources page.


"Access Partition Families" Page

The page displays the list of access partition families associated with the role and the toolbar to manage this list.

The administrator can restrict role assigning only by the access partition families displayed on this page.

The table below describes the toolbar buttons:

Button

Name

Description

remove-anc.png

Delete Current Access Partition Family

Deletes the selected access partition family from the list.

remove-all.png

Delete All Access Partition Families

Deletes all access partition families from the list.

add-dependent.png

Add Dependent Families

Adds to the list all access partition families related to the classes mentioned on the Resources page.

select-in-tree.png

Select Family in Tree

Highlights the access partition family selected in the list in RadixWare Designer navigation tree.


example.jpgTo permit the administrator to assign to the user a certain role with respect to the user accounts belonging to this or that group, perform the following actions:

  1. On the Resources | Presentations page, add the presentation of the General editor of the Radix::Acs::User class.
  2. Set some permitting flags, for example, Access and Update.
  3. On the Access Partition Families page, click the Add Dependent Families button (add-dependent.png). If the procedure from Entity Class Editor was executed previously, the Radix::Acs::UserGroup class will be added to the list.

Phrase Books

The phrase books are the definitions used to facilitate translating of the applications in different languages. The definition of such type contains a set of phrases translated in all languages defined for the development layer or translated in some languages. These phrases can be used while working with the multilanguage strings editor.