What is Customization Studio
- Customization Studio allows non-developers to modify PowerBuilder applications
- They don't need development skill or source code!
- The persons making these changes are called "Customizers"
- They use an application called "Designer"
- They can edit PowerBuilder Windows like Microsoft Office Documents
- They modify an executable copy of the application.
The Customization Process
- The development team creates a PowerBuilder Application
- They generate an executable copy and deploy it on the Customizer's desktop
- The "Customizer" modifies the application with Designer
- The application has a new interface...
- ...and can be deployed to every user.
Applying changes to the Source code
How to update an application after the customization:
- The initial application is deployed with Customization Studio
- Each client customizes their copy of the application
Changes are saved in a file
- When new versions of the application are deployed,
changes are loaded again, and automatically applied.
If needed, Customization Studio can permanently apply the changes defined by the Customizer to the code.
This offers new ways of validating a User Interface:
By default, the UI validation requires multiple cycles of trial & error:
- Developers deploy the application
- Users send back their modification requests
- Developers update the application and deploy a new version, etc.
Customization Studio simplifies this process:
- End-users make changes directly in the UI
- Changes are temporarily saved in a repository
- Developers review the changes.
They can accept or reject each modification.
- Customization Studio modifies the source code automatically to apply these changes.
Applying changes to the Source code with Customization Studio
Adding new items
Customization Studio can do more than edit existing objects
- You can also add new items to the application:
- Cosmetic items (images, lines, group boxes, texts...)
- Fields from DW Buffer
- Coming soon:
- Add data from the DB in existing datawindows
- Add Computed Fields
- A Report Maker is also scheduled in the roadmap. Users will create new reports from within the application!
Customization Studio's Main Components
The Repository is a central piece of the Customization Studio Architecture.
It contains meta-data that will guide customizers when adapting the application:
- It makes customizations safer, by restricting modifications whenever it is necessary
- It also makes customizations easier, by replacing technical details with user-level information, and simplifying modifications of object attributes.
The Repository is created by developers, and deployed with the application.
- Which modifications are authorized within Designer:
- Which tool is available in Designer
- Which Objects or DW columns are blocked
- Which Fields can be manipulated within Designer (with the tool "Field")
- Field Attributes :
Initially defined by developers, they can be
edited later by Customizers with Designer:
- Initial Field values (constants)
- Default Field values (expressions)
- Fields validation rules (expressions)
- Hint (displayed by application Framework in status bar/microhelp, tooltip...)
- Required Field (True/False - should be used by application Framework)
- Hide Field (they will not be visible within Designer)
- Field sort order (defines how fields will be listed within Designer)
- Field Business names (used by Designer to replace DB names and better guide Customizers)
Different types of customizer can adapt the same application.
- A consultant can firstly customize the application for all the users in a company: presentation standard (title, fonts, colors), business terminology, add or hide data, rearrange screens...
- A Power User can personalize reports for his own use.
Templates allow you to control which customization features are accessible to each type of customizer. Templates also define which language is used in the Designer user interface.
An application can use several customizer profiles (1 template per profile).
The application logic will select the template of the current customizer.
Note: template permissions are a subset of repository permissions
The Repository defines:
- Which tools are available at application-level
- Which tools are available at objects-level
- Which tools are available at customizer-level.
- Only tools authorized at repository-level can be selected.
All the changes defined with Designer are stored by default in a file.
- In production, Customization Studio loads this file and applies the corresponding changes.
- Developers can review/update these changes with the Customization Studio Console
- Several customization files can be deployed with the application.Then, the application logic can evaluate which set of customization is appropriate for the current user, and apply it.
- It is also possible to concatenate several customization files (each file is basically a flat XML list). For instance, you can define several subsets of customizations, and the application logic will determine which subset should be grouped and applied in the application. This opens the possibility for modular customizations, defined by several people at different times, or offering several alternatives for a given module of the application.
Customization Studio Designer
Customizers use an application called "Designer". They can edit PowerBuilder Windows like Microsoft Office Documents. They modify an executable copy of the application without accessing the code.
Developers use NCS Console to:
- Create and update a repository.
- Create 1 template per customizer profile (language, features...)
When the application starts and NCS Designer opens,
the application logic selects and applies:
1 Repository, 1 Template,
1 Preference file, 1 Customization file
When Customizers adjust the NCS Designer settings, these settings are saved in the current preference file.
Customizers make changes in the application.
These changes are saved in a customization file.
When end-users run the application,
the application logic selects and applies a customization file.
If necessary, the developers can review/update customizations.
They can also apply permanently some changes to the code:
NCS will modify automatically the PBL.