A Common GUI Platform for Controls Applications
Vito Baggiolini, Katarina Sigerud
This project is a second phase of the StOpMI project. Its purpose is to provide a standard GUI development platform for the future Controls GUI software needed for the SPS and the LHC. It shall enable teams to contribute modules to a common controls GUI, and provide common GUI components (e.g. an Explorer) that can be shared and re-used. This work is done in response to new and changing requirements that were not covered by the mandate of the original StOpMI project.
The project shall be organized as a small core team that collaborates with so-called “external” GUI developers in other projects. The core team has two main tasks: (1) provide the common GUI platform based on the NetBeans platform [1] and on deliverables of the original StOpMI project and (2) set up a support structure to help the external GUI developers use the common platform and to migrate their old StOpMI based applications to the new platform. The external developers develop their project specific GUIs, and assure the link between the core team and their project.
The project starts on July 1 2002 and lasts for 9 months. It requires a total manpower of 1 man-year.
Around 3 years ago, the StOpMI project was launched with the aim to provide the elements necessary to build standardized GUIs for the PCR. This project produced a common look and feel, a series of JavaBean components, a simple Frame that can hold the GUIs developed using the JavaBeans, and a central event-dispatching component called the OPController.
Over the last few years, several Java projects (e.g. CMW, SPS-2001, Biscoto, Cesar, Laser) have started to implement GUIs. Some of the projects have used StOpMI, while others have used Java/Swing directly. It has thus become apparent that the deliverables of the StOpMI are not sufficient anymore. While StOpMI did provide necessary GUI building blocks, it fell short in two points: it lacks some common GUI components (e.g. an Explorer Tree) and it does not specify a clear architecture needed to guide developers.
Each of the mentioned projects has filled in the missing elements “their own way”. This has lead, for one thing, to redundant implementations of common GUI building blocks (e.g. there are 5 implementations of an Explorer Tree). Furthermore, each project has used a different, often ad-hoc architecture, and different ways of linking general-purpose GUI elements with the project-specific parts of their GUIs. As a consequence, it is impossible to share components or to integrate different GUIs into a common controls application.
To correct this situation, we propose to provide a basis for coordinated and collaborative GUI development. In our view, this should start as soon as possible, before the projects consolidate their solutions and continue to invest more effort in their developments.
As StOpMI, this project strives for a common framework that enables coordinated and collaborative GUI development. Such a platform should allow several teams to work together on GUIs, whereby each team contributes their modules to the overall GUI. For example, when developing the controls GUI for the SPS Experimental areas, the Cesar project team would develop the main part of the GUI for accelerator operations and integrate modules from other teams – the alarms team would contribute the Alarm console GUI and an equipment group the panel for low-level Equipment diagnostics (e.g. Biscoto GUI). Of course, the Alarm console GUI and the equipment diagnostic modules could also be used in other controls GUIs. A common architecture is needed for this, with clear guidelines on how to develop such pluggable modules, and how to combine them to a common overall GUI.
To achieve this, we propose to use the NetBeans GUI development platform and combine it with the software produced by StOpMI. NetBeans has those elements that are missing from StOpMI – it provides (1) the architecture plus guidelines, (2) a frame in which to plug GUI modules, and (3) GUI elements missing from StOpMI, such as the explorer. StOpMI, on the other hand, provides the JavaBeans (e.g. Buttons, TextFields, Labels etc), and the standard look-and-feel. In other words, NetBeans and StOpMI are two complementary parts that can be easily integrated.
NetBeans is a public domain project lead by Sun Microsystems. It is technically sound, and well documented (on its web site and in a forthcoming book from O’Reilly), and it has an active user community. Last but not least, it has proven suitable for collaborative development by multiple teams. It has been developed in a public-domain project, and many different teams develop Modules, that can be plugged into the NetBeans core.
We are carrying out this project to solve the problems described in the “Background” section and to implement the plan outlined in the “Project Vision”. In summary, we want:
· To coordinate efforts in GUI development, to make good use of manpower and avoid redundant development of similar functionality.
· To enable different teams to contribute GUI modules to a common controls application, with a common look-and-feel and shared software components.
· To provide developers with the means to effectively develop modern GUIs with full-fledged functionality.
This section describes how we plan to attain the above purpose. Section 5.1 describes the work that falls within the responsibility of the project, and section 5.2 lists the items that are outside its responsibility.
This project is responsible for the following major tasks. Note that the first three are part of the active project period, while the fourth is work to be done during maintenance.
1. Develop
the common platform for Control GUIs
· Gather user requirements and match them against functionality of NetBeans and StOpMI.
· Assess and mitigate risks of using NB for our purposes.
· Integrate parts of NetBeans, StOpMI, ASCBeans, Jdataviewer, CMW, Biscoto and other shareable components, into the common platform.
· Provide documentation and example programs.
2. Elaborate
recommendations and guidelines of how to develop with the common platform
· Elaborate multi-team development process tailored to our environment.
· Select tools for GUI development and testing.
3. Set
up a support structure and provide support to users
· Elaborate and implement a support structure for the platform and the development tools.
· Prepare training and support material.
· Help users in getting started with the platform and development tools.
· Migrate old, StOpMI-based applications to the new common GUI platform.
· Interact with the NetBeans community (e.g. for bug reports, asking questions, etc).
4. Maintain developments and support material
· Adapt the common GUI platform and documentation to changes in versions of NetBeans or the JDK.
· Correct bugs in code and documentation.
·
Maintain and enlarge collection of FAQs and How-to’s,
in response to frequent user questions.
The project is not responsible of the following tasks:
· Development of new applications based on the common Controls GUI platform. This is done by the project teams themselves.
· Migration of Swing (i.e. non-StOpMI) GUIs belonging to other projects to the new platform. However, the project provides support for migration.
· Maintenance of project-specific GUI projects, which have been developed using the new platform. Maintenance of the project-specific software lies within the projects.
· Enforce use of the common GUI platform in the projects – this can only be done by the management.
Here is a summary of the deliverables we intend to provide to the end user and/or the stakeholders.
· User Requirements Document (URD): all developments shall be based on the URD, which will be elaborated together with the users.
· The Common Platform software:
o The NetBeans platform, as provided by Sun Microsystems
o Existing CERN components (StOpMI, ASCBeans, JDataViewer, etc) migrated to the common platform
o Additional CERN general-purpose components developed within the project, as agreed on in the URD.
· Related documentation:
o Installation instructions.
o Getting-started guide (c.f. “Training and Support”).
o Hands-on instructions for using recommended NetBeans features and modules.
o General recommendations on how to use the common platform (e.g. level of integration between the common platform and project-specific panels).
o Document describing its interfaces to other areas of development (e.g. Middleware, device proxies).
· Training material: a series of technical presentations teaching the users to get started with the common platform and to write develop basic GUIs with it.
· A support infrastructure: a web site with all documentation for users and stakeholders, a mailing list for questions etc.
· Migrated StOpMI applications: the project will migrate existing applications that were developed with the StOpMI infrastructure to the new common platform.
· A long-term maintenance plan with responsibilities assigned.
The project is estimated to require a total manpower of 1 man-year. It is scheduled to start on July 1, 2002, and to last for 9 months.
The project shall be organized as a core team of 6 persons, and a group of external developers, one from each collaborating project.
The core team carries out the work described in this project description. The members are:
|
· Vito Baggiolini (project leader) |
with help from two collaborators: |
|
· Serguei Chtcherbakov |
· Maria Jose Jorda Garcia |
|
· Lionel Mestre |
· Eric Roux |
|
· Katarina Sigerud |
·
|
The external developers shall ensure the collaboration with and between the participating partner projects. For instance, the external developers shall:
· Contribute the user requirements from their projects.
· Develop new project-specific GUIs using the common platform technology.
· Act as first-line help for their team colleagues.
· Assure that their team colleagues use the common platform technology properly and provide mutually compatible elements.
· Participate in coordination of developments amongst the different project teams, to avoid redundancy and to make collaborative GUI development effort possible.
.