Qualisist is an AI-powered add-in for Enterprise Architect, devloped by Sparxs Systems. It started off as scientific research by the University of Luxembourg’s Interdisciplinary Centre for Security, Reliability and Trust (SnT). It is designed and tested for

1.   defining, modelling, and optimising technical requirements,
2.   requirements authoring support,
3.   reconciliation between requirements models,
4.   automated generation of full deliverable,
5.   acceptance criteria written as Gherkin test scenarios (syntaxacclaimed by the software development community).

The plug-in allows product managers, program managers and business analysts to accurately write software development requirements for developers to follow, minimizing errors and budget overruns.

Qualisist is compatible with version 15 and 16 version of Enterprise Architect. The installation takes 3-5 minutes. After finishing theprocess, by clicking on “Specialize” tab, you will get 4 new

toolboxes:

Qualisist´s competitive advantage is its smart editor, which has the capability to identify errors in the requirement specification. Also, our smart editor can uncover design problems by identifying

in the requirements text any domain entities that are not included in the requirements models.

With the smart editor, Qualisist streamlines the requirement writing process, enabling developers and managers to author requirements 50% faster. This results in quicker and more efficient project initiation, setting the foundation for successful software development.

It uses Rimay, which is a Controlled Natural Language (CNL), that eases the requirements capture with 48 grammar rules to write requirements and practical text editing features such as:

• Syntax highlighting to identify the main parts of the requirements,
• Autocompletion to speed up the writing process and instant feedback about the errors.

To Shape Script, or not to Shape Script?

Almost a year ago, as we embarked on what was to be the first of a series of lockdowns in the UK, I decided to learn some new skills that I could put into practice with Enterprise Architect (EA). I decided that I would like to learn how to create an MDG to assist not only my own modelling activities, but also those of the clients to which Dunstan Thomas provide consultancy services. Besides, with access to one of the best in the business (Phil “Chudders” Chudley) I had no excuse not to drink from an unending well of knowledge.

What is an MDG and what is a Meta Model?

An MDG, or Model Driven Generator Technology, to give it its official title, is the method in which Sparx Systems Enterprise Architect implements a Meta Model.

A Meta Model is the definition of symbols and relationships within a modelling notation. It also defines the rules to which those relationships must adhere.

Getting to it!

I set aside some time with Phil and followed him down the MDG rabbit hole, like my very own White Rabbit.

Over the course of a couple of days, I spent a lot of time with Phil absorbing his words of wisdom. It was then time to get practical as I, like many others, learn best by doing. Therefore, I set out to create what would become my first MDG. I wanted it to be something that would use again rather than it just be a learning aid, so I looked at my role within DT to see where I could make use of a tool not traditionally used to capture information via modelling. This led me looking into risk capture.

In addition to my role as Consultant, I also lend my hand to various other activities about the office (who remembers offices? I ‘member) and one such activity is performing the fire risk assessment for the office. This had me thinking, can I use EA with a custom MDG to model my risk assessments? The answer is of course yes…else, I would not be writing this article.

Unfortunately, COVID-19 threw a spanner in the works as we were very soon under lockdown conditions. This meant that with the office closed, I could not perform a test using the fire assessment documents, but as luck would have it, DT had to perform COVID-19 risk assessments for the office in the event that staff required access. I was able to use this data to test my ability to model a risk assessment.

This led to the creation of my first MDG, RiskResolve. It is a very simple MDG with a set purpose. Define a goal (e.g. use of the office during pandemic conditions), then identify the different activities that are required to achieve that goal and further narrow that down to the individual tasks that would make up such activities. From there, I could then identify the risks associated with any of these items. This formed the top level of my model as the Risk Identification Diagram (RID) and using abstraction, I could then drill-down into the identified risk elements to the next view, the Risk Resolution Diagram (RRD). In this view, our identified risk is comprised of elements called instigators and then we have our resolution elements, which detail how an instigator is addressed to alleviate risk. These are connected via association.

Here are the example patterns I have built into the MDG:

RID Pattern

RRD Pattern

With the MDG working and me able to generate a document from it to form a risk assessment, I was very happy, but soon I got to thinking about using Shape Scripts to enhance the visuals of the model.

What is a Shape Script?

Sparx Systems talk about Shape Scripts as follows:

“As Shape Scripts are associated with stereotypes, you define them through the ‘Stereotypes’ tab of the ‘UML Types’ dialog; each stereotype can have one Shape Script.”

In plain terms, you can define how EA renders your elements by writing a Shape Script for each of them.

Not content with making things easy on myself for a first attempt at writing a Shape Script, I decided that I would like have my Associated Risk elements on the RID diagram rendered as triangles. This would overwrite the default visuals that the element is inheriting for the stereotype on which it is based.

Here is the Shape Script:

The Shape Script draws the shape by way of you plotting out how EA will draw the element within a given rectangular shape:

Here are the results:

As you can see, this is a less than ideal shape for what I need. The element name in this example simply cannot fit within this shape unless I were to attempt to position the name at the bottom of the shape, but even then I would still need space to render other information such as the associated tagged value to tell me who is at risk and display the composite link icon.

I also performed a similar experiment on the RRD, here are the results:

This is what it should look like: 

Whilst you can create a Shape Script that displays the relevant compartments (see below), it is very difficult to create the required subshapes for anything beyond a rectangle.

This is especially true given that we can just use the inherited appearance of the metaclass to which we have assigned our stereotypes. From there we can achieve the same by adding attributes such as ShowNotes=1; and ShowTags=1; our diagram profile to achieve the same:

In my example, I need only to publish particular compartments. However, should I need to display the attributes of an element, I cannot do this with a Shape Script and we are back to using the inherited appearance of the metaclass.

Conclusion

I guess through a combination of my experimentation and the visual examples above we can draw the following conclusions:

1. EA provides us with an extremely useful and powerful functionality allowing us to create our own metamodels
2. These meta models can be further customised through the use of Shape Scripts
3. A Shape Script can be set to react to certain conditions e.g. Tagged Values and Properties (like Rectangle Notation and Composite)
4. Creating these Shape Scripts can be time consuming and there are limitations to what they can do

From all of this I guess my advice would be to use a Shape Script if you are desperate to change the shape of your element stereotype, just beware of the time required to create some of the more wacky shapes and have them display your required data on the model.

Subscriber Questions: How can I show messaging between BPMN processes?

We regularly get asked questions by our YouTube subscribers and recently one we were asked by someone how they could show messaging between independent processes using Enterprise Architect.

In the clip shown below, and after some serious beard stroking, I look at using a high-level collaboration diagram to demonstrate the connectivity between the processes, which was my initial gut reaction. After some additional consideration of the question I also look at an approach using the conversation diagram in conjunction with model elements and lower level choreographies as a way to show this communication at a high-level.

Please click the link below to view the footage:

https://www.youtube.com/embed/tBjj2QeF3M8

Don't forget to subscribe to our channel for more content like this, and of course ask your subscriber questions!

Sparx Systems has just announced the release of Enterprise Architect 15.2, via the latest newsletter.

Geoffrey Sparks, Sparx Systems CEO has remarked of Version 15.2,

"After recently passing the 20th year of Enterprise Architect's public life, it is a great pleasure to ship version 15.2. This major new release firmly demonstrates Sparx System's commitment to continual innovation, development and evolution of the Enterprise Architect tool suite and the Pro Cloud Server platform. We look forward to seeing these new tools and capabilities at work, enhancing the modeling and design pipelines of our user base."

Learn more about Enterprise Architect 15.2 via the Release Page

To subscribe to future newsletters, visit: https://www.sparxsystems.com/support/forms/newsletter.html

 Sparx Systems is proud to mark the 20th anniversary of Enterprise Architect's commercial release in August 2000.

"Sparx Systems has a long and unbroken history of development, commitment to quality, to value and to highly effective modeling and design based on open standards," remarked Geoffrey Sparks of the milestone. "In an industry that has seen many tools and methodologies come and go, Sparx Enterprise Architect has been firm and resolute in its goals and aspirations and its continuous development of innovative and effective features, capabilities, and tooling. From Day 1, Enterprise Architect was designed to serve the needs of a broad spectrum of modelers, designers, managers, maintainers, and other stakeholders across a truly diverse range of industries. Its success over these last 20 years, in over 160 countries is proof of its value, power, and effectiveness."

Thank you to all our customers and business partners for their support and enthusiasm.

unsplash-logoMr Cup / Fabien Barral

Have you ever wanted to generate code from your Enterprise Architect UML or SysML models? Have you tried to customize Enterprise Architect’s code template framework? Do not give up the dream of project-specific code generators and read how easily they can be implemented.

The Need for a Code Generator

A good software or system architecture is on a higher abstraction level compared to the implementation. It should be a consistent model that documents decisions and neglects unnecessary, often technical, details. Consider, for instance, the class diagram in Figure 1. It shows a domain model that defines the data structure needed for a shop to allow customers to order articles. The properties of each class are modeled in detail, but other unnecessary aspects like operations to access properties are left out.

If the software architecture/design is made upfront before starting with the implementation, a lot of cumbersome and error-prone work can be avoided by code generation. Commercial out-of-the-box code generators often do not change the degree of abstraction. That’s why they often do not match the needs of the project.

The code template framework of Enterprise Architect can be tailored according to the project-specific needs. But this requires some initial training. And often the expected outcome is hard to achieve as described in Eclipse-based Code Generation for Enterprise Architect Models.

A Simple Project-specific Code Generator

I prefer a general-purpose programming language such as Java or Xtend to implement code generators. In particular Xtend is well suited to implement templates because of its template expressions. They allow one to embed executable code inside the text to be generated. It feels like programming PHP, JSP, or JSX. The code in Listing 1 shows a code generation template written in Xtend. It generates Java classes for the classes declared in the class diagram of Figure 1.

package com.yakindu.ea.examples.orderingsoftware.template

import com.yakindu.bridges.ea.examples.runtime.codegen.EACodegen
import org.eclipse.uml2.uml.Class
import org.eclipse.uml2.uml.NamedElement

class ClassTemplate {
   @EACodegen("Java")
   def String generate(Class element) '''
      package «element.package.javaQualifiedName»;
      
      «val superType = element.generals.findFirst[true]?.name»
      «val extends = '''«IF !superType.isNullOrEmpty» extends «superType»«ENDIF»'''»
      public«IF element.isAbstract» abstract«ENDIF» class «element.name»«extends» {
         
         «FOR attribute : element.ownedAttributes SEPARATOR System.lineSeparator»
            «val type = attribute.type?.javaQualifiedName»
            «IF 1 != attribute.upper»
               «val defaultValue = '''new java.util.LinkedList<«type»>()'''»
               private final java.util.List<«type»> «attribute.name» = «defaultValue»;
            «ELSE»
               private «type» «attribute.name»; 
            «ENDIF»
         «ENDFOR»
         
         «FOR attribute : element.ownedAttributes SEPARATOR System.lineSeparator»
            «val type = attribute.type?.javaQualifiedName»
            «IF 1 != attribute.upper»
               public List<«type»> get«attribute.name.toFirstUpper»() {
                  return «attribute.name»;
               }
            «ELSE»
               public «type» get«attribute.name.toFirstUpper»() {
                  return «attribute.name»;
               }
            «ENDIF»
            «IF 1 == attribute.upper»
               
               «val params = '''«type» «attribute.name»'''»
               public void set«attribute.name.toFirstUpper»(«params») {
                  this.«attribute.name» = «attribute.name»;
               }
            «ENDIF»
         «ENDFOR»
      }
   '''
   
   protected def String getJavaQualifiedName(NamedElement element) {
      element.qualifiedName.replace("::", ".")
   } 
}

The generated Java code shown in Listings 2, 3 and 4 does not look like handwritten, because qualified names are used instead of imports. This will be improved later in Figure 4 by methods collectImports and printImports.

package com.example.orderingsoftware;

public abstract class AbstractIDObject {

   private java.util.UUID id; 

   public java.util.UUID getId() {
      return id;
   }
   
   public void setId(java.util.UUID id) {
      this.id = id;
   }
}

package com.example.orderingsoftware;

public class OrderItem extends AbstractIDObject {

   private java.math.BigInteger amount; 
   
   private com.example.orderingsoftware.Article article; 

   public java.math.BigInteger getAmount() {
      return amount;
   }
   
   public void setAmount(java.math.BigInteger amount) {
      this.amount = amount;
   }
   
   public com.example.orderingsoftware.Article getArticle() {
      return article;
   }
   
   public void setArticle(com.example.orderingsoftware.Article article) {
      this.article = article;
   }
}

package com.example.orderingsoftware;

public class Order extends AbstractIDObject {

   private java.util.Date date; 
   
   private com.example.orderingsoftware.Customer customer; 
   
   private final java.util.List<OrderItem> items = new java.util.LinkedList<OrderItem>(); 

   public java.util.Date getDate() {
      return date;
   }
   
   public void setDate(java.util.Date date) {
      this.date = date;
   }
   
   public com.example.orderingsoftware.Customer getCustomer() {
      return customer;
   }
   
   public void setCustomer(com.example.orderingsoftware.Customer customer) {
      this.customer = customer;
   }
   
   public java.util.List<com.example.orderingsoftware.OrderItem> getItems() {
      return items;
   }
}

If you look carefully at the template in Listing 1, you will realize that it does not know anything about Enterprise Architect. Instead, it handles instances of the UML metamodel which is available in Eclipse thanks to the Eclipse UML 2 project. The missing connection between Enterprise Architect and UML is the YAKINDU EA-Bridge. It is an API that offers UML-compliant read and write access to Enterprise Architect UML and SysML models. The database behind an Enterprise Architect project is automatically transformed into instances of the UML metamodel. This has three major advantages for you as a developer: 

• Your code is compatible with other tools that are based on the UML 2 project such as Papyrus.
• Highly performant read and write access to Enterprise Architect models without the need to reverse engineer the database schema of Enterprise Architect.
• You do not have to learn anything about the API of the YAKINDU EA-Bridge. It is completely hidden for you as a developer, because the YAKINDU EA-Bridge integrates itself into the ecosystem of the Eclipse Modeling Framework (EMF).

The YAKINDU EA-Bridge comes with an optional Eclipse IDE integration which allows one to implement project-specific code generators. Those code generators are often prototypically developed and are executed only within a certain context. Thus, it is crucial that the development effort is less compared to  manual coding. To implement a project-specific code generator, all you have to do is to place the EAP file in an Eclipse project and to annotate methods in the code generation template with @EACodegen. Annotated methods should accept the UML element for which code should be generated as the only parameter and return the generated text. If your Enterprise Architect model is hosted by a remote database such as Microsoft SQL Server, you can use a shortcut file instead of an EAP file.

When the project is built, e.g. automatically or manually via the main menu item ‘Project, Clean…‘, the template is launched for all UML classes declared in all EAP files. Of course, only EAP files stored in the template’s project are considered. The generated code is saved in a file specified by the qualified name of the class. The file extension is specified by the argument of the @EACodegen annotation. The structure of the Eclipse project can be seen in Figure 2.

Please observe that the YAKINDU EA-Bridge is an API. It allows you to process the Enterprise Architect model in any way. Indeed, the original use case were comprehensive code generators such as an Autosar RTE generator based on UML architectures. 

Generating More than one Artefact per Model Element

Let’s make the example more exciting by implementing a product line with two different persistence approaches: One that uses JPA to store data in a relational database and one that uses HBase as a big data store.

I suggest implementing a persistence manager which can be used to load and save instances. Only the product based on JPA should allow one to start and complete transactions. Furthermore, I would like to place JPA specific annotations in the Java classes. Figure 3 shows the methods offered by the persistence manager.

The consequence is now, that the implementation of all six classes is slightly different in both products. The Java code in Listings 5, 6, 7 and 8 shows an excerpt of the code to be implemented.

package com.example.orderingsoftware;

public class Article extends AbstractIDObject {

   private String name; 

   public String getName() {
      return name;
   }
   
   public void setName(String name) {
      this.name = name;
   }
}

package com.example.orderingsoftware;

import javax.persistence.Entity;
import javax.persistence.Table;

@Entity
@Table(name = "ArticleTable")
public class Article extends AbstractIDObject {

   private String name; 

   public String getName() {
      return name;
   }
   
   public void setName(String name) {
      this.name = name;
   }
}

public class PersistenceManager implements AutoCloseable {

   private final Table articleTable;

   public static final byte[] MODEL_FAMILY = "Model".getBytes();

   public static final TableName ARTICLE_TABLE_NAME = TableName.valueOf("ArticleTable");

   public Article getArticle(UUID id) {
      try {
         if (id != null) {
            Get get = new Get(id.toString().getBytes());
            if (articleTable.exists(get)) {
               Result r = articleTable.get(get);
               Article result = new Article();
               result.setId(id);
               result.setName(Bytes.toString(r.getValue(MODEL_FAMILY, ARTICLE_NAME_QUALIFIER)));
               return result;
            }
         }
         return null;
      } catch (Exception e) {
         throw new RuntimeException(e.getMessage(), e);
      }
   }

   // ...
}

public class PersistenceManager implements AutoCloseable {

   private EntityManager entityManager; 

   public Article getArticle(UUID id) {
      if (id != null) {
         return entityManager.find(Article.class, id);
      } else {
         return null;
      }
   }

   // ...
}

Feasible solutions to realize the product line are: 

• To use inheritance. That would require an interface definition with the public API for each class and to implement it for JPA and for HBase. The consequence would be that the rest of the application must be adjusted to operate only on the interfaces and never on the concrete classes. 
• To copy, paste, and modify the implementation for both products would avoid the need to modify the rest of the application. Maintaining two variants might sound reasonable. But is this still the case with an increasing amount of variants? You should think carefully about the pros and cons of copy and paste.
• To use a code generator which generates the product specific code. The classes realizing code generation templates could be based on a common implementation and each subclass could adjust the product-specific parts. 

I prefer the last solution. The outline in Figure 4 shows the refactored class template of Listing 1. Each introduced method generates a specific member of a Java class. This allows me to override these methods in the product-specific templates. In Listing 9 for instance can be seen, that JPA specific annotations are placed before the class definition.

class JPAClassTemplate extends ClassTemplate {
   @EACodegenFile
   def IFile path(Class element, IFile ^default) {
      val path = "com/example/orderingsoftware/" + ^default.name
      return getTargetFilePath("jpa", path)
   }
   
   @EACodegen("java")
   override generate(Class element) {
      return super.generate(element)
   }
   
   override printClassDeclaration(Class element) '''
      «IF element.isAbstract»
         @MappedSuperclass
      «ELSE»
         @Entity
         @Table(name = "«element.name»Table")
      «ENDIF»
      «super.printClassDeclaration(element)»'''

   // ...
}

The method path(Class, IFile) in the template subclasses annotated with @EACodegenFile is used to define the target location at which the generated code should be saved. It has two parameters. The first one is the UML element for which code should be generated. The second is the default location where the generated code should be stored. The return value of the annotated method is the adjusted location at which the generated code should be stored.

The screenshot in Figure 5 shows all templates. The arrows point to the files that are generated by each of them. In addition to the production code, also the test code is generated.

Conclusion

Modern general-purpose programming languages such as Xtend are well suited to implement complex code generators. The input could be a UML model, possibly modeled in Enterprise Architect. The YAKINDU EA-Bridge transforms the relational database behind an Enterprise Architect model on the fly, and completely hidden, into instances of the UML metamodel. There is no need to learn the proprietary code generation language provided by Enterprise Architect or to reverse engineer the database schema of Enterprise Architect. 

The Eclipse IDE integration of the YAKINDU EA-Bridge allows one to implement project-specific code generators at low costs in a short time. In this way, you can save a lot of cumbersome, error-prone, and mindless implementation work.

If you want to see and run the full example for yourself, try out the YAKINDU EA-Bridge. The presented example is one of the examples shipped with the YAKINDU EA-Bridge.

Sparx Systems is pleased to announce a new Sparx Systems University Week scheduled June 3^rd-7^th.

During Sparx Systems University week, a range of both free and paid training sessions are hosted at training locations around the world and online.  All sessions are supported by Sparx Service providers and qualified trainers in a number of different languages.

This week-long event is a unique opportunity to gain knowledge and improve skills around Enterprise Architect. June's course line-up covers a broad range of topics, and has been developed with both introductory and advanced users in mind.

Creating Navigable Models for HTML Publication

By Phil Chudley, Prinicipal Consultant at Dunstan Thomas Consulting

Background

Once a model has been developed in Enterprise Architect, it can be shared to users who do not have Enterprise Architect by publishing the model to HTML where the model can be viewed in a browser.

However, out of the box, this common method of publication to HTML suffers from the following problems:

1. Unless the model is organised very logically, the non-Enterprise Architect user can struggle to find their way around the model.
2. The presence of the Project Browser tree in the Web Page(s), can be confusing to the non-Enterprise Architect user where too much information is provided.

In reality, the non-Enterprise Architect user is most interested in the diagrams, and ideally would wish to navigate the model using these diagrams.

Navigation techniques are already built-in to Enterprise Architect, namely:

• Composite Elements.
• Hyperlinks.
• Navigation Cells.

If a model is built so that it can be navigated purely via diagrams using the techniques above, then the presence of the project browser tree in the HTML publication is rather irrelevant. The question is how can this project browser tree be removed from the web pages? The answer can be found in this article.

Creating a Model that can be Navigable via Diagrams

This section uses built-in features of Enterprise Architect. For an example, let us consider the following model that has been built already in Enterprise Architect:

This model is a “typical” UML model supplemented with Requirements, User Interface Screens and a Dashboard. As its stands it is quite difficult to navigate for the non-Enterprise Architect user, therefore we add to the model the following:

• Table of Contents diagrams that contain Navigation Cells to other diagrams.

A navigation cell is created very easily by:

1. Creating a diagram (I use the EA Extended Custom diagram type) in a Package.
2. Navigate to a diagram.
3. Drag and drop this diagram to the diagram created in step 1) and choose Navigation Cell from the list of options.
4. Choose an appropriate image.

For the model illustrated above, we begin by:

1. Adding a View named TOC (or Table of Contents) to the model root.
2. Move this to be the first view in the model.
3. Add to this View a diagram (for example an EA Extended Custom diagram type).

This is illustrated below:

The next step is to add navigation cells to this newly created diagram and there are two basic approaches:

1. Add a navigation cell for each diagram within the model to the diagram named TOC.
2. Create “TOC” diagrams for each view / package and created navigation cells for these lower level TOC diagrams.

Which option you use depends upon the complexity of the model, in this example I used option 2) which resulted in the TOC diagram being populated with navigation cells as shown below:

As an example of a lower level TOC diagram, consider the package named User Interface which is shown expanded below:

Each of the packages inside User Interface has a User Interface diagram. Generally I place one diagram in one package.

Creating navigation cells for these diagrams yields the TOC diagram for the User Interface package as shown below:

This process is repeated for other Views and Packages.

We now have a model that is navigable entirely via diagrams commencing with the top level TOC diagram.

In this example I created a “back link” to the level above, using a hyperlink and setting the Behavior property Printable to be false.

The final step is to ensure that when the model opens, the TOC diagram is displayed by default. This is achieved by:

1. Opening the TOC diagram.
2. Select the Layout Ribbon.
3. Select Manage → Set as Model Default.

Publishing to HTML

The result of selecting the Model Root node and using the Publish to HTML function, out of the box is as shown below:

The modifications we are going to make are as follows:

1. Change the header image.
2. Remove the Project and Advanced information from the bottom of the diagram.
3. Remove the Project Browser Navigation tree.

Making the Modifications

Changing the Header Image

This is very easy to do, as there is an option on the HTML generation dialog to navigate to and select an alternate image. However, there is a “gottcha”. So that the chosen image will fit in the frame at the top of the HTML page, it must be less than or equal to 60px in height.

In this section, I will show you how to customize the HTML output so that the frame resizes to fit the height of your image.

The following steps are used:

1. Discover the height of your image (this can be achieved with Windows File Explorer by positioning the mouse on the image file and examining the tool tip that displays). The image that I am going to use has a height of 56px.
2. Using the Resources View, open the section named Web Style Templates, right-click and select Create New HTML Template.
3. Enter a suitable name and click OK.
4. In the dialog that displays the list of Templates, select the template named CSS – Main.
5. Scroll down to line 248 as shown below:
   
6. Change line 252 to be the height of your image + 1, in my example this is 57.
7. Similarly, change line 259 to be the height of your image, in my example this is 56:
   
8. Click Save.

Remove the Project and Advanced information from the bottom of the diagram

The following steps are used, assuming that the dialog showing the HTML Templates is still visible, if not, right click your Web Style Template in the resources and select Modify HTML Template:

1. Select the Template named Body – Diagram:
   
2. Delete lines 13 through 32 inclusive:
   
3. Click Save.

Remove the Project Browser Navigation tree

Saving the best for last, our final modification is to remove the Project Browser Tree. To achieve this the Javascript Template needs modification as follows:

1. Select the Template named Javascript:
   
2. Scroll down to line 520 which should be the function named resizePage().
3. Scroll down to line 549 and replace this line with the following lines of Javascript:
   
4. Scroll back to line 85 which should be the function named initLoad(src, toc, home).
5. Insert the following line of Javascript between lines 128 and 129:
   
6. As a check the modification above should be as shown below:
   
7. Click Save and then Click Close.

The Result

To view the effect of the changes, re-publish the model to HTML this time selecting your Web Style Template and navigating to your Image:

The result as shown in the Browser is as shown below:

Conclusion

The next step would be to modify the HTML templates such that when the user clicks an element which does not link to a diagram, nothing happens rather than the default behavior of displaying an element properties screen. Alternatively, the element properties screen could be modified to display just name and notes for example. Once I have worked out how to do this, I will share this in another tutorial.

Phil Chudley
Principal Consultant
Dunstan Thomas Consulting
Follow me on Twitter @SparxEAGuru

Digital transformation, new business models and the rapid pace of change have had a profound impact on the modern enterprise. Agile approaches can lead to faster feedback cycles, improved stakeholder engagement, reduced waste, improved transparency, predictable delivery and better business outcomes.

The Sparx Systems tool suite supports enterprise agility through better collaboration, strategic management, capability modeling, Kanban diagrams, user stories, integrated communication tools, project management features, traceability and much more.

Presented by Chris Armstrong and Scott Hebbard.

Register Today at:

https://www.sparxsystems.com/resources/webinar/partners/agile/enterprise/index.html

There are a great number of opportunities to meet Sparx Services in Europe: