Docstoc

_Sandcastle_-MaintenanceGuide.docx - MSE Studio

Document Sample
_Sandcastle_-MaintenanceGuide.docx - MSE Studio Powered By Docstoc
					Sandcastle



Maintenance Guide
1.0
Architecture Studio




Ahn, Cho, Chotemateepirom, Haider, Zgraggen
Sandcastle Team                                                                            25 April 2013


Revision History

Date          Version    Author       Description
08/27/2009    0.1        Sam          Outline
09/13/2009    0.2        Guido        Put it in this document and made a first draft of the document
10/5/2009     0.3        Jaffer       Reviewed and refined the document.
10/6/2009     0.4        Jaffer       Added section on Quality and Testing, 5 subsections in the How
                                      To section.
10/28/2009 0.5           Benjamas     Added 4 subsections in the How To section.
10/30/2009 0.6           Benjamas     Added 2 subsections in the How To section.
11/4/2009 0.61           Jaffer       Added a section on setting up the development environment on
                                      Linux.
11/9/2009     0.62       Benjamas     Added a section on modifying the validation properties of the
                                      domain model.
11/9/2009     0.63       Soo-Yung     Added sections on building products and setting up development
                                      environment.
11/14/2009 0.64          Sam          Added section 3 about the libraries used. Added section 7.3 about
                                      adding a toolbar button or menu item.
11/15/2009 0.65          Guido        Added section 4.3 about the Eclipse version.
11/16/2009 0.66          Sam          Cleaned up the document, fixed grammar, and corrected
                                      inconsistencies.
11/24/2009 0.67          Sam          Added note about enabling or disabling the export document
                                      functionality.
11/24/2009 0.68          Jaffer       Added a reference to the list of open Trac tickets site.
11/24/2009 1.0           Sam          Changed the section on enabling or disabling the export
                                      document to building the trial version.




Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                              Page 2 of 25
Sandcastle Team                                                                                                                                 25 April 2013



Contents
1     Purpose of this Document .................................................................................................................... 5
    1.1      Related Documents ....................................................................................................................... 5
2     Overview of Architecture Studio........................................................................................................... 5
    2.1      Elevator speech ............................................................................................................................. 5
    2.2      User Guide .................................................................................................................................... 6
3     Libraries and Technologies ................................................................................................................... 6
    3.1      RCP ................................................................................................................................................ 6
      3.1.1          Training Plan.......................................................................................................................... 6
    3.2      SWT, JFace, and Jigloo................................................................................................................... 7
      3.2.1          Training Plan.......................................................................................................................... 7
    3.3      EMF ............................................................................................................................................... 7
      3.3.1          Training Plan.......................................................................................................................... 8
    3.4      GEF ................................................................................................................................................ 8
      3.4.1          Training Plan.......................................................................................................................... 8
    3.5      GMF ............................................................................................................................................... 8
      3.5.1          Training Plan.......................................................................................................................... 9
4     Development environment ................................................................................................................... 9
    4.1      Eclipse version, plugins and settings............................................................................................. 9
      4.1.1          Eclipse Formatter Settings .................................................................................................. 10
    4.2      Other tools .................................................................................................................................. 10
    4.3      Build Script .................................................................................................................................. 10
    4.4      New Eclipse ................................................................................................................................. 10
5     Quality and Testing ............................................................................................................................. 11
6     Architecture and Detailed Design ....................................................................................................... 12
    6.1      Architecture ................................................................................................................................ 12
    6.2      Detailed Design ........................................................................................................................... 12
    6.3      Utilities project............................................................................................................................ 12
    6.4      Config.properties ........................................................................................................................ 13
7     How to:................................................................................................................................................ 13
    7.1      Add a new property section to the properties tab ..................................................................... 13



Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                                                                 Page 3 of 25
Sandcastle Team                                                                                                                        25 April 2013


    7.2      Add a toolbar button or menu item ........................................................................................... 14
    7.3      Add an RCP view ......................................................................................................................... 14
    7.4      Modify generated GMF code ...................................................................................................... 15
    7.5      Build the product (from Eclipse) ................................................................................................. 15
    7.6      Build the product (without Eclipse) ............................................................................................ 16
    7.7      Change the properties of a default type or add a new default type .......................................... 16
    7.8      Add an option in the context menu for an element/relationship/group/view .......................... 17
      7.8.1         Adding menu item through plugin.xml ............................................................................... 17
      7.8.2         Adding menu item through the ASDiagramEditorContextMenuProvider .......................... 17
    7.9      Listen for changes in the instance model ................................................................................... 18
    7.10     Listen for when a project is loaded and unloaded...................................................................... 19
    7.11     Manipulate the instance model .................................................................................................. 19
    7.12     Modify the domain model .......................................................................................................... 20
    7.13     Modify the validation properties of the domain model ............................................................. 20
    7.14     Regenerate EMF source files ...................................................................................................... 23
    7.15     Regenerate GMF source files ...................................................................................................... 23
    7.16     Set up the development environment........................................................................................ 23
    7.17     Setup the development environment on Linux .......................................................................... 23
    7.18     How to build the trial version of the application ........................................................................ 24
8     Possible future work ........................................................................................................................... 24




Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                                                        Page 4 of 25
Sandcastle Team                                                                               25 April 2013



1 Purpose of this Document
This document is intended for the maintainers of Architecture Studio. By this we mean people who are
interested in changing or updating features or the behavior of the tool. This should be the starting point
for all the people who are not familiar with our architecture, design, and code.

This guide gives an overview of the software, the technology, and the development environment, and
also provides some ideas about what could be improved in a future version. There is also a ‘how to’
section at the end which outlines common development related tasks.

1.1 Related Documents
A good starting point is the ACDM book from Tony Lattanze [Lat08]. Without the basic understanding of
his view of how software architecture should be documented, it will be hard to extend this tool in the
right way.

The following documents will be helpful for understanding what we did, and why we did it in a certain
way:

       [Sandcastle]-ArchitecturalDriversSpecification.docx: This document contains the architectural
        drivers for the system (use-cases, quality attribute scenarios, technical constraints, and business
        constraints). It also contains some requirements that are not currently implemented, e.g. the
        warnings system.
       (Sandcastle)-CodingStandard.docx: This document describes the coding standards we followed
        while constructing the application. Maintainers are advised to have a look at this standard since
        code quality was an important aspect for our client.
       (Sandcastle)UIStandards.docx: This document contains a list of items that must be verified
        against all user interface items (dialogs, windows, etc.) for the Architecture Studio application.
       (Sandcastle)Product Glossary.docx: This document contains all the definitions and acronyms we
        used.
       (Sandcastle)SoftwareArchitectureDocumentation.docx: This document contains the whole
        description of the architecture with all three different perspectives.
       source/documentation/index.html: This document contains the detailed design for the
        application including class diagrams, descriptions of the classes, and descriptions of the public
        methods in those classes. This document can be found with the source code.
       (Sandcastle)-TestSpecification.docx: This document contains the user scripts to test all of the
        functionality in the application.



2 Overview of Architecture Studio
2.1 Elevator speech
Our product is called Architecture Studio. We want this tool to be a platform for software architects to
craft the architectures for their software projects.


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                 Page 5 of 25
Sandcastle Team                                                                                25 April 2013


This tool is a Java based desktop application. The tool encourages good architecture practices as
described in [Lat08]. One of the most important practices is to look at the architecture from the static,
dynamic, and physical perspectives. Furthermore, the tool encourages gathering architectural drivers
which can be assigned to different architectural elements. The tool has many more features like creating
mappings between elements in different views. The tool also provides an element and relationship
catalog and manages the legends of the design diagrams. And to provide some notational flexibility for
the architected, the user can create their own notation by adding additional element and relationship
types to the palette.

2.2 User Guide
For a more detailed description on how certain features of Architecture Studio are used please read the
user guide. You can access the user guide from Architecture Studio through the Help -> User Guide
menu option. You can also open the user guide manually by opening the index.html file in the user-
guide directory in the installation directory of Architecture Studio.



3 Libraries and Technologies
This project required the use of several important technologies. Maintainers should be aware of the
technologies used by this application and should be familiar with these technologies in order to make
changes in the areas of the application that use these technologies. Following are descriptions and
introductions to the technologies used by the application. Note that each of the following libraries is a
part of the Eclipse framework. They can be used outside of Eclipse. Please refer to the Architectural
Experiments Knowledgebase1 for more information.

Each of the following sections includes a training plan. The training plans will provide a high level
overview of the technologies to understand how they are used by the application. But more detail will
often be required for development work.

3.1 RCP
RCP (Rich Client Platform) is the windowing framework used by the application. It controls the layout,
appearance, and behavior of the main window, the menu bar, the toolbar, and the views and editors
(i.e. the panes). The architecturestudio project makes extensive use of the RCP library.

3.1.1 Training Plan
          Go through presentation at http://eclipsezilla.eclipsecon.org/php/attachment.php?bugid=3667
          Install Eclipse for RCP/Plug-in developers
          Install sample source files for eclipse Rich Client Platform. Directions are at
           http://eclipsercp.org/book/cd.php
               o Use the "Sample and Tools" on this website to install the examples from an update site.
          Read/skim chapters 2 through 7 (pp 13 - 112) of eclipse Rich Client Platform. View and run the
           sample code for those chapters.
1
    The Architectural Experiments Knowledgebase can be found on Sandcastle’s Google Site.


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                 Page 6 of 25
Sandcastle Team                                                                                 25 April 2013


3.2 SWT, JFace, and Jigloo
The SWT (Standard Widget Toolkit) library contains user interface widgets, including dialogs, buttons,
tables, and edit boxes, which are used to create the user interface for the application. Virtually every bit
of user interface in the application makes use of SWT. It is used by the following projects:
architecturestudio, architecturestudio.architecturaldriver,
architecturestudio.customtype, architecturestudio.diagramming, and
architecturestudio.tool.

JFace provides a model-view-controller wrapper to some SWT widgets. It is used in some places in
architecturestudio.architecturaldriver, and architecturestudio.diagramming.
Wherever JFace is used, it is also possible to use the SWT widgets without using JFace. Therefore, the
use of JFace in the application is not consistent. JFace is used in some places and not used in others.

Jigloo is an Eclipse plugin that provides a graphical interface allowing developers to draw user interfaces.
Jigloo will auto-generate source code implementing the user interface drawn by the developer. It should
be noted that Jigloo isn’t perfect. In certain cases, we found it easier to write the user interface code by
hand without using Jigloo.

3.2.1 Training Plan
       Create a basic UI using Jigloo following the steps in the tutorial at:
        http://www.cloudgarden1.com/swt_tutorial/index.html
       Read/skim the information and the sample code at:
        http://www.java2s.com/Tutorial/Java/0280__SWT/Catalog0280__SWT.htm
       Integrate the sample code on the following pages with the code created during the tutorial:
            o SWT Widget: http://www.java2s.com/Tutorial/Java/0280__SWT/0040__Widget.htm
            o Button: http://www.java2s.com/Tutorial/Java/0280__SWT/0180__Button.htm
            o Text: http://www.java2s.com/Tutorial/Java/0280__SWT/0300__Text.htm
            o List: http://www.java2s.com/Tutorial/Java/0280__SWT/0300__Text.htm
            o Table: http://www.java2s.com/Tutorial/Java/0280__SWT/1020__Table.htm
            o Menu: http://www.java2s.com/Tutorial/Java/0280__SWT/0560__Menu.htm
       Read the following pages:
            o GridLayout: http://www.java2s.com/Tutorial/Java/0280__SWT/1960__GridLayout.htm
            o GridData: http://www.java2s.com/Tutorial/Java/0280__SWT/1960__GridLayout.htm

3.3 EMF
EMF (Eclipse Modeling Framework) is a modeling framework that is used in our application to manage
the in-memory representation of the user’s project data, to persist the data to disk, and to perform
validation on the data. EMF provides functionality allowing the developer to diagram the data model
graphically, and auto-generate the code implementing that data model. EMF is used extensively in the
following projects: architecturestudio.project, and architecturestudio.project.edit.
Because EMF is used to represent the user’s project data, it is used less extensively by other projects
which read and modify the user’s project data, including



Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                  Page 7 of 25
Sandcastle Team                                                                              25 April 2013


architecturestudio.architecturaldriver, architecturestudio.customtype,
architecturestudio.diagramming, architecturestudio.project, and
architecturestudio.tool.

3.3.1 Training Plan
       Read
        http://www.eclipse.org/modeling/emf/docs/presentations/EclipseCon/EclipseCon2008_309T_F
        undamentals_of_EMF.pdf
       View http://redmonk.com/tv/2007/07/20/eclipse-emf-demo-large/
       Read/skim chapters 2 through 4 (pp 11 through 100) in EMF: Eclipse Modeling Framework,
        Second Edition.
       (Optional) Do exercises in chapter 4. You can skip the part about importing from Rational Rose.
       Read
        http://help.eclipse.org/ganymede/index.jsp?topic=/org.eclipse.emf.transaction.doc/references/
        overview/transactionOverview.html to get an overview of the EMF transaction framework.
       Read
        http://help.eclipse.org/ganymede/index.jsp?topic=/org.eclipse.emf.validation.doc/references/o
        verview/ValidationOverview.html to get an overview of the EMF validation framework.

3.4 GEF
GEF (Graphical Editing Framework) is a library providing functionality allowing developers to create
graphical editors using a model-view-controller architecture. The GEF libraries must be provided some
data model and a mechanism to represent the data model graphically. Given this, GEF provides the
developer with editors which display the graphical representation of the data to the user, and allow the
user to interact with the graphical representation and thereby make changes to the underlying data
models. GEF is used extensively by the architecturestudio.customtype project and by the
architecturestudio.diagramming project. The architecturestudio.diagramming project
also uses GMF which provides additional functionality on top of GEF.

3.4.1 Training Plan
       Read: http://eclipsewiki.editme.com/GefDescription, sections 1 and 2. (Optional) Skim the rest
        AFTER you've done the reading in step 2.
       Read: https://msesrv4c-vm.mse.cs.cmu.edu/svn/studio/experiments/3 - GEF/eclipse Plug-ins,
        Chapter 20, GEF Graphical Editing Framework.pdf
       At the same time look at the example code (referenced above) and relate the code with what
        you're reading.
       (Recommended) Read: http://www.ibm.com/developerworks/opensource/library/os-gef/. This
        is a good read, just to consolidate what you've learnt about GEF up till now.

3.5 GMF
GMF (Graphical Modeling Framework) is a library tying together the features of EMF and GEF. It
provides features allowing developers to use EMF for the data representation and GEF for the graphical



Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                               Page 8 of 25
Sandcastle Team                                                                              25 April 2013


representation. There are two main parts of GMF, the code generation tool, and the runtime library. The
developer provides the code generation tool with the data models and descriptions of the graphical
representations of the data models. The code generation tool will auto-generate the code implementing
the graphical editors using the provided EMF data models and graphical representations. The graphical
editors use the GMF runtime library. Much of the code implementing the graphical editors in
architecturestudio.diagramming was generated using the GMF code generation tool. And that
code uses the GMF runtime library. Thus, it is critical to have a solid understanding of GMF in order to
understand the code for the graphical editors in architecturestudio.diagramming. Note that the
custom type editor in architecturestudio.customtype DOES NOT use GMF since it uses its own
custom data models rather than using EMF for the data models.

3.5.1 Training Plan
       Install Eclipse Modeling Tools by following the next few steps or the Sandcastle version of
        Eclipse.
            o Browse to http://www.eclipse.org/downloads/
            o Install the Windows version of the Eclipse Modeling Tools (by downloading and
                 extracting it to an appropriate folder like c:\program files\EclipseModeling using
                 WinRar).
                       Note: Make sure to download eclipse-modeling-ganymede-SR2-incubation-
                         win32.zip. Depending how you get there the link may be for SR1.
       Browse to the folder where you installed the Eclipse Modeling Tools and run eclipse.exe.
       Select Help->Cheat Sheets...
       Perform the steps in http://wiki.eclipse.org/index.php/GMF_Tutorial
            o Note: this is the same tutorial as in Help->Cheat Sheets->Graphical Modeling
                 Framework->GMF Tutorial, but be sure to read the tutorial since that has more
                 information than the Cheat Sheet.
            o Note: We were able to download the Mindmap and the TaiPan examples from the CVS
                 repository as described in the tutorial. And we were able to run the Mindmap
                 application but not the TaiPan application.
            o Also try selecting the "Generate RCP Application" when creating the generator model.
       (Optional) read the presentation at
        http://www.eclipsecon.org/2008/index.php?page=sub/&id=337
       (Optional) View the webinar (45 min) at http://live.eclipse.org/node/418



4 Development environment
4.1 Eclipse version, plugins and settings
We used Eclipse to do our development. We downloaded the Eclipse modeling tool (version 3.4.2) and
added several plugins to meet our requirements. Following is a table of all the plugins our version had
with a description of what they were used for.



Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                               Page 9 of 25
Sandcastle Team                                                                                25 April 2013


Plugin                 Description
EMF                    Eclipse Modeling Framework allows the creation of code based on a model.
GMF                    Graphical Modeling Framework which makes the interaction between EMF and
                       GMF easier.
GEF                    Graphical Editing Framework can represent models graphically.
Subclipse              This SVN plugin synchronizes the code with our code repository.
FindBugs               This plugin was used to achieve a high code quality by finding potential bugs
                       early in the development cycle.
Mylyn                  This plugin was used to interact with our ticketing system (Trac)
Jigloo                 This plugin is a user interface design tool and was used to make the initial
                       version of our user interface.


4.1.1 Eclipse Formatter Settings
We used the built-in Eclipse formatter to ensure that all the developers follow the coding standard. The
details on the formatter can be found in the Eclipse properties. The properties dialog has an export and
import function for the formatter configuration which is stored in an xml file. The name for our xml file
is (Sandcastle)-EclipseFormatter.xml and can be found in the SVN repository.

4.2 Other tools
Here is a table of all the tools we used to support our implementation.

Plugin                 Description
Trac                   Open source ticketing system. All the remaining open tickets are listed in
                       chapter 7.17
SVN                    This tool was used for version control.
Process Dashboard      This Java based tool was used to track time and several metrics related to TSP
                       (Team Software Process), and also contained our iteration plans.
IBM Rational           We used this tool only to generate class diagrams which we embedded in some
Software Architect     Javadoc pages.

4.3 Build Script
The build script that is provided with the source code is used to build the product. The product includes
an executable file to start the application and configuration files. If you are trying to build the product
inside of Eclipse, this build script is not necessary. However, it is required to build the product without
running Eclipse. The build script is in SVN with the source code at

architecturestudio/script/product_build_script/.

Instructions to set up the scripts and to run the build can be found in
“architecture_studio_build_setup_instruction.txt” in the location stated above.

4.4 New Eclipse
Eclipse releases a new version every year, and this was the case during our project. The team decided to
finish the development with Eclipse version 3.4, ‘Ganymede’, and not switch to the new version of


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                 Page 10 of 25
Sandcastle Team                                                                               25 April 2013


Eclipse, version 3.5, ‘Galileo’. In the fall 2009 semester, we tested if there would be any major problems
if a future team would use the newer version. Except for two errors which need to be fixed, there were
no major problems with the newer version. A future team could use the newer Eclipse version as their
development environment.

The two errors mentioned is the result of the class “PolygonShape” which is part of draw2d and included
in the new Eclipse version. Since we created a class with the same name it is necessary add an import
statement which selects the right class.

The following line need to be added to the two classes which use our PolygonShape.

import architecturestudio.customtype.viewitemtypeeditor.model.PolygonShape;



5 Quality and Testing
For details on the code quality measures we had in place during the construction phase of the project,
please refer to the (Sandcastle)QualityAssuranceProposal.docx document. This section is an overview of
the material in that document so that you have an idea of how to maintain the quality of the
Architecture Studio source code.

The table below summarizes the quality assurance activities that we performed on the source code.

Activity          Description                                  Reference documents
Static Analysis   We used FindBugs to ensure that there        N/A
                  were no high priority warnings in hand
                  written code.
Personal code     The author of the code reviewed the          (Sandcastle)PersonalReviewChecklist.docx
review            code using a checklist before they
                  checked it in.
Buddy check       A reviewer performed a full inspection of    (Sandcastle)BuddyCheckChecklist.docx
                  the code, and discussed defects with the
                  author. Fixes made by the author were
                  verified by the reviewer.
Walk through      The author(s) would walk the team            N/A
                  through the code for certain functionality
                  in a meeting. Defects were found during
                  the meeting.
Unit testing      Unit tests were written for non-UI code      The unit tests are located in the
                  using JUnit.                                 architecturestudio.test project.
Functional        Author of a feature wrote test cases that    (Sandcastle)-FunctionTest-CycleN.docx
testing           could be performed manually to test their    (Sandcastle)-TestSpecification.docx
                  functionality. Test cases were performed
                  during the functional testing phase.
System testing    The system tests were performed based        (Sandcastle)-SystemTest-CycleN.docx
                  on the documentation in the                  [Sandcastle]-
                  Architectural Drivers Specification (ADS)    ArchitecturalDriversSpecification.docx


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                Page 11 of 25
Sandcastle Team                                                                                25 April 2013


                   (primarily the use cases and quality           (Sandcastle)-TestSpecification.docx
                   attribute scenarios).
Usability          Usability tests were performed with test       (Sandcastle)UsabilityTestPlan.docx
testing            users after much of the functionality was
                   written to check for usability issues. It is
                   recommended that some sort of usability
                   heuristics or tests be performed when
                   new UI is implemented.




6 Architecture and Detailed Design
6.1 Architecture
As mentioned above, our architecture is documented in the
(Sandcastle)SoftwareArchitectureDocumentation.docx. The diagrams in this document were created
using various tools:

       Microsoft Visio
       Star UML (this tool was used for most diagrams)
       Eclipse GMF plugin (for the domain model)

In our architecture, the physical view represent the allocation decomposition which includes the
deployment style and the Eclipse project structure. After understanding the architecture of our tool, it is
important to understand our project structure to find the related functionality in the code.

Another important aspect of our architecture is the domain model of our underlying data structure. EMF
uses this model as a base. Therefore all the functionality we provide is based on this model. To add new
functionality it might be wise to study this domain model first.

6.2 Detailed Design
We decided to embed our detailed design directly in the code. This means that we used Javadoc to
document the detailed design. In addition to the common tags which can be added in the code we also
added an overview page for every project and package. We included UML class diagrams in these
overview pages to make the detailed design easier to understand. We defined the Javadoc tags which
we used in the coding standard. There is no formal guidance on how to create the overview pages. The
main page for the detailed design can be found at source/documentation/index.html.

6.3 Utilities project
We decided to create a Utils module in our architecture which contains all functionality which we used
throughout the whole project. In the Eclipse project structure this module can be found in its own
project: architecturestudio.util. This project contains the following components:

Functionality     Description


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                 Page 12 of 25
Sandcastle Team                                                                                   25 April 2013


Logging           The logging part is the interface for all logging actions. The behavior of this part can
                  easily be changed through the config.properties (see 6.4) file.
I18N              I18N stands for Internationalization and handles string externalization. This makes it
                  easier to change strings within the UI, because it does not require recompiling the
                  code. It will also make it easier to translate the tool into a different language.
IO                This part handles the interaction between the file system and the tool.
UI                This part contains helper classes for creating user interfaces. Look in here for some
                  constants and methods that apply standard layout rules (like button dimensions), these
                  should be used for consistency of the UI.
The main idea of this package is to reuse code and have a single point to store utility functions which are
not directly related to other projects.

6.4 Config.properties
This file is located in the root folder of the product and is used to set global settings for the tool. These
settings include options for the logging and location of the project data and could be extended to
include any other configuration an experienced user might want to change. The idea is that this
configuration file is accessible for a user in the main project folder and can directly be edited without
recompiling the code.



7 How to:
7.1 Add a new property section to the properties tab
The properties tab we are talking about here is the properties tab in the Design perspective. This tab
makes use of “The Eclipse Tabbed Properties View” (see http://www.eclipse.org/articles/Article-Tabbed-
Properties/tabbed_properties_view.html for reference). The following steps outline the procedure for
adding a new property section to the properties tab:

    1. Open up architecturestudio.diagramming/plugin.xml and add a propertyTab tag in the
       org.eclipse.ui.views.properties.tabbed.propertyTabs extension point. Look at the other
       propertyTab tags in this extension point as a reference for how you have to configure it. Note
       that the “extra” property category is already defined in the
       org.eclipse.ui.views.properties.tabbed.propertyContributor extension point. We used this
       category for all tabs we have added by ourselves.
    2. Create a property section class that extends the architecturestudio.diagramming.sheet.
       ArchitectureStudioBasePropertySection class. Implement the createControls() method for
       creating the UI and refresh() method for updating data of the UI based on the selection on the
       diagram editor. (You might look at the GroupAppearancePropertySection class for an example)
    3. Create a filter class that implements IFilter interface. Implement the select() method to return
       true only if the types of the selected object are ones you want to show this property. Note that
       this class can be shared among different property sections if they want the same filter. (Look at
       the GroupAppearancePropertySectionFilter class for an example)




Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                   Page 13 of 25
Sandcastle Team                                                                                    25 April 2013


    4. Go back to the architecturestudio.diagramming/plugin.xml and add a propertySection tag in the
       org.eclipse.ui.views.properties.tabbed.propertySections extension point. Look at the other
       propertyTab tags in this extension point as a reference for how you have to configure it. Note
       that the attribute value of “filter” key should be the fully qualified name of the class you created
       in step 3. The attribute value of the “class” key should be the fully qualified name of the class
       you create in step 2. Also, the attribute value of “tab” key should be the id of the propertyTab
       tag you created in step 1.

7.2 Add a toolbar button or menu item
In many cases, adding features to Architecture Studio will require the addition of a tool bar button or
menu item. This can be accomplished by performing the following steps.

    1. Create a class to implement the functionality provided by the toolbar or menu item. This class
       must extend org.eclipse.jface.action.Action.
    2. Alternatively, the source code from an existing action can be copied and modified.
    3. In this new class, specify the ID for the action by creating the following attribute (remember to
       replace [action id] with a unique ID, e.g. the fully qualified name for the class):
        public static final String ID = "[action id]";
    4. In the constructor, for the class, initialize the text of the action by called “setText”. Initialize the
       icon for the action by calling “setImageDescriptor”. Initialize the enabled state of the action by
       calling “setEnabled”.
    5. Add the code to be executed when the action is selected by adding or modifying the “run”
       method in the class.
    6. If the class is not in the architecturestudio project, ensure that the package containing the class
       is exported by the project. The package containing the action should be listed under “Export-
       Package” in MANAFEST.MF in the META-INF folder of the project.
    7. Modify architecturestudio.windowing.ArchitectureStudioActionBarAdvisor to add the action to
       the appropriate menu or toolbar.
    8. To add the action to the menu bar, add a line to construct the action and add it to the menu in
       one of the following functions: asFillFileMenu, asFillEditMenu, asFillToolsMenu,
       asFillCustomTypeMenu, or asFillHelpMenu.
    9. To add the action to the toolbar, add a line to construct the action and add it to the tool bar in
       fillCoolBar.

7.3 Add an RCP view
An RCP view is a separated area that has tabs in the RCP perspectives. Those tabs are labeled with text
and icons and the user can click on the tabs to select the RCP view. Widgets, such as buttons, combo
boxes, and text areas, can be added to each RCP view. In the application, the user can select a tab of the
RCP view to use those widgets and modify inputs defined in the area. For example, The RCP views in
“Architectural Drivers” perspective are “Use Case Entities”, “Operational Use Cases”, “Quality Attribute
Scenarios”, “Technical Constraints”, “Business Constraints”, and “Architectural Drivers Property”.




Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                    Page 14 of 25
Sandcastle Team                                                                                 25 April 2013


The following defines the steps that must be performed in order to add a RCP view to one of the
perspective:

    1. Open plugin.xml file in the project that you want to add the RCP view class to.
    2. Select “Extensions” tab at the bottom.
    3. You can skip this step if you already see “org.eclipse.ui.views” extension in the list on the left
       side. If you do not see “org.eclipse.ui.views” extension in the list, use “Add…” button to add the
       extension. When you click on the button, it will pop up a dialog and you can search for
       “org.eclipse.ui.views”.
    4. Right click on “org.eclipse.ui.views” entry, select “New” in the menu shown, and select “view”.
       This will allow you to edit entries for the view on the right side. For those entries:
       A. Define id for this view. This must be unique from all other views in the project.
       B. Define name of this view. This will be shown in the tab of the view.
       C. Define a class for this view. The view GUI will be implemented in the class that you define
            in this entry.
    5. Go to the class that you have defined in the previous step. There is
       “createPartControl(Composite parent)” method in the class. You can modify the GUI of this
       view in this method such as adding widgets.
    6. Go to the perspective class that you want to add this view to. You can find
       “createInitialLayout(IPageLayout layout)” method in the class. You can add the view in the
       method using “addView” or “addStandaloneView” method in IPageLayout class. You have to
       pass in the id of the view that you have defined in the step 4 as parameter to those methods.

7.4 Modify generated GMF code
There is some code in the architecturestudio.diagramming project that is generated by GMF. It
is important to make it easy for developers to regenerate the code without breaking anything or
undoing their changes. That is why whenever we want to make a change something in a class that was
generated, we subclass it and override parts of it that introduce the changes we want to make. You will
see this pattern in many packages inside the architecturestudio.diagramming project. Hand
written classes that subclass a generated class and override some behavior start with the ‘AS’ prefix. For
example, ArchitectureStudioViewProvider is overridden by
ASArchitectureStudioViewProvider. It is recommended that this pattern be followed so that you
face minimal problems when you regenerate GMF code in the future.

7.5 Build the product (from Eclipse)
The application can be built and packaged into a single .exe file. This can be done with the help of the
Eclipse product export wizard. This wizard uses our product definition file in our source code. The file is
located at architecturestudio/architecturestudio.build.product. The followings steps show the
procedure to build a product in eclipse:

    1. Open architecturestudio/architecturestudio.build.product file.
    2. Select “Overview” tab at the bottom and click on the “Eclipse Project export wizard” link at the
       bottom right part of the screen. This will popup a “Export” dialog.


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                 Page 15 of 25
Sandcastle Team                                                                               25 April 2013


    3. In “Destination” section, select the folder that you want to export to and click on “Finish”
       button.
    4. You can find an executable file for the application in the selected folder in the previous step.

7.6 Build the product (without Eclipse)
The product can also be built using the build script that is provided with the source code. The build
script can be retrieved from the following location in SVN:

architecturestudio/script/product_build_script/

To learn how to set up the build script, please refer to “architecture_studio_build_setup_instruction.txt”
file in the location above. The computer that is used to build the product must have Apache Ant
installed.

7.7 Change the properties of a default type or add a new default type
The properties of default types are stored in the
architecturestudio.project.edit/resources/defaultShapes.xml file. We can change their properties,
remove some of them, or add a new default type by editing this file.

Step for changing the properties of a default type:

    1. Open up architecturestudio.project.edit/resources/defaultShapes.xml and look for the element
       type or relationship type tag of the default type you want to change.
    2. Update the value.

Step for adding a new default type:

    1. Create the icon image for the new default type and put it in the
       “architecturestudio.project.edit/resources/visualizations/palette_icons/” directory. This icon
       will be used to show the visualization of the type in the palette.
    2. If it is the element default type, create the SVG file for the new default type and put it in the
       “architecturestudio.project.edit/resources/visualizations/svg/” directory. This svg file will be
       used to draw an element in the diagram.
    3. Open up architecturestudio.project.edit/resources/defaultShapes.xml and add an elementTypes
       tag or relationshipTypes tag in the typeCategories of the perspective of this default type. Look at
       the other tags as a reference for how you have to configure it. Note that the attribute value of
       “icon” key points to the address of the icon you create in step 1. Similarly, the “visualization”
       key is pointed to the address of the svg file you create in step2.

After that you will need to rebuild the application to include new defaultShape.xml file and the image
files, but you don’t need to recompile the application.




Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                Page 16 of 25
Sandcastle Team                                                                              25 April 2013


7.8 Add an option in the context menu for an
    element/relationship/group/view
There are two ways of adding options to the context menu (the right-click menu) for an item in the
drawing area. The rationale for using each is given below, with the description of how to add the option.

7.8.1 Adding menu item through plugin.xml
Steps for adding a menu item:

    1. Create a class in architecturestudio.diagramming.part that implements the
       IObjectActionDelegate interface. Implement the selectionChanged() and run()
       methods.
    2. Open up architecturestudio.diagramming/plugin.xml and add an
       objectContribution tag in the org.eclipse.ui.popupMenus extension point. Look at
       the other objectContribution tags in this extension point as a reference for how you have
       to configure the menu item. Note that the class attribute of the action child of this tag will
       point to the class you created in step 1.

The advantage of this approach (compared with the approach given below) is that you can add a menu
item action to many different diagram items (elements, relationships, groups, and/or views) with very
little code. You can use the objectClass attribute of the objectContribution tag to filter for
which diagram items this context menu option will appear.

Again, you should look at the other objectContribution tags in plugin.xml to get an exact idea of
how to add your new context menu item. You should try and use this approach for adding context menu
items as this involves the least code.

7.8.2 Adding menu item through the ASDiagramEditorContextMenuProvider
This approach involves a lot more classes and code than the first approach. The one advantage this
approach gives is the ability to change the state and text of the context menu item based on any
dynamic event. This approach is used to add the ‘Decompose’ option to elements and relationships,
because once an element/relationship has been decomposed, this menu is changed to the ‘Open child
View’ option. It is the same class, only the name and behavior of the menu item is changed.

Steps for adding a menu item:

    1. Create a request in the architecturestudio.diagramming.requests package which sub-
       classes AbstractEditCommandRequest. This will have the model object(s) that will be
       manipulated by the action.

    2. Create an action in the architecturestudio.diagramming.actions package which sub-
       classes DiagramAction. Use the request you created in this class.

    3. Create a command in the architecturestudio.diagramming.edit.commands package
       which sub-classes AbstractTransactionalCommand. It will need a constructor that takes



Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                              Page 17 of 25
Sandcastle Team                                                                                 25 April 2013


        the request you created as a parameter, so that it can get the model object(s) from the request
        and perform the action required in its doExecuteWithResult method.

    4. Add a check for your new request in the
       ASArchitectureStudioBaseItemSemanticEditPolicy class in its
       getSemanticCommandSwitch method. Also create a corresponding method that gets the
       request as a parameter and returns a command. This method will return null in this class, and
       will be sub-classed by other edit policies (see points below).

    5. Override the method you created in the previous step in either
       ASElementItemSemanticEditPolicy or ASRelationshipItemSemanticEditPolicy
       (or both). This will determine if the action appears enabled in the context menu for elements
       and relationships respectively. The overriding method should return a new Command object
       (that you created in step 3) wrapped in a GEFWrapper.

    6. Finally add the action in the ASDiagramEditorContextMenuProvider class so that it
       appears in the context menu.

7.9 Listen for changes in the instance model
You can have your class listen for events signaling when the instance model changes (e.g. when new
view is added, a rationale of a view is updated). The application uses "EMF Model Transaction" to
manage the transaction and update the data model. The EMF framework provides a way to listen to the
changes in the data model. It is helpful for the UI in that the UI can update its interface when it gets the
notification of the changes. The steps to listen for changes in the instance model are as follows:

    1. Have your class implement the ResourceSetListener interface. You will have to implement all
       the methods defined in the interface.

    2. Since we are interested only the event after the instance model changes, the following methods
       will be implemented to return specific result to ignore other events:
             transactionAboutToCommit() method returns null.
             isAggregatePrecommitListener() method returns false.
             isPostcommitOnly() method return true.
             isPrecommitOnly() method return false.

    3. You will need to implement these two methods based on your needs:
           getFilter() method to return the filter that include only the changes of the objects that
               you are interested. For example, if the UI wants to listen to the changes of the “use
               case” instance model, its filter has to include USE_CASE_CONTAINER (this will tell the UI
               when the use case is added or deleted) and USE_CASE (this will tell the UI when any use
               cases are updated, such as when the title of a use case is updated). Note that the filter
               object should be created only once in the constructor and return this same object every
               time this method is called.


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                 Page 18 of 25
Sandcastle Team                                                                                   25 April 2013


                 resourceSetChanged() method. This method is called when the instance model that you
                  are interested gets changed. You can add your code here to update the UI based on the
                  changed occurred.

    4. In the constructor of your class, register it as a resource set listener by writing this line:
       ProjectDataManager.asGetInstance().asAddResourceSetListener(this);

7.10 Listen for when a project is loaded and unloaded
You can have your class listen for events signaling when a project is loaded (when you create a new
project or open an existing project), renamed (the ‘Save As’ option), and unloaded (the currently open
project is closed) in the application. The steps to do that are as follows:

    1. Have your class implement the IProjectLoadListener interface. You will have to
       implement the asNotifyProjectLoad(), asNotifyProjectRename(), and
       asNotifyProjectUnload() methods.
    2. In the constructor of your class, register it as a project load listener by writing this line:
       ProjectDataManager.asGetInstance().asAddProjectLoadListener(this);
    3. Add your code that handles the event in any of the two functions mentioned in step 1, based on
       your needs.

7.11 Manipulate the instance model
The application manipulates the instance model by using the EMF transaction so it is important that any
changes to the instance model must be done through the EMF transaction framework.

There are two ways to manipulate the instance model in the application:

       Use of the data managers, such as the ProjectDataManager or the MappingDataManager.
       Use of the EMF transaction framework directly (the same way that the data managers do).

If you want to manage the instance model directly by using EMF transaction framework, not through the
data managers, you should look at the code of data managers as a reference for how you have to
update the instance model. You will see that updating the instance model will be done through the
transactional command stack that can be retrieved from the transactional editing domain. You must
avoid updating the instance model directly by using set methods of the objects because it could make
the data model get into an inconsistent state.

There should be only one instance of the TransactionalEditingDomain in the application, and you can
get it by:

       If you have any data object, you can call the method
        “AdapterFactoryEditingDomain.getEditingDomainFor(object)”; it will return the
        TransactionalEditingDomain object using by the application.
       If you don’t have any data object, you can get it from the registry:




Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                   Page 19 of 25
Sandcastle Team                                                                              25 April 2013


        editingDomain = TransactionalEditingDomain.Registry.INSTANCE
                .getEditingDomain(“architecturestudio.EditingDomain”);
        Note that “architecturestudio.EditingDomain” is the key we defined for the editing domain.

7.12 Modify the domain model
To facilitate creating and changing the domain model, we used the Ecore tool called Ecore Diagram.
With the tool, we can create the domain model by drawing the diagram like a class diagram. The .ecore
file is automatically generated from the diagram. After we got the .ecore file, we generate the
.genmodel file and the code. The steps to modify the domain model are as follows:

    1. Open up “architecturestudio.project/model/ArchitectureStudio.ecorediag”. You will see the
       class diagram representing the domain model of the application.
    2. Modify the diagram and save the file.
    3. Open up “/architecturestudio.project/model/ArchitectureStudio.ecore”. Check if it is generated
       correctly (be careful at this step, sometimes the tool doesn’t correctly update the generated file)
    4. Right click at “/architecturestudio.project/model/ArchitectureStudio.genmodel” file and select
       “Reload…” option. Select the ArchitectureStudio.ecore file, follow the steps and click finish.
    5. Open up “/architecturestudio.project/model/ArchitectureStudio.genmodel”. Right click at the
       “Model” node. Select “Generate Model Code” and “Generate Edit Code”.
    6. Check if the code is regenerated and the code reflects the updated data model.

Note that the following methods of the following classes will not be regenerated:

       ArchitecturalDriverItemProvider.class: getPropertyDescriptors(Object object)
       UseCaseEntityItemProvider.class: getText()
       UseCaseItemProvider.class: getText()
       ViewItemProvider.class: getText()

If the updated data model affects these methods, you will need to update them yourself.

7.13 Modify the validation properties of the domain model
We used both the EMF validation framework
(http://help.eclipse.org/ganymede/index.jsp?topic=/org.eclipse.emf.validation.doc/references/overvie
w/ValidationOverview.html) and EMF transaction framework
(http://help.eclipse.org/ganymede/index.jsp?topic=/org.eclipse.emf.transaction.doc/references/overvie
w/transactionOverview.html) to control the integrity of the domain model.

All the changes to the domain model must be performed as EMF transactions (see section 7.11 for more
details). The framework provides a way for us to insert our code to run before the transaction is
committed. We used this framework to make the automatic changes to maintain the integrity of the
domain model based on the changes that are generated by the users. Please see java doc of the
architecturestudio.project.manager.transactionlisteners package for more
information. In the case you want to add a new transaction listener to the domain model, you can
consult classes in this package for reference.


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                               Page 20 of 25
Sandcastle Team                                                                                 25 April 2013


Before the transaction is about to commit (also after the transaction listener has already done its task),
the EMF validation framework will play its role to do the live validation. The live validation validates the
state of the domain model to make sure that it is still consistent; if not, the transaction will be rolled
back and all the changes will be undone.

The EMF validation framework supports both Java and OCL language. Actually it also supports other
languages but we need to write our own parsers, so we used just these two languages. After the
validation is done, we used the validation listener (the ValidationListener class) to show the error
messages to the users. Please see java doc of the architecturestudio.project.manager.validations
package for more information. Table 1 shows the validation rules and the languages used to implement
each rule.

Steps to modify the validation properties of the domain model:

    1. Open up architecturestudio.project.edit/plugin.xml and look for the
       org.eclipse.emf.validation.constraintProviders extension point. Constraint is defined under the
       <constraintProvider> tag; each constraint is defined in the <constraint> tag.
    2. You can modify a rule by updating the value of constraint tag:
            In the case of OCL language, the “lang” attribute of the “constraint” tag is “OCL”. You do
                not need to implement additional java class. If you want to modify the constraint, you
                can directly update the OCL constraint defined in this tag.
            In the case of Java language, the “lang” attribute of the “constraint” tag is “Java”. Each
                constraint has the java class implemented to check that constraint. If you want to
                modify the rule, look for the class for that constraint. The signature of the class is
                defined in the “class” attribute of the “constraint” tag.
    3. You can add new rule or constraint by adding new constraint tag. Look at the other constraint
       tags as a reference for how you have to configure it.
            In the case of Java language, you will need to implement the java class first. The class
                should be located under the architecturestudio.project.manager.validations package.
                Look at the other classes as a reference for how you can implement it.
            In the case of OCL, you can just define the OCL constraint.

        Make use that you configure the target tag correctly. This information is very important for the
        validation framework to know when this constraint will be called. For example, if you specify the
        target to be “ViewItem” and the event to be “Set”, every time any view item is modified, this
        constraint will be called before the transaction can be committed.

    4. You can delete a rule, by just deleting the whole “constraint” tag of that rule. Note that you
       should also delete the related java class in the case that constraint uses the Java language.
    5. We created unit tests for testing the validation rules. You can update the unit test to test the
       modification of the rules. The unit test class is here: architecturestudio.test/
       architecturestudio.test.project.TestValidationRules.




Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                  Page 21 of 25
Sandcastle Team                                                                                        25 April 2013


Table 1 Domain model rules

Components                   Rules                                                                         Use
Architecture driver          No duplicate ID across all architecture driver types but allow empty          OCL
                             ID.
                             When deleted, check if it is assigned to anything. If it is, pop-up the       Java
                             confirmation dialog box. If the user confirms, this AD including all
                             the assignments of this AD are deleted.

View                         No duplicate view name in the same project                                    OCL,
                                                                                                           Java
                             When deleted, ask users to confirm if there are related child views,          Java
                                  View is deleted (all view items in this view will also be
                                     deleted).
                                  All mappings to/from this view are deleted.
                                  All mappings to/from any elements/relationships/groups of
                                     this view are deleted.
                                  All assignments to any elements/relationships/groups of
                                     this view are deleted.
                                  All assignments to any mappings that are deleted from
                                     above rules are deleted.
                             Note: The child views will not be deleted.
Element/Relationship         No duplicate name in the same view, but allow duplicate empty                 OCL
/Group                       name.
                             When deleted, ask users to confirm if there is the child view,                Java
                                  Element/Relationship/Group is deleted.
                                  All mappings to/from this element/relationship/group are
                                     deleted.
                                  All assignments to this element/relationship/group are
                                     deleted.
                                  All assignments to any mappings that are deleted from
                                     above rules are deleted.
                                  Remove element/relationship/group from its group (this
                                     will be done automatically if we use containment for the
                                     group relationship).
                             Note: The child views will not be deleted.
Relationship                 Source element and target element must be in the same view                    OCL
Element                      No duplicate name in the same perspective (with both custom and               Java
Type/Relationship            default shapes).
Type                         Don’t allow deletion if there are any instances of this type in any           Java
                             views.
Assignment                   No duplicate AD assigned to the same thing.                                   OCL


Mapping                      No mapping with the same target and source.                                   OCL
                             No mapping in the same view.                                                  Java
                             Target and source must not be the same                                        OCL


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                     Page 22 of 25
Sandcastle Team                                                                                   25 April 2013


                           If the type of mapping is hierarchy, the target must be view.              Java
                           (If the source and target is element/relationship/group, the type of
                           mapping must be non-hierarchy)
                           Only one decomposed view is allowed for one                                Java
                           element/relationship.
                           The Hierarchy Mapping for the element/relationship/group is                Java
                           allowed only to the View in the same perspective.



7.14 Regenerate EMF source files
Look at the steps 5, 6 and the follow-up note of section 7.12 (Modify the domain model)

7.15 Regenerate GMF source files
Steps for generating the source code for a GMF application should be clear after you go through the
training plan outlined in section 3 of this document. The model files for the GMF application are located
in the architecturestudio.diagramming/diagram directory.

After you have regenerated code for the GMF application, you should only need to merge changes in the
architecturestudio.diagramming/plugin.xml file and the architecturestudio.diagramming/META-
INF/MANIFEST.MF file. These files point to some high level classes that were written by us that allow us
to enhance the modifiability of the generated code. Because of changes in these files, we don’t need to
make any changes in the generated code, as detailed in the ‘Modify generated GMF code’ section.

7.16 Set up the development environment
The development of Architecture Studio requires some tools that are listed as below:

        Java Development Kit (JDK) later than 1.6
        Eclipse Modeling Tools with additional plug-ins. This version of Eclipse is provided with the
         source code.
        Customized Eclipse workspace. This is also provided with the version of Eclipse.

And, the following steps allow you to start the development for Architecture Studio in Eclipse:

    1.   Install JDK
    2.   Get the version of Eclipse and the workspace and copy them to your computer.
    3.   Get all the eclipse projects related to Architecture Studio using SVN plug-in in Eclipse.
    4.   Build and run Architecture Studio in Eclipse.

If you can run the Architecture Studio in Eclipse, you are ready to modify Architecture Studio.

7.17 Setup the development environment on Linux
The development environment of Architecture Studio has been tested on Ubuntu 9.04 (32bit). Follow
the steps below to set up a development environment and run Architecture Studio on a Linux based
operating system:


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                  Page 23 of 25
Sandcastle Team                                                                                 25 April 2013


      1. Install the latest version of the JVM.
      2. Download SWT for Linux (from http://www.eclipse.org/swt/) and install it (installation
         instructions might vary across versions and Linux distributions).
             a. Unzip the downloaded archive.
             b. Copy swt.jar to %JAVA_HOME%/jre/lib/ext
      3. Download and setup the Eclipse Modeling Tools (includes Incubating components)2 version of
         Eclipse.
      4. Install SVN and check out all projects from the code repository
      5. Import the projects into your Eclipse workspace.
      6. You might see some swt.jar related ‘Access Restrictions’ errors. You can fix them by changing a
         setting in Eclipse
             a. Open Windows > Preferences > Java > Compiler > Errors/Warnings
             b. Open the Deprecated and restricted API section on the dialog
             c. Set the Forbidden reference (access rules) setting to Warning
      7. Next you might see some errors in MANIFEST.MF files of your projects. You need to update
         version numbers of libraries used by the project, as versions of some libraries vary between
         their Windows and Linux distributions. You can find the correct version number by looking for
         the library under the Plug-in Dependencies leaf in the project tree in the Eclipse Package
         Explorer.
      8. Your project should build and run, just like on Windows.

7.18 How to build the trial version of the application
In the architecturestudio.util project, browse to the architecturestudio.util.io
package. Open the ConfigProperties.java file. In the ConfigProperties class, there is an attribute named
TRIAL_VERSION. Set this attribute to true to run the application as the trial version, or set it to false to
run the application as the complete version. To build both versions of the application, the application
should be built after setting the attribute to true, and again after the attribute is set to false. If
TRIAL_VERSION is set to true, the name of the application will be “Architecture Studio (Trial Version)” in
the title bar, and the export document feature will be disabled.



8 Possible future work
-      Tickets in Trac related to improvements and minor bug fixes.
           o See the Sandcastle website (on Dogbert and /site/index.html in the documents SVN
                repository) for a list of remaining tickets.
-      UC22 - Use UML to draw detail design.
-      UC23 - Warn user about unmet design obligations.
-      UC25 - Manage tasks for the project.




2
    http://www.eclipse.org/downloads/packages/release/ganymede/sr1


Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                                 Page 24 of 25
Sandcastle Team                                                                    25 April 2013




References
[Lat08] Lattanze, A. Architecting Software Intensive Systems: A Practitioners Handbook, New
York, NY: Auerbach, 2008




Ahn, Cho, Chotemateepirom, Haider, Zgraggen                                    Page 25 of 25

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:4/25/2013
language:Latin
pages:25
huangyuarong huangyuarong
About