Merge lp:~yrke/tapaal/cleanup-PNO-namingAndInterface into lp:tapaal

[Kenneth Yrke Jørgensen]

[Kenneth Yrke Jørgensen (yrke)]

This branch fixes stuff related to drawing and animation; we should test nothing unexpected is broken.

Bugfixes:

  - Clearify text in manual select token menu #1883974
  - Fixed undo/redo of objects moved at differnt zoom than current
  - Fixed adding arcpah point (menu or double click) at zoom differnt than 100
  - Fixed an issue archpath endpoint could be moved.

Changes:

Animation:
  - Updated now enabled transitions are calculated, now have one function that calculates and update components.
  - Enabledness i no longer saved in TranstionComponents (dispatches to model)
  - Moved code needed to setup animation from TabContent to the animation controller
  - Renamed animation components to clarify behavior
  -

Drawing:
  - Moved drawing of place/transitions arcs and notes to new controller (CanvasController)
  - Updated calulation of arc angles (between objecs) from using tan to use atan2, this also fixes an exception thrown when two objecs are very close.
  - Made a number of members final
  - Pushed members in Local/Shared Time Places up (to share code)
  - Added a new function a add X tokens to a place (insted of having to create a new token and add them in a loop)
  - Added tests for loading tokens
  - Added new type GraphicalElement that is added to Canvas, for now PetriNetObject exstendes GraphicalElmenet, but then can later be split
  - setNetwork in a tab is now removed an a network set via constructor
  - labels Offset is not saved in unzoom coords
  - arcpath poins are not created uning unzoomed coords

[lp:~yrke/tapaal/cleanup-PNO-namingAndInterface]

1206. By Kenneth Yrke Jørgensen on 2020-07-06

Merged changes from other computer

1207. By Kenneth Yrke Jørgensen on 2020-07-06

Removed color

1208. By Kenneth Yrke Jørgensen on 2020-07-06

Corrected spelling

[Peter Haahr Taankvist (ptaank)]

Open alternating-bit-protocol-components. Zoom in full -> Press Ctrl+U 3 times -> zoom out to 100%. Now the Annotation Note is placed weirdly. Additionally, press ctrl+z 3 times, and it is still placed weirdly, until we zoom again.

[Peter Haahr Taankvist (ptaank)]

The problem with pressing shift+U many times still persists:

Open alternating-bit-protocol-components

press shift+U 23 times

now press ctrl+U some times

The spacing will not increase, rather the places will all stay on top of each other and arcpathpoints will fly everywhere.

[Peter Haahr Taankvist (ptaank)]

> The problem with pressing shift+U many times still persists:
>
> Open alternating-bit-protocol-components
>
> press shift+U 23 times
>
> now press ctrl+U some times
>
> The spacing will not increase, rather the places will all stay on top of each
> other and arcpathpoints will fly everywhere.

What's worse is that the same happens with ctrl+z

[Peter Haahr Taankvist (ptaank)]

It is not possible to undo resizing of annotation notes

[Lena Ernstsen (lsaid)]

1)
When I select ‘place’ and want to add it to the the component I sometimes have to click several times before it registers and adds the ‘place’. Same goes for transitions, tokens, and the different arcs.

2)
The positions of the different arcs are shown as ‘X:0 Y:0’. But I'm not sure if this is relevant or not.

3)
There is a weird behaviour when moving an arc with extra inserted points. When moving such and arc a little to the right, then it moves very fast by itself to the far right and goes off screen. When undoing, the arc does not return to how it was setup before moving it, but rather it stays to the far right and removes the extra points.
The same thing happens if you move the end point of an arc with an extra point a little down.

review: Needs Fixing

[Peter Haahr Taankvist (ptaank)]

> 1)
> When I select ‘place’ and want to add it to the the component I sometimes have
> to click several times before it registers and adds the ‘place’. Same goes for
> transitions, tokens, and the different arcs.
>
> 2)
> The positions of the different arcs are shown as ‘X:0 Y:0’. But I'm not sure
> if this is relevant or not.
>
> 3)
> There is a weird behaviour when moving an arc with extra inserted points. When
> moving such and arc a little to the right, then it moves very fast by itself
> to the far right and goes off screen. When undoing, the arc does not return to
> how it was setup before moving it, but rather it stays to the far right and
> removes the extra points.
> The same thing happens if you move the end point of an arc with an extra point
> a little down.

How to reproduce #3
Place a place and a transition and draw an arc between them. Now drag at one of the endpoints and the arcs will fly all over.

[Peter Haahr Taankvist (ptaank)]

> 1)
> When I select ‘place’ and want to add it to the the component I sometimes have
> to click several times before it registers and adds the ‘place’. Same goes for
> transitions, tokens, and the different arcs.
>
> 2)
> The positions of the different arcs are shown as ‘X:0 Y:0’. But I'm not sure
> if this is relevant or not.
>
> 3)
> There is a weird behaviour when moving an arc with extra inserted points. When
> moving such and arc a little to the right, then it moves very fast by itself
> to the far right and goes off screen. When undoing, the arc does not return to
> how it was setup before moving it, but rather it stays to the far right and
> removes the extra points.
> The same thing happens if you move the end point of an arc with an extra point
> a little down.

4)
#1 To add to this it also seems that it has a hard time registering a click on an enabled transition in animation mode.

[Peter Haahr Taankvist (ptaank)]

5)

Adding text to an annotation note and then undoing does not undo the size of the annotation note.

[lp:~yrke/tapaal/cleanup-PNO-namingAndInterface]

1209. By Kenneth Yrke Jørgensen on 2020-07-09

Changed mouse clicked events to mouse down

1210. By Kenneth Yrke Jørgensen on 2020-07-09

Disabled dragging arcs

Current implementation does not support this

1211. By Kenneth Yrke Jørgensen on 2020-07-09

Moved adding of arcpath point with doubleclick to new controller

[Kenneth Yrke Jørgensen (yrke)]

Changed draw from click to mouse down, addresses #1,4. #2 is as expected, #3 is also in trunk but added a fix so you can't draw on an arc.

review: Needs Resubmitting

[Lena Ernstsen (lsaid)]

review: Approve

[Peter Haahr Taankvist (ptaank)]

review: Approve

[Jiri Srba (srba)]

review: Approve

=== modified file 'src/dk/aau/cs/gui/SharedPlacesAndTransitionsPanel.java'
--- src/dk/aau/cs/gui/SharedPlacesAndTransitionsPanel.java	2020-05-27 13:15:44 +0000
+++ src/dk/aau/cs/gui/SharedPlacesAndTransitionsPanel.java	2020-07-09 12:55:48 +0000
@@ -45,17 +45,17 @@
 	private static final String TRANSITIONS = "Transitions";
 	private static final String PLACES = "Places";
 
-	private JList list;
-	private SharedPlacesListModel sharedPlacesListModel;
-	private SharedTransitionsListModel sharedTransitionsListModel;
-	private JComboBox placesTransitionsComboBox;
-	private UndoManager undoManager;
-	private NameGenerator nameGenerator;
-	private TabContent tab;
+	private final JList list = new NonsearchableJList();
+	private final SharedPlacesListModel sharedPlacesListModel;
+	private final SharedTransitionsListModel sharedTransitionsListModel;
+	private final JComboBox placesTransitionsComboBox = new JComboBox(new String[]{ PLACES, TRANSITIONS });
+	private final UndoManager undoManager;
+	private final NameGenerator nameGenerator;
+	private final TabContent tab;
 
-	private JButton renameButton = new JButton("Rename");
-	private JButton removeButton  = new JButton("Remove");
-	private JButton addButton = new JButton("New");
+	private final JButton renameButton = new JButton("Rename");
+	private final JButton removeButton  = new JButton("Remove");
+	private final JButton addButton = new JButton("New");
 	private JButton moveUpButton;
 	private JButton moveDownButton;
 	private JButton sortButton;
@@ -128,9 +128,8 @@
 
 	private void initComponents() {
 		JPanel listPanel = new JPanel(new GridBagLayout());
-		
-		list = new NonsearchableJList();
-		list.addListSelectionListener(new ListSelectionListener() {
+
+        list.addListSelectionListener(new ListSelectionListener() {
 			public void valueChanged(ListSelectionEvent e) {
 				if(!e.getValueIsAdjusting()){
 					JList source = (JList)e.getSource();
@@ -262,9 +261,8 @@
 		gbc.fill = GridBagConstraints.HORIZONTAL;
 		gbc.anchor = GridBagConstraints.NORTH;
 		listPanel.add(sortButton,gbc);
-		
-		placesTransitionsComboBox = new JComboBox(new String[]{ PLACES, TRANSITIONS });
-		placesTransitionsComboBox.setToolTipText(toolTipChangeBetweenPlacesAndTransitions);
+
+        placesTransitionsComboBox.setToolTipText(toolTipChangeBetweenPlacesAndTransitions);
 		placesTransitionsComboBox.addActionListener(e -> {
 			JComboBox source = (JComboBox)e.getSource();
 			String selectedItem = (String)source.getSelectedItem();
 
=== modified file 'src/dk/aau/cs/gui/TabContent.java'
--- src/dk/aau/cs/gui/TabContent.java	2020-06-22 07:41:12 +0000
+++ src/dk/aau/cs/gui/TabContent.java	2020-07-09 12:55:48 +0000
@@ -3,6 +3,7 @@
 import java.awt.*;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
+import java.awt.geom.Point2D;
 import java.io.*;
 import java.math.BigDecimal;
 import java.util.*;
@@ -11,12 +12,11 @@
 import javax.swing.*;
 import javax.swing.border.BevelBorder;
 
-import dk.aau.cs.approximation.OverApproximation;
-import dk.aau.cs.approximation.UnderApproximation;
 import dk.aau.cs.debug.Logger;
 import dk.aau.cs.gui.components.StatisticsPanel;
 import dk.aau.cs.gui.undo.Command;
 import dk.aau.cs.gui.undo.DeleteQueriesCommand;
+import dk.aau.cs.gui.undo.TimedPlaceMarkingEdit;
 import dk.aau.cs.io.*;
 import dk.aau.cs.io.queries.SUMOQueryLoader;
 import dk.aau.cs.io.queries.XMLQueryLoader;
@@ -35,12 +35,13 @@
 import pipe.gui.*;
 import pipe.gui.canvas.DrawingSurfaceImpl;
 import pipe.gui.graphicElements.*;
-import pipe.gui.graphicElements.tapn.TimedPlaceComponent;
-import pipe.gui.graphicElements.tapn.TimedTransitionComponent;
-import pipe.gui.handler.PlaceTransitionObjectHandler;
+import pipe.gui.graphicElements.tapn.*;
+import pipe.gui.undo.*;
+import pipe.gui.widgets.ConstantsPane;
 import pipe.gui.undo.ChangeSpacingEdit;
 import pipe.gui.undo.UndoManager;
 import pipe.gui.widgets.*;
+
 import net.tapaal.swinghelpers.JSplitPaneFix;
 import dk.aau.cs.gui.components.BugHandledJXMultisplitPane;
 import dk.aau.cs.gui.components.TransitionFireingComponent;
@@ -49,37 +50,443 @@
 
 public class TabContent extends JSplitPane implements TabContentActions{
 
+    static class TAPNLens {
+        public boolean isTimed() {
+            return timed;
+        }
+
+        public boolean isGame() {
+            return game;
+        }
+
+        private final boolean timed;
+        private final boolean game;
+
+        TAPNLens(boolean timed, boolean game) {
+            this.timed = timed;
+            this.game = game;
+        }
+    }
+    private final TAPNLens lens;
+
 	//Model and state
-	private TimedArcPetriNetNetwork tapnNetwork = new TimedArcPetriNetNetwork();
-	private HashMap<TimedArcPetriNet, DataLayer> guiModels = new HashMap<TimedArcPetriNet, DataLayer>();
-	private HashMap<TimedArcPetriNet, Zoomer> zoomLevels = new HashMap<TimedArcPetriNet, Zoomer>();
-
-
-	private UndoManager undoManager = new UndoManager();
+	private final TimedArcPetriNetNetwork tapnNetwork;
+
+	//XXX: Replace with bi-map
+	private final HashMap<TimedArcPetriNet, DataLayer> guiModels = new HashMap<TimedArcPetriNet, DataLayer>();
+	private final HashMap<DataLayer, TimedArcPetriNet> guiModelToModel = new HashMap<>();
+
+	private final HashMap<TimedArcPetriNet, Zoomer> zoomLevels = new HashMap<TimedArcPetriNet, Zoomer>();
+
+
+	private final UndoManager undoManager = new UndoManager();
+
+	public final GuiModelManager guiModelManager = new GuiModelManager();
+	public class GuiModelManager {
+	    public GuiModelManager(){
+
+        }
+
+        public void addNewTimedPlace(DataLayer c, Point p){
+	        Require.notNull(c, "datalyer can't be null");
+            Require.notNull(p, "Point can't be null");
+
+            dk.aau.cs.model.tapn.LocalTimedPlace tp = new dk.aau.cs.model.tapn.LocalTimedPlace(drawingSurface.getNameGenerator().getNewPlaceName(guiModelToModel.get(c)));
+            TimedPlaceComponent pnObject = new TimedPlaceComponent(p.x, p.y, tp);
+            guiModelToModel.get(c).add(tp);
+            c.addPetriNetObject(pnObject);
+
+            getUndoManager().addNewEdit(new AddTimedPlaceCommand(pnObject, guiModelToModel.get(c), c));
+
+        }
+
+        public void addNewTimedTransitions(DataLayer c, Point p) {
+            dk.aau.cs.model.tapn.TimedTransition transition = new dk.aau.cs.model.tapn.TimedTransition(drawingSurface.getNameGenerator().getNewTransitionName(guiModelToModel.get(c)));
+
+            TimedTransitionComponent pnObject = new TimedTransitionComponent(p.x, p.y, transition);
+
+            guiModelToModel.get(c).add(transition);
+            c.addPetriNetObject(pnObject);
+
+            getUndoManager().addNewEdit(new AddTimedTransitionCommand(pnObject, guiModelToModel.get(c), c));
+        }
+
+        public void addAnnotationNote(DataLayer c, Point p) {
+            AnnotationNote pnObject = new AnnotationNote(p.x, p.y);
+
+            //enableEditMode open editor, retuns true of text added, else false
+            //If no text is added,dont add it to model
+            if (pnObject.enableEditMode(true)) {
+                c.addPetriNetObject(pnObject);
+                getUndoManager().addEdit(new AddAnnotationNoteCommand(pnObject, c));
+            }
+        }
+
+        public void addTimedInputArc(DataLayer c, TimedPlaceComponent p, TimedTransitionComponent t, ArcPath path) {
+            Require.notNull(c, "DataLayer can't be null");
+            Require.notNull(p, "Place can't be null");
+            Require.notNull(t, "Transitions can't be null");
+
+            TimedArcPetriNet modelNet = guiModelToModel.get(c);
+
+            if (!modelNet.hasArcFromPlaceToTransition(p.underlyingPlace(), t.underlyingTransition())) {
+
+                TimedInputArc tia = new TimedInputArc(
+                    p.underlyingPlace(),
+                    t.underlyingTransition(),
+                    TimeInterval.ZERO_INF
+                );
+
+                TimedInputArcComponent tiac = new TimedInputArcComponent(p,t,tia);
+
+                if (path != null) {
+                    tiac.setArcPath(new ArcPath(tiac, path));
+                }
+
+                Command edit = new AddTimedInputArcCommand(
+                    tiac,
+                    modelNet,
+                    c
+                );
+                edit.redo();
+
+                undoManager.addNewEdit(edit);
+
+            }  else {
+                //TODO: can't have two arcs between place and transition
+                JOptionPane.showMessageDialog(
+                    CreateGui.getApp(),
+                    "There was an error drawing the arc. Possible problems:\n"
+                        + " - There is already an arc between the selected place and transition\n"
+                        + " - You are attempting to draw an arc between a shared transition and a shared place",
+                    "Error", JOptionPane.ERROR_MESSAGE
+                );
+            }
+        }
+
+        public void addTimedOutputArc(DataLayer c, TimedTransitionComponent t, TimedPlaceComponent p, ArcPath path) {
+            Require.notNull(c, "DataLayer can't be null");
+            Require.notNull(p, "Place can't be null");
+            Require.notNull(t, "Transitions can't be null");
+
+            TimedArcPetriNet modelNet = guiModelToModel.get(c);
+
+            if (!modelNet.hasArcFromTransitionToPlace(t.underlyingTransition(), p.underlyingPlace())) {
+
+                TimedOutputArc toa = new TimedOutputArc(
+                    t.underlyingTransition(),
+                    p.underlyingPlace()
+                );
+
+                TimedOutputArcComponent toac = new TimedOutputArcComponent(t, p, toa);
+
+                if (path != null) {
+                    toac.setArcPath(new ArcPath(toac, path));
+                }
+
+                Command edit = new AddTimedOutputArcCommand(
+                    toac,
+                    modelNet,
+                    c
+                );
+                edit.redo();
+                undoManager.addNewEdit(edit);
+
+            } else {
+
+                JOptionPane.showMessageDialog(
+                    CreateGui.getApp(),
+                    "There was an error drawing the arc. Possible problems:\n"
+                        + " - There is already an arc between the selected place and transition\n"
+                        + " - You are attempting to draw an arc between a shared transition and a shared place",
+                    "Error", JOptionPane.ERROR_MESSAGE
+                );
+
+            }
+
+
+        }
+
+        public void addInhibitorArc(DataLayer c, TimedPlaceComponent p, TimedTransitionComponent t, ArcPath path) {
+            Require.notNull(c, "DataLayer can't be null");
+            Require.notNull(p, "Place can't be null");
+            Require.notNull(t, "Transitions can't be null");
+
+            TimedArcPetriNet modelNet = guiModelToModel.get(c);
+
+            if (!modelNet.hasArcFromPlaceToTransition(p.underlyingPlace(), t.underlyingTransition())) {
+
+                TimedInhibitorArc tiha = new TimedInhibitorArc(
+                    p.underlyingPlace(),
+                    t.underlyingTransition()
+                );
+
+                TimedInhibitorArcComponent tihac = new TimedInhibitorArcComponent(p, t, tiha);
+
+                if (path != null) {
+                    tihac.setArcPath(new ArcPath(tihac, path));
+                }
+
+                Command edit = new AddTimedInhibitorArcCommand(
+                    tihac,
+                    modelNet,
+                    c
+                );
+                edit.redo();
+                undoManager.addNewEdit(edit);
+
+            } else {
+
+                JOptionPane.showMessageDialog(
+                    CreateGui.getApp(),
+                    "There was an error drawing the arc. Possible problems:\n"
+                        + " - There is already an arc between the selected place and transition\n"
+                        + " - You are attempting to draw an arc between a shared transition and a shared place",
+                    "Error", JOptionPane.ERROR_MESSAGE
+                );
+
+            }
+
+        }
+
+        public void addTimedTransportArc(DataLayer c, TimedPlaceComponent p1, TimedTransitionComponent t, TimedPlaceComponent p2, ArcPath path1, ArcPath path2) {
+            Require.notNull(c, "DataLayer can't be null");
+            Require.notNull(p1, "Place1 can't be null");
+            Require.notNull(t, "Transitions can't be null");
+            Require.notNull(p2, "Place2 can't be null");
+
+            TimedArcPetriNet modelNet = guiModelToModel.get(c);
+
+            if (
+                !modelNet.hasArcFromPlaceToTransition(p1.underlyingPlace(), t.underlyingTransition()) &&
+                !modelNet.hasArcFromTransitionToPlace(t.underlyingTransition(), p2.underlyingPlace())
+            ) {
+
+                int groupNr = getNextTransportArcMaxGroupNumber(p1, t);
+
+                TransportArc tta = new TransportArc(p1.underlyingPlace(), t.underlyingTransition(), p2.underlyingPlace());
+
+                TimedTransportArcComponent ttac1 = new TimedTransportArcComponent(p1, t, tta, groupNr);
+                TimedTransportArcComponent ttac2 = new TimedTransportArcComponent(t, p2, tta, groupNr);
+
+                ttac1.setConnectedTo(ttac2);
+                ttac2.setConnectedTo(ttac1);
+
+                if (path1 != null) {
+                    ttac1.setArcPath(new ArcPath(ttac1, path1));
+                }
+                if (path2 != null) {
+                    ttac2.setArcPath(new ArcPath(ttac2, path2));
+                }
+
+                //XXX: the Command should take both arcs
+                Command edit = new AddTransportArcCommand(
+                    ttac2,
+                    tta,
+                    modelNet,
+                    c
+                );
+                edit.redo();
+                undoManager.addNewEdit(edit);
+
+            } else {
+                JOptionPane.showMessageDialog(
+                    CreateGui.getApp(),
+                    "There was an error drawing the arc. Possible problems:\n"
+                        + " - There is already an arc between the source place and transition\n"
+                        + " - There is already an arc between the transtion and the target place\n"
+                        + " - You are attempting to draw an arc between a shared transition and a shared place",
+                    "Error", JOptionPane.ERROR_MESSAGE
+                );
+            }
+
+        }
+
+        private int getNextTransportArcMaxGroupNumber(TimedPlaceComponent p, TimedTransitionComponent t) {
+            int groupMaxCounter = 0;
+
+            for (Arc a : t.getPreset()) {
+                if (a instanceof TimedTransportArcComponent && a.getTarget().equals(t)) {
+                    if (((TimedTransportArcComponent) a).getGroupNr() > groupMaxCounter) {
+                        groupMaxCounter = ((TimedTransportArcComponent) a).getGroupNr();
+                    }
+                }
+            }
+
+            return groupMaxCounter+1;
+        }
+
+
+        public void deleteSelection() {
+            // check if queries need to be removed
+            ArrayList<PetriNetObject> selection = drawingSurface().getSelectionObject().getSelection();
+            Iterable<TAPNQuery> queries = queries();
+            HashSet<TAPNQuery> queriesToDelete = new HashSet<TAPNQuery>();
+
+            boolean queriesAffected = false;
+            for (PetriNetObject pn : selection) {
+                if (pn instanceof TimedPlaceComponent) {
+                    TimedPlaceComponent place = (TimedPlaceComponent)pn;
+                    if(!place.underlyingPlace().isShared()){
+                        for (TAPNQuery q : queries) {
+                            if (q.getProperty().containsAtomicPropositionWithSpecificPlaceInTemplate(((LocalTimedPlace)place.underlyingPlace()).model().name(),place.underlyingPlace().name())) {
+                                queriesAffected = true;
+                                queriesToDelete.add(q);
+                            }
+                        }
+                    }
+                } else if (pn instanceof TimedTransitionComponent){
+                    TimedTransitionComponent transition = (TimedTransitionComponent)pn;
+                    if(!transition.underlyingTransition().isShared()){
+                        for (TAPNQuery q : queries) {
+                            if (q.getProperty().containsAtomicPropositionWithSpecificTransitionInTemplate((transition.underlyingTransition()).model().name(),transition.underlyingTransition().name())) {
+                                queriesAffected = true;
+                                queriesToDelete.add(q);
+                            }
+                        }
+                    }
+                }
+            }
+            StringBuilder s = new StringBuilder();
+            s.append("The following queries are associated with the currently selected objects:\n\n");
+            for (TAPNQuery q : queriesToDelete) {
+                s.append(q.getName());
+                s.append('\n');
+            }
+            s.append("\nAre you sure you want to remove the current selection and all associated queries?");
+
+            int choice = queriesAffected ? JOptionPane.showConfirmDialog(
+                CreateGui.getApp(), s.toString(), "Warning",
+                JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE)
+                : JOptionPane.YES_OPTION;
+
+            if (choice == JOptionPane.YES_OPTION) {
+                getUndoManager().newEdit(); // new "transaction""
+                if (queriesAffected) {
+                    TabContent currentTab = TabContent.this;
+                    for (TAPNQuery q : queriesToDelete) {
+                        Command cmd = new DeleteQueriesCommand(currentTab, Arrays.asList(q));
+                        cmd.redo();
+                        getUndoManager().addEdit(cmd);
+                    }
+                }
+
+                deleteSelection(selection);
+                network().buildConstraints();
+            }
+        }
+
+        //XXX: function moved from undoManager --kyrke - 2019-07-06
+        private void deleteObject(PetriNetObject pnObject) {
+            if (pnObject instanceof ArcPathPoint) {
+
+                ArcPathPoint arcPathPoint = (ArcPathPoint)pnObject;
+
+                //If the arc is marked for deletion, skip deleting individual arcpathpoint
+                if (!(arcPathPoint.getArcPath().getArc().isSelected())) {
+
+                    //Don't delete the two last arc path points
+                    if (arcPathPoint.isDeleteable()) {
+                        Command cmd = new DeleteArcPathPointEdit(
+                            arcPathPoint.getArcPath().getArc(),
+                            arcPathPoint,
+                            arcPathPoint.getIndex(),
+                            getModel()
+                        );
+                        cmd.redo();
+                        getUndoManager().addEdit(cmd);
+                    }
+                }
+            }else{
+                //The list of selected objects is not updated when a element is deleted
+                //We might delete the same object twice, which will give an error
+                //Eg. a place with output arc is deleted (deleted also arc) while arc is also selected.
+                //There is properly a better way to track this (check model?) but while refactoring we will keeps it close
+                //to the orginal code -- kyrke 2019-06-27
+                if (!pnObject.isDeleted()) {
+                    Command cmd = null;
+                    if(pnObject instanceof TimedPlaceComponent){
+                        TimedPlaceComponent tp = (TimedPlaceComponent)pnObject;
+                        cmd = new DeleteTimedPlaceCommand(tp, guiModelToModel.get(getModel()), getModel());
+                    }else if(pnObject instanceof TimedTransitionComponent){
+                        TimedTransitionComponent transition = (TimedTransitionComponent)pnObject;
+                        cmd = new DeleteTimedTransitionCommand(transition, transition.underlyingTransition().model(), getModel());
+                    }else if(pnObject instanceof TimedTransportArcComponent){
+                        TimedTransportArcComponent transportArc = (TimedTransportArcComponent)pnObject;
+                        cmd = new DeleteTransportArcCommand(transportArc, transportArc.underlyingTransportArc(), transportArc.underlyingTransportArc().model(), getModel());
+                    }else if(pnObject instanceof TimedInhibitorArcComponent){
+                        TimedInhibitorArcComponent tia = (TimedInhibitorArcComponent)pnObject;
+                        cmd = new DeleteTimedInhibitorArcCommand(tia, tia.underlyingTimedInhibitorArc().model(), getModel());
+                    }else if(pnObject instanceof TimedInputArcComponent){
+                        TimedInputArcComponent tia = (TimedInputArcComponent)pnObject;
+                        cmd = new DeleteTimedInputArcCommand(tia, tia.underlyingTimedInputArc().model(), getModel());
+                    }else if(pnObject instanceof TimedOutputArcComponent){
+                        TimedOutputArcComponent toa = (TimedOutputArcComponent)pnObject;
+                        cmd = new DeleteTimedOutputArcCommand(toa, toa.underlyingArc().model(), getModel());
+                    }else if(pnObject instanceof AnnotationNote){
+                        cmd = new DeleteAnnotationNoteCommand((AnnotationNote)pnObject, getModel());
+                    }else{
+                        throw new RuntimeException("This should not be possible");
+                    }
+                    cmd.redo();
+                    getUndoManager().addEdit(cmd);
+                }
+            }
+        }
+
+
+        private void deleteSelection(PetriNetObject pnObject) {
+            if(pnObject instanceof PlaceTransitionObject){
+                PlaceTransitionObject pto = (PlaceTransitionObject)pnObject;
+
+                ArrayList<Arc> arcsToDelete = new ArrayList<>();
+
+                //Notice since we delte elements from the collection we can't do this while iterating, we need to
+                // capture the arcs and delete them later.
+                for(Arc arc : pto.getPreset()){
+                    arcsToDelete.add(arc);
+                }
+
+                for(Arc arc : pto.getPostset()){
+                    arcsToDelete.add(arc);
+                }
+
+                arcsToDelete.forEach(this::deleteObject);
+            }
+
+            deleteObject(pnObject);
+        }
+
+        public void deleteSelection(ArrayList<PetriNetObject> selection) {
+            for (PetriNetObject pnObject : selection) {
+                deleteSelection(pnObject);
+            }
+        }
+
+
+    }
+
 
     /**
 	 * Creates a new tab with the selected file, or a new file if filename==null
 	 */
 	public static TabContent createNewTabFromInputStream(InputStream file, String name) throws Exception {
-		TabContent tab = new TabContent();
-		tab.setInitialName(name);
 
-		try {
+	    try {
 			ModelLoader loader = new ModelLoader();
 			LoadedModel loadedModel = loader.load(file);
 
-			tab.setNetwork(loadedModel.network(), loadedModel.templates());
-			tab.setQueries(loadedModel.queries());
-			tab.setConstants(loadedModel.network().constants());
+            TabContent tab = new TabContent(loadedModel.network(), loadedModel.templates(), loadedModel.queries());
+            tab.setInitialName(name);
 
 			tab.selectFirstElements();
 
 			tab.setFile(null);
+			return tab;
 		} catch (Exception e) {
 			throw new Exception("TAPAAL encountered an error while loading the file: " + name + "\n\nPossible explanations:\n  - " + e.toString());
 		}
 
-		return tab;
 	}
 
 	public static TabContent createNewEmptyTab(String name){
@@ -89,7 +496,7 @@
 		//Set Default Template
 		String templateName = tab.drawingSurface().getNameGenerator().getNewTemplateName();
 		Template template = new Template(new TimedArcPetriNet(templateName), new DataLayer(), new Zoomer());
-		tab.addTemplate(template, false);
+		tab.addTemplate(template);
 
 		return tab;
 	}
@@ -99,14 +506,6 @@
 	 */
 
 	public static TabContent createNewTabFromPNMLFile(File file) throws Exception {
-		TabContent tab = new TabContent();
-
-		String name = null;
-
-		if (file != null) {
-			name = file.getName().replaceAll(".pnml", ".tapn");
-		}
-		tab.setInitialName(name);
 
 		if (file != null) {
 			try {
@@ -116,24 +515,28 @@
 				PNMLoader loader = new PNMLoader();
 				loadedModel = loader.load(file);
 
-
-				tab.setNetwork(loadedModel.network(), loadedModel.templates());
-				tab.setQueries(loadedModel.queries());
-				tab.setConstants(loadedModel.network().constants());
+                TabContent tab = new TabContent(loadedModel.network(), loadedModel.templates(), loadedModel.queries());
+
+                String name = null;
+
+                if (file != null) {
+                    name = file.getName().replaceAll(".pnml", ".tapn");
+                }
+                tab.setInitialName(name);
 
 				tab.selectFirstElements();
 
 				tab.setMode(Pipe.ElementType.SELECT);
 
+                //appView.updatePreferredSize(); //XXX 2018-05-23 kyrke seems not to be needed
+                name = name.replace(".pnml",".tapn"); // rename .pnml input file to .tapn
+                return tab;
 
 			} catch (Exception e) {
 				throw new Exception("TAPAAL encountered an error while loading the file: " + file.getName() + "\n\nPossible explanations:\n  - " + e.toString());
 			}
 		}
-
-		//appView.updatePreferredSize(); //XXX 2018-05-23 kyrke seems not to be needed
-		name = name.replace(".pnml",".tapn"); // rename .pnml input file to .tapn
-		return tab;
+		return null;
 	}
 
 	/**
@@ -227,49 +630,72 @@
 	
 	private WorkflowDialog workflowDialog = null;
 
-	public TabContent() {
-		for (TimedArcPetriNet net : tapnNetwork.allTemplates()) {
-			guiModels.put(net, new DataLayer());
-			zoomLevels.put(net, new Zoomer());
-			hasPositionalInfos.put(net, Boolean.FALSE);
-		}
-		
-		drawingSurface = new DrawingSurfaceImpl(new DataLayer(), this, managerRef);
-		drawingSurfaceScroller = new JScrollPane(drawingSurface);
-		// make it less bad on XP
-		drawingSurfaceScroller.setBorder(new BevelBorder(BevelBorder.LOWERED));
-		drawingSurfaceScroller.setWheelScrollingEnabled(true);
-		drawingSurfaceScroller.getVerticalScrollBar().setUnitIncrement(10);
-		drawingSurfaceScroller.getHorizontalScrollBar().setUnitIncrement(10);
-
-		// Make clicking the drawing area move focus to GuiFrame
-		drawingSurface.addMouseListener(new MouseAdapter() {	
-			@Override
-			public void mouseClicked(MouseEvent e) {
-				CreateGui.getApp().requestFocus();
-			}
-		});
-		
-		drawingSurfaceDummy = new JPanel(new GridBagLayout());
-		GridBagConstraints gc=new GridBagConstraints();
-		gc.fill=GridBagConstraints.HORIZONTAL;
-		gc.gridx=0;
-		gc.gridy=0;
-		drawingSurfaceDummy.add(new JLabel("The net is too big to be drawn"), gc);
-		
-		createEditorLeftPane();
-		createAnimatorSplitPane();
-
-		this.setOrientation(HORIZONTAL_SPLIT);
-		this.setLeftComponent(editorSplitPaneScroller);
-		this.setRightComponent(drawingSurfaceScroller);
-
-		this.setContinuousLayout(true);
-		this.setOneTouchExpandable(true);
-		this.setBorder(null); // avoid multiple borders
-		this.setDividerSize(8);
-		//XXX must be after the animationcontroller is created
-		animationModeController = new CanvasAnimationController(getAnimator());
+
+	private TabContent() {
+	    this(new TimedArcPetriNetNetwork(), new ArrayList<>(), new TAPNLens(true,false));
+    }
+
+	private TabContent(TimedArcPetriNetNetwork network, Collection<Template> templates, TAPNLens lens) {
+
+        Require.that(network != null, "network cannot be null");
+        Require.notNull(lens, "Lens can't be null");
+        this.lens = lens;
+        tapnNetwork = network;
+
+        guiModels.clear();
+        for (Template template : templates) {
+            addGuiModel(template.model(), template.guiModel());
+            zoomLevels.put(template.model(), template.zoomer());
+            hasPositionalInfos.put(template.model(), template.getHasPositionalInfo());
+        }
+
+        drawingSurface = new DrawingSurfaceImpl(new DataLayer(), this, managerRef);
+        drawingSurfaceScroller = new JScrollPane(drawingSurface);
+        // make it less bad on XP
+        drawingSurfaceScroller.setBorder(new BevelBorder(BevelBorder.LOWERED));
+        drawingSurfaceScroller.setWheelScrollingEnabled(true);
+        drawingSurfaceScroller.getVerticalScrollBar().setUnitIncrement(10);
+        drawingSurfaceScroller.getHorizontalScrollBar().setUnitIncrement(10);
+
+        // Make clicking the drawing area move focus to GuiFrame
+        drawingSurface.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                CreateGui.getApp().requestFocus();
+            }
+        });
+
+        drawingSurfaceDummy = new JPanel(new GridBagLayout());
+        GridBagConstraints gc=new GridBagConstraints();
+        gc.fill=GridBagConstraints.HORIZONTAL;
+        gc.gridx=0;
+        gc.gridy=0;
+        drawingSurfaceDummy.add(new JLabel("The net is too big to be drawn"), gc);
+
+        createEditorLeftPane();
+        createAnimatorSplitPane();
+
+        this.setOrientation(HORIZONTAL_SPLIT);
+        this.setLeftComponent(editorSplitPaneScroller);
+        this.setRightComponent(drawingSurfaceScroller);
+
+        this.setContinuousLayout(true);
+        this.setOneTouchExpandable(true);
+        this.setBorder(null); // avoid multiple borders
+        this.setDividerSize(8);
+        //XXX must be after the animationcontroller is created
+        animationModeController = new CanvasAnimationController(getAnimator());
+    }
+
+    private TabContent(TimedArcPetriNetNetwork network, Collection<Template> templates, Iterable<TAPNQuery> tapnqueries) {
+        this(network, templates, tapnqueries,  new TAPNLens(true, false));
+    }
+	private TabContent(TimedArcPetriNetNetwork network, Collection<Template> templates, Iterable<TAPNQuery> tapnqueries, TAPNLens lens) {
+        this(network, templates, lens);
+
+        setNetwork(network, templates);
+        setQueries(tapnqueries);
+        setConstants(network().constants());
 	}
 	
 	public SharedPlacesAndTransitionsPanel getSharedPlacesAndTransitionsPanel(){
@@ -706,34 +1132,24 @@
 		return count;
 	}
 
-	/*
-		XXX: 2018-05-07 kyrke, added a version of addTemplate that does not call templatExplorer.updatTemplateList
-		used in createNewTab (as updateTamplateList expects the current tab to be selected)
-		this needs to be refactored asap. but the is the only way I could get it to work for now.
-		The code is very unclean on what is a template, TimeArcPetriNetNetwork, seems to mix concerns about
-		gui/controller/model. Further refactoring is needed to clean up this mess.
-	 */
-	public void addTemplate(Template template, boolean updateTemplateExplorer) {
+	public void addTemplate(Template template) {
 		tapnNetwork.add(template.model());
 		guiModels.put(template.model(), template.guiModel());
+        guiModelToModel.put(template.guiModel(), template.model());
 		zoomLevels.put(template.model(), template.zoomer());
 		hasPositionalInfos.put(template.model(), template.getHasPositionalInfo());
-		if (updateTemplateExplorer) {
-			templateExplorer.updateTemplateList();
-		}
-	}
-
-	public void addTemplate(Template template) {
-		addTemplate(template, true);
+		templateExplorer.updateTemplateList();
 	}
 
 	public void addGuiModel(TimedArcPetriNet net, DataLayer guiModel) {
 		guiModels.put(net, guiModel);
+		guiModelToModel.put(guiModel, net);
 	}
 
 	public void removeTemplate(Template template) {
 		tapnNetwork.remove(template.model());
 		guiModels.remove(template.model());
+		guiModelToModel.remove(template.guiModel());
 		zoomLevels.remove(template.model());
 		hasPositionalInfos.remove(template.model());
 		templateExplorer.updateTemplateList();
@@ -747,7 +1163,7 @@
 		return queries.getQueries();
 	}
 
-	public void setQueries(Iterable<TAPNQuery> queries) {
+	private void setQueries(Iterable<TAPNQuery> queries) {
 		this.queries.setQueries(queries);
 	}
 
@@ -759,20 +1175,12 @@
 		queries.addQuery(query);
 	}
 
-	public void setConstants(Iterable<Constant> constants) {
+	private void setConstants(Iterable<Constant> constants) {
 		tapnNetwork.setConstants(constants);
 	}
 
-	public void setNetwork(TimedArcPetriNetNetwork network, Collection<Template> templates) {
-		Require.that(network != null, "network cannot be null");
-		tapnNetwork = network;
+	private void setNetwork(TimedArcPetriNetNetwork network, Collection<Template> templates) {
 
-		guiModels.clear();
-		for (Template template : templates) {
-			addGuiModel(template.model(), template.guiModel());
-			zoomLevels.put(template.model(), template.zoomer());
-			hasPositionalInfos.put(template.model(), template.getHasPositionalInfo());
-		}
 
 		sharedPTPanel.setNetwork(network);
 		templateExplorer.updateTemplateList();
@@ -1060,6 +1468,8 @@
 		animator.updateAnimationButtonsEnabled(); //Update stepBack/Forward
 	}
 
+	private Pipe.ElementType editorMode = Pipe.ElementType.SELECT;
+
 	//XXX temp while refactoring, kyrke - 2019-07-25
 	@Override
 	public void setMode(Pipe.ElementType mode) {
@@ -1068,11 +1478,67 @@
 
 		//Disable selection and deselect current selection
 		drawingSurface().getSelectionObject().clearSelection();
-
-		//If pending arc draw, remove it
-		if (drawingSurface().createArc != null) {
-			PlaceTransitionObjectHandler.cleanupArc(drawingSurface().createArc, drawingSurface());
-		}
+        editorMode = mode;
+        switch (mode) {
+            case ADDTOKEN:
+                setManager(new AbstractDrawingSurfaceManager() {
+                    @Override
+                    public void registerEvents() {
+                        registerEvent(
+                            e -> e.pno instanceof TimedPlaceComponent && e.a == MouseAction.pressed,
+                            e -> placeClicked((TimedPlaceComponent) e.pno)
+                        );
+                    }
+
+                    public void placeClicked(TimedPlaceComponent pno) {
+                        Command command = new TimedPlaceMarkingEdit(pno, 1);
+                        command.redo();
+                        undoManager.addNewEdit(command);
+                    }
+                });
+                break;
+            case DELTOKEN:
+                setManager(new AbstractDrawingSurfaceManager() {
+                    @Override
+                    public void registerEvents() {
+                        registerEvent(
+                            e -> e.pno instanceof TimedPlaceComponent && e.a == MouseAction.pressed,
+                            e -> placeClicked((TimedPlaceComponent) e.pno)
+                        );
+                    }
+
+                    public void placeClicked(TimedPlaceComponent pno) {
+                        Command command = new TimedPlaceMarkingEdit(pno, -1);
+                        command.redo();
+                        undoManager.addNewEdit(command);
+                    }
+                });
+                break;
+            case TAPNPLACE:
+                setManager(new CanvasPlaceDrawController());
+                break;
+            case TAPNTRANS:
+                setManager(new CanvasTransitionDrawController());
+                break;
+            case ANNOTATION:
+                setManager(new CanvasAnnotationNoteDrawController());
+                break;
+            case TAPNARC:
+                setManager(new CanvasArcDrawController());
+                break;
+            case TAPNINHIBITOR_ARC:
+                setManager(new CanvasInhibitorarcDrawController());
+                break;
+            case TRANSPORTARC:
+                setManager(new CanvasTransportarcDrawController());
+                break;
+            case SELECT:
+                setManager(new CanvasGeneralDrawController());
+                break;
+            default:
+                setManager(notingManager);
+                break;
+        }
 
 		if (mode == Pipe.ElementType.SELECT) {
 			drawingSurface().setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
@@ -1221,63 +1687,7 @@
 
 	@Override
 	public void deleteSelection() {
-		// check if queries need to be removed
-		ArrayList<PetriNetObject> selection = drawingSurface().getSelectionObject().getSelection();
-		Iterable<TAPNQuery> queries = queries();
-		HashSet<TAPNQuery> queriesToDelete = new HashSet<TAPNQuery>();
-
-		boolean queriesAffected = false;
-		for (PetriNetObject pn : selection) {
-			if (pn instanceof TimedPlaceComponent) {
-				TimedPlaceComponent place = (TimedPlaceComponent)pn;
-				if(!place.underlyingPlace().isShared()){
-					for (TAPNQuery q : queries) {
-						if (q.getProperty().containsAtomicPropositionWithSpecificPlaceInTemplate(((LocalTimedPlace)place.underlyingPlace()).model().name(),place.underlyingPlace().name())) {
-							queriesAffected = true;
-							queriesToDelete.add(q);
-						}
-					}
-				}
-			} else if (pn instanceof TimedTransitionComponent){
-				TimedTransitionComponent transition = (TimedTransitionComponent)pn;
-				if(!transition.underlyingTransition().isShared()){
-					for (TAPNQuery q : queries) {
-						if (q.getProperty().containsAtomicPropositionWithSpecificTransitionInTemplate((transition.underlyingTransition()).model().name(),transition.underlyingTransition().name())) {
-							queriesAffected = true;
-							queriesToDelete.add(q);
-						}
-					}
-				}
-			}
-		}
-		StringBuilder s = new StringBuilder();
-		s.append("The following queries are associated with the currently selected objects:\n\n");
-		for (TAPNQuery q : queriesToDelete) {
-			s.append(q.getName());
-			s.append('\n');
-		}
-		s.append("\nAre you sure you want to remove the current selection and all associated queries?");
-
-		int choice = queriesAffected ? JOptionPane.showConfirmDialog(
-				CreateGui.getApp(), s.toString(), "Warning",
-				JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE)
-				: JOptionPane.YES_OPTION;
-
-		if (choice == JOptionPane.YES_OPTION) {
-			getUndoManager().newEdit(); // new "transaction""
-			if (queriesAffected) {
-				TabContent currentTab = this;
-				for (TAPNQuery q : queriesToDelete) {
-					Command cmd = new DeleteQueriesCommand(currentTab, Arrays.asList(q));
-					cmd.redo();
-					getUndoManager().addEdit(cmd);
-				}
-			}
-
-			drawingSurface().deleteSelection(drawingSurface().getSelectionObject().getSelection());
-			//getCurrentTab().drawingSurface().repaint();
-			network().buildConstraints();
-		}
+		guiModelManager.deleteSelection();
 
 
 	}
@@ -1309,13 +1719,13 @@
 
 			//If arc is being drawn delete it
 
-			if (drawingSurface().createArc == null) {
+			if (editorMode == Pipe.ElementType.SELECT) {
 				getUndoManager().undo();
 				network().buildConstraints();
 
 			} else {
 
-				PlaceTransitionObjectHandler.cleanupArc(drawingSurface().createArc, drawingSurface());
+				setMode(Pipe.ElementType.SELECT);
 
 			}
 		}
@@ -1330,13 +1740,13 @@
 
 				//If arc is being drawn delete it
 
-				if (drawingSurface().createArc == null) {
+				if (editorMode == Pipe.ElementType.SELECT) {
 					getUndoManager().redo();
 					network().buildConstraints();
 
 				} else {
 
-					PlaceTransitionObjectHandler.cleanupArc(drawingSurface().createArc, drawingSurface());
+                    setMode(Pipe.ElementType.SELECT);
 
 				}
 			}
@@ -1462,6 +1872,321 @@
 		return null;
 	}
 
+	class CanvasPlaceDrawController extends AbstractDrawingSurfaceManager {
+
+        @Override
+        public void drawingSurfaceMousePressed(MouseEvent e) {
+            Point p = canvas.adjustPointToGridAndZoom(e.getPoint(), canvas.getZoom());
+
+            guiModelManager.addNewTimedPlace(canvas.getGuiModel(), p);
+        }
+
+        @Override
+        public void registerEvents() {
+
+        }
+    }
+
+    class CanvasTransitionDrawController extends AbstractDrawingSurfaceManager {
+
+        @Override
+        public void drawingSurfaceMousePressed(MouseEvent e) {
+            Point p = canvas.adjustPointToGridAndZoom(e.getPoint(), canvas.getZoom());
+
+            guiModelManager.addNewTimedTransitions(drawingSurface.getGuiModel(), p);
+        }
+
+        @Override
+        public void registerEvents() {
+
+        }
+    }
+
+    class CanvasAnnotationNoteDrawController extends AbstractDrawingSurfaceManager {
+
+        @Override
+        public void drawingSurfaceMousePressed(MouseEvent e) {
+            Point p = canvas.adjustPointToGridAndZoom(e.getPoint(), canvas.getZoom());
+
+           guiModelManager.addAnnotationNote(drawingSurface.getGuiModel(), p);
+        }
+
+        @Override
+        public void registerEvents() {
+
+        }
+    }
+
+    class CanvasInhibitorarcDrawController extends AbstractDrawingSurfaceManager {
+
+        private TimedTransitionComponent transition;
+        private TimedPlaceComponent place;
+        private Arc arc;
+
+        @Override
+        public void registerEvents() {
+            registerEvent(
+                e->e.pno instanceof TimedPlaceComponent && e.a == MouseAction.pressed,
+                e->placeClicked(((TimedPlaceComponent) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof TimedTransitionComponent && e.a == MouseAction.pressed,
+                e->transitionClicked(((TimedTransitionComponent) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.entered,
+                e->placetranstionMouseOver(((PlaceTransitionObject) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.exited,
+                e->placetranstionMouseExited(((PlaceTransitionObject) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.moved,
+                e->placetransitionMouseMoved(((PlaceTransitionObject) e.pno), e.e)
+            );
+        }
+
+        private void placetransitionMouseMoved(PlaceTransitionObject pno, MouseEvent e) {
+            if (arc != null) {
+                if (arc.getSource() == pno || !arc.getSource().areNotSameType(pno)) {
+                    //Dispatch event to parent (drawing surface)
+                    e.translatePoint(pno.getX(),pno.getY());
+                    pno.getParent().dispatchEvent(e);
+                }
+            }
+        }
+
+        private void placetranstionMouseExited(PlaceTransitionObject pto) {
+            if (arc != null) {
+                arc.setTarget(null);
+                //XXX this is bad, we have to clean up internal state manually, should be refactored //kyrke - 2019-11-14
+                // Relates to bug #1849786
+                if (pto instanceof Transition) {
+                    ((Transition)pto).removeArcCompareObject(arc);
+                }
+                arc.updateArcPosition();
+            }
+        }
+
+        private void placetranstionMouseOver(PlaceTransitionObject pno) {
+            if (arc != null) {
+                if (arc.getSource() != pno && arc.getSource().areNotSameType(pno)) {
+                    arc.setTarget(pno);
+                    arc.updateArcPosition();
+                }
+            }
+        }
+
+        private void transitionClicked(TimedTransitionComponent pno) {
+            if (place != null && transition == null) {
+                transition = pno;
+                CreateGui.getDrawingSurface().clearAllPrototype();
+                guiModelManager.addInhibitorArc(getModel(), place, transition, arc.getArcPath());
+                clearPendingArc();
+            }
+        }
+
+        private void placeClicked(TimedPlaceComponent pno) {
+            if (place == null && transition == null) {
+                place = pno;
+                arc = new TimedInhibitorArcComponent(pno);
+                //XXX calling zoomUpdate will set the endpoint to 0,0, drawing the arc from source to 0,0
+                //to avoid this we change the endpoint to set the end point to the same as the end point
+                //needs further refactorings //kyrke 2019-09-05
+                arc.setEndPoint(pno.getPositionX(), pno.getPositionY(), false);
+                CreateGui.getDrawingSurface().addPrototype(arc);
+                arc.requestFocusInWindow();
+                arc.setSelectable(false);
+                arc.enableDrawingKeyBindings(this::clearPendingArc);
+            } else if (transition != null && place == null) {
+                place = pno;
+                CreateGui.getDrawingSurface().clearAllPrototype();
+                guiModelManager.addTimedOutputArc(getModel(), transition, place, arc.getArcPath());
+                clearPendingArc();
+            }
+        }
+
+        private void clearPendingArc() {
+            CreateGui.getDrawingSurface().clearAllPrototype();
+            place = null;
+            transition = null;
+            arc = null;
+        }
+
+        @Override
+        public void drawingSurfaceMouseMoved(MouseEvent e) {
+            if(arc!=null) {
+                arc.setEndPoint(e.getX(), e.getY(), e.isShiftDown());
+            }
+        }
+
+        @Override
+        public void drawingSurfaceMousePressed(MouseEvent e) {
+            if (arc!=null) {;
+                Point p = e.getPoint();
+                int x = Zoomer.getUnzoomedValue(p.x, CreateGui.getDrawingSurface().getZoom());
+                int y = Zoomer.getUnzoomedValue(p.y, CreateGui.getDrawingSurface().getZoom());
+
+                boolean shiftDown = e.isShiftDown();
+                //XXX: x,y is ignored is overwritten when mouse is moved, this just add a new point to the end of list
+                arc.getArcPath().addPoint(arc.getArcPath().getEndIndex(), x,y, shiftDown);
+            }
+        }
+
+        @Override
+        public void registerManager(DrawingSurfaceImpl canvas) {
+            CreateGui.useExtendedBounds = true;
+        }
+
+        @Override
+        public void deregisterManager() {
+            clearPendingArc();
+            CreateGui.useExtendedBounds = false;
+        }
+
+
+    }
+    class CanvasArcDrawController extends  AbstractDrawingSurfaceManager {
+        private TimedTransitionComponent transition;
+        private TimedPlaceComponent place;
+        private Arc arc;
+
+        @Override
+        public void registerEvents() {
+            registerEvent(
+                e->e.pno instanceof TimedPlaceComponent && e.a == MouseAction.pressed,
+                e->placeClicked(((TimedPlaceComponent) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof TimedTransitionComponent && e.a == MouseAction.pressed,
+                e->transitionClicked(((TimedTransitionComponent) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.entered,
+                e->placetranstionMouseOver(((PlaceTransitionObject) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.exited,
+                e->placetranstionMouseExited(((PlaceTransitionObject) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.moved,
+                e->placetransitionMouseMoved(((PlaceTransitionObject) e.pno), e.e)
+            );
+        }
+
+        private void placetransitionMouseMoved(PlaceTransitionObject pno, MouseEvent e) {
+            if (arc != null) {
+                if (arc.getSource() == pno || !arc.getSource().areNotSameType(pno)) {
+                    //Dispatch event to parent (drawing surface)
+                    e.translatePoint(pno.getX(),pno.getY());
+                    pno.getParent().dispatchEvent(e);
+                }
+            }
+        }
+
+        private void placetranstionMouseExited(PlaceTransitionObject pto) {
+            if (arc != null) {
+                arc.setTarget(null);
+                //XXX this is bad, we have to clean up internal state manually, should be refactored //kyrke - 2019-11-14
+                // Relates to bug #1849786
+                if (pto instanceof Transition) {
+                    ((Transition)pto).removeArcCompareObject(arc);
+                }
+                arc.updateArcPosition();
+            }
+        }
+
+        private void placetranstionMouseOver(PlaceTransitionObject pno) {
+            if (arc != null) {
+                if (arc.getSource() != pno && arc.getSource().areNotSameType(pno)) {
+                    arc.setTarget(pno);
+                    arc.updateArcPosition();
+                }
+            }
+        }
+
+        private void transitionClicked(TimedTransitionComponent pno) {
+            if (place == null && transition == null) {
+                transition = pno;
+                arc = new TimedOutputArcComponent(pno);
+
+                //XXX calling zoomUpdate will set the endpoint to 0,0, drawing the arc from source to 0,0
+                //to avoid this we change the endpoint to set the end point to the same as the end point
+                //needs further refactorings //kyrke 2019-09-05
+                arc.setEndPoint(pno.getPositionX(), pno.getPositionY(), false);
+                CreateGui.getDrawingSurface().addPrototype(arc);
+                arc.requestFocusInWindow();
+                arc.setSelectable(false);
+                arc.enableDrawingKeyBindings(this::clearPendingArc);
+            } else if (place != null && transition == null) {
+                transition = pno;
+                CreateGui.getDrawingSurface().clearAllPrototype();
+                guiModelManager.addTimedInputArc(getModel(), place, transition, arc.getArcPath());
+                clearPendingArc();
+            }
+        }
+
+        private void placeClicked(TimedPlaceComponent pno) {
+            if (place == null && transition == null) {
+                place = pno;
+                arc = new TimedInputArcComponent(pno);
+                //XXX calling zoomUpdate will set the endpoint to 0,0, drawing the arc from source to 0,0
+                //to avoid this we change the endpoint to set the end point to the same as the end point
+                //needs further refactorings //kyrke 2019-09-05
+                arc.setEndPoint(pno.getPositionX(), pno.getPositionY(), false);
+                CreateGui.getDrawingSurface().addPrototype(arc);
+                arc.requestFocusInWindow();
+                arc.setSelectable(false);
+                arc.enableDrawingKeyBindings(this::clearPendingArc);
+            } else if (transition != null && place == null) {
+                place = pno;
+                CreateGui.getDrawingSurface().clearAllPrototype();
+                guiModelManager.addTimedOutputArc(getModel(), transition, place, arc.getArcPath());
+                clearPendingArc();
+            }
+        }
+
+        private void clearPendingArc() {
+            CreateGui.getDrawingSurface().clearAllPrototype();
+            place = null;
+            transition = null;
+            arc = null;
+        }
+
+        @Override
+        public void drawingSurfaceMouseMoved(MouseEvent e) {
+            if(arc!=null) {
+                arc.setEndPoint(e.getX(), e.getY(), e.isShiftDown());
+            }
+        }
+
+        @Override
+        public void drawingSurfaceMousePressed(MouseEvent e) {
+            if (arc!=null) {;
+                Point p = e.getPoint();
+                int x = Zoomer.getUnzoomedValue(p.x, CreateGui.getDrawingSurface().getZoom());
+                int y = Zoomer.getUnzoomedValue(p.y, CreateGui.getDrawingSurface().getZoom());
+
+                boolean shiftDown = e.isShiftDown();
+                //XXX: x,y is ignored is overwritten when mouse is moved, this just add a new point to the end of list
+                arc.getArcPath().addPoint(arc.getArcPath().getEndIndex(), x,y, shiftDown);
+            }
+        }
+
+        @Override
+        public void registerManager(DrawingSurfaceImpl canvas) {
+            CreateGui.useExtendedBounds = true;
+        }
+
+        @Override
+        public void deregisterManager() {
+            clearPendingArc();
+            CreateGui.useExtendedBounds = false;
+        }
+    }
+
 	static class CanvasAnimationController extends AbstractDrawingSurfaceManager {
 
 		private final Animator animator;
@@ -1473,7 +2198,7 @@
 		@Override
 		public void registerEvents() {
 			registerEvent(
-					e -> e.a == MouseAction.clicked && e.pno instanceof TimedTransitionComponent && SwingUtilities.isLeftMouseButton(e.e),
+					e -> e.a == MouseAction.pressed && e.pno instanceof TimedTransitionComponent && SwingUtilities.isLeftMouseButton(e.e),
 					e -> transitionLeftClicked((TimedTransitionComponent)e.pno)
 			);
 			registerEvent(
@@ -1516,13 +2241,205 @@
         //De-register old manager
 		managerRef.get().deregisterManager();
         managerRef.setReference(newManager);
-		managerRef.get().registerManager();
-    }
-
-    //XXX: A quick function made while refactoring to test if the tab is currently
-	// the tab selected, and is allowed to change gui the gui. Should be controlled an other way
-	// /kyrke 2019-11-10
-	public boolean isTabInFocus(){
-		return app.isPresent();
-	}
+		managerRef.get().registerManager(drawingSurface);
+    }
+
+    private final class CanvasTransportarcDrawController extends AbstractDrawingSurfaceManager {
+
+        private TimedTransitionComponent transition;
+        private TimedPlaceComponent place1;
+        private TimedPlaceComponent place2;
+        private Arc arc;
+        private Arc arc1;
+        private Arc arc2;
+
+
+        @Override
+        public void registerEvents() {
+            registerEvent(
+                e->e.pno instanceof TimedPlaceComponent && e.a == MouseAction.pressed,
+                e->placeClicked(((TimedPlaceComponent) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof TimedTransitionComponent && e.a == MouseAction.pressed,
+                e->transitionClicked(((TimedTransitionComponent) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.entered,
+                e->placetranstionMouseOver(((PlaceTransitionObject) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.exited,
+                e->placetranstionMouseExited(((PlaceTransitionObject) e.pno))
+            );
+            registerEvent(
+                e->e.pno instanceof PlaceTransitionObject && e.a == MouseAction.moved,
+                e->placetransitionMouseMoved(((PlaceTransitionObject) e.pno), e.e)
+            );
+        }
+
+        private void placetransitionMouseMoved(PlaceTransitionObject pno, MouseEvent e) {
+            if (arc != null) {
+                if (arc.getSource() == pno || !arc.getSource().areNotSameType(pno)) {
+                    //Dispatch event to parent (drawing surface)
+                    e.translatePoint(pno.getX(),pno.getY());
+                    pno.getParent().dispatchEvent(e);
+                }
+            }
+        }
+
+        private void placetranstionMouseExited(PlaceTransitionObject pto) {
+            if (arc != null) {
+                arc.setTarget(null);
+                //XXX this is bad, we have to clean up internal state manually, should be refactored //kyrke - 2019-11-14
+                // Relates to bug #1849786
+                if (pto instanceof Transition) {
+                    ((Transition)pto).removeArcCompareObject(arc);
+                }
+                arc.updateArcPosition();
+            }
+        }
+
+        private void placetranstionMouseOver(PlaceTransitionObject pno) {
+            if (arc != null) {
+                if (arc.getSource() != pno && arc.getSource().areNotSameType(pno)) {
+                    arc.setTarget(pno);
+                    arc.updateArcPosition();
+                }
+            }
+        }
+
+        private void transitionClicked(TimedTransitionComponent pno) {
+            if (place1 != null && transition == null) {
+                transition = pno;
+                arc2 = arc = new TimedTransportArcComponent(pno, -1, false);
+
+                //XXX calling zoomUpdate will set the endpoint to 0,0, drawing the arc from source to 0,0
+                //to avoid this we change the endpoint to set the end point to the same as the end point
+                //needs further refactorings //kyrke 2019-09-05
+                arc.setEndPoint(pno.getPositionX(), pno.getPositionY(), false);
+                CreateGui.getDrawingSurface().addPrototype(arc);
+                arc.requestFocusInWindow();
+                arc.setSelectable(false);
+                arc.enableDrawingKeyBindings(this::clearPendingArc);
+            }
+        }
+
+        private void placeClicked(TimedPlaceComponent pno) {
+            if (place1 == null && transition == null) {
+                place1 = pno;
+                arc1 = arc = new TimedTransportArcComponent(pno, -1, true);
+                //XXX calling zoomUpdate will set the endpoint to 0,0, drawing the arc from source to 0,0
+                //to avoid this we change the endpoint to set the end point to the same as the end point
+                //needs further refactorings //kyrke 2019-09-05
+                arc.setEndPoint(pno.getPositionX(), pno.getPositionY(), false);
+                CreateGui.getDrawingSurface().addPrototype(arc);
+                arc.requestFocusInWindow();
+                arc.setSelectable(false);
+                arc.enableDrawingKeyBindings(this::clearPendingArc);
+            } else if (transition != null && place2 == null) {
+                place2 = pno;
+                CreateGui.getDrawingSurface().clearAllPrototype();
+                guiModelManager.addTimedTransportArc(getModel(), place1, transition, place2, arc1.getArcPath(), arc2.getArcPath());
+                clearPendingArc();
+            }
+        }
+
+        private void clearPendingArc() {
+            CreateGui.getDrawingSurface().clearAllPrototype();
+            place1 = place2 = null;
+            transition = null;
+            arc = arc1 = arc2 = null;
+        }
+
+        @Override
+        public void drawingSurfaceMouseMoved(MouseEvent e) {
+            if(arc!=null) {
+                arc.setEndPoint(e.getX(), e.getY(), e.isShiftDown());
+            }
+        }
+
+        @Override
+        public void drawingSurfaceMousePressed(MouseEvent e) {
+            if (arc!=null) {
+                Point p = e.getPoint();
+                int x = Zoomer.getUnzoomedValue(p.x, CreateGui.getDrawingSurface().getZoom());
+                int y = Zoomer.getUnzoomedValue(p.y, CreateGui.getDrawingSurface().getZoom());
+
+                boolean shiftDown = e.isShiftDown();
+                //XXX: x,y is ignored is overwritten when mouse is moved, this just add a new point to the end of list
+                arc.getArcPath().addPoint(arc.getArcPath().getEndIndex(), x,y, shiftDown);
+            }
+        }
+
+        @Override
+        public void registerManager(DrawingSurfaceImpl canvas) {
+            CreateGui.useExtendedBounds = true;
+        }
+
+        @Override
+        public void deregisterManager() {
+            clearPendingArc();
+            CreateGui.useExtendedBounds = false;
+        }
+    }
+
+    private class CanvasGeneralDrawController extends AbstractDrawingSurfaceManager {
+        @Override
+        public void registerEvents() {
+            registerEvent(
+                e->e.pno instanceof TimedTransitionComponent && e.a == MouseAction.doubleClicked,
+                e-> ((TimedTransitionComponent) e.pno).showEditor()
+            );
+            registerEvent(
+                e->e.pno instanceof TimedPlaceComponent && e.a == MouseAction.doubleClicked,
+                e-> ((TimedPlaceComponent) e.pno).showEditor()
+            );
+            registerEvent(
+                e->e.pno instanceof TimedTransitionComponent && e.a == MouseAction.rightClicked,
+                e-> ((TimedTransitionComponent) e.pno).getMouseHandler().getPopup(e.e).show(e.pno, e.e.getX(), e.e.getY())
+            );
+            registerEvent(
+                e->e.pno instanceof TimedPlaceComponent && e.a == MouseAction.rightClicked,
+                e-> ((TimedPlaceComponent) e.pno).getMouseHandler().getPopup(e.e).show(e.pno, e.e.getX(), e.e.getY())
+            );
+            registerEvent(
+                e->e.pno instanceof Arc && e.a == MouseAction.rightClicked,
+                e-> ((Arc) e.pno).getMouseHandler().getPopup(e.e).show(e.pno, e.e.getX(), e.e.getY())
+            );
+            registerEvent(
+                e->e.pno instanceof AnnotationNote && e.a == MouseAction.doubleClicked,
+                e-> ((AnnotationNote) e.pno).enableEditMode()
+            );
+            registerEvent(
+                e->e.pno instanceof AnnotationNote && e.a == MouseAction.rightClicked,
+                e-> ((AnnotationNote) e.pno).getMouseHandler().getPopup(e.e).show(e.pno, e.e.getX(), e.e.getY())
+            );
+            registerEvent(
+                e->e.pno instanceof Arc && e.a == MouseAction.entered,
+                e -> ((Arc)e.pno).getArcPath().showPoints()
+            );
+            registerEvent(
+                e->e.pno instanceof Arc && e.a == MouseAction.exited,
+                e -> ((Arc)e.pno).getArcPath().hidePoints()
+            );
+            registerEvent(
+                e->e.pno instanceof Arc && e.a == MouseAction.doubleClicked && e.e.isControlDown(),
+                e->arcDoubleClickedWithContrl(((Arc) e.pno), e.e)
+            );
+
+        }
+
+        private void arcDoubleClickedWithContrl(Arc arc, MouseEvent e) {
+            CreateGui.getCurrentTab().getUndoManager().addNewEdit(
+                arc.getArcPath().insertPoint(
+                    new Point2D.Double(
+                        Zoomer.getUnzoomedValue(arc.getX() + e.getX(), arc.getZoom()),
+                        Zoomer.getUnzoomedValue(arc.getY() + e.getY(), arc.getZoom())
+                    ),
+                    e.isAltDown()
+                )
+            );
+        }
+    }
 }
 
=== modified file 'src/dk/aau/cs/gui/TemplateExplorer.java'
--- src/dk/aau/cs/gui/TemplateExplorer.java	2020-05-27 13:15:44 +0000
+++ src/dk/aau/cs/gui/TemplateExplorer.java	2020-07-09 12:55:48 +0000
@@ -81,12 +81,12 @@
 	private JButton renameButton;
 	private JButton copyButton;
 
-	private TabContent parent;
-	private UndoManager undoManager;
+	private final TabContent parent;
+	private final UndoManager undoManager;
 	private boolean isInAnimationMode;
 
-	public JButton moveUpButton;
-	public JButton moveDownButton;
+	private JButton moveUpButton;
+	private JButton moveDownButton;
 	private JButton sortButton;
 	
 	private static final String toolTipNewComponent ="Create a new component";
@@ -188,7 +188,7 @@
 
 	private void initExplorerPanel() {
 		templatePanel = new JPanel(new GridBagLayout());
-		listModel = new DefaultListModel();
+		listModel = new DefaultListModel<>();
 		for (Template net : parent.allTemplates()) {
 			listModel.addElement(net);
 		}
@@ -214,7 +214,7 @@
 			}
 		});
 
-		templateList = new NonsearchableJList(listModel);
+		templateList = new NonsearchableJList<>(listModel);
 
 		templateList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 		templateList.setSelectedIndex(0);
@@ -476,7 +476,7 @@
 	private void onOKRenameTemplate() {		
 		Template template = selectedModel();			
 		String newName = nameTextField.getText().trim();
-		if (newName == null || template.model().name().equals(newName)) {
+		if (template.model().name().equals(newName)) {
 			exit();
 			return;
 		}
@@ -508,37 +508,34 @@
 	}
 	
 	private void onOK() {
-		Template template = null;		
-		String templateName = nameTextField.getText().trim();		
-		if (templateName != null) {
-			if(!isNameAllowed(templateName)) {
-				JOptionPane.showMessageDialog(parent.drawingSurface(),
-						"Acceptable names for components are defined by the regular expression:\n[a-zA-Z][_a-zA-Z0-9]*\n\nThe new component could not be created.",
-						"Error Creating Component",
-						JOptionPane.ERROR_MESSAGE);
-				exit();
-				ShowNewTemplateDialog(templateName);
-				return;
-			}
-			else if (parent.network().hasTAPNCalled(templateName)) {
-				JOptionPane.showMessageDialog(parent.drawingSurface(),
-						"A component named \"" + templateName + "\" already exists.\n\nThe new component could not be created.",
-						"Error Creating Component",
-						JOptionPane.ERROR_MESSAGE);
-				exit();
-				ShowNewTemplateDialog(templateName);
-				return;
-			}
-			else {
-				template = createNewTemplate(templateName);
-
-				int index = listModel.size();
-				undoManager.addNewEdit(new AddTemplateCommand(TemplateExplorer.this, template, index));
-				parent.addTemplate(template);
-			}
-		}
-
-		exit();
+        String templateName = nameTextField.getText().trim();
+        if(!isNameAllowed(templateName)) {
+            JOptionPane.showMessageDialog(parent.drawingSurface(),
+                    "Acceptable names for components are defined by the regular expression:\n[a-zA-Z][_a-zA-Z0-9]*\n\nThe new component could not be created.",
+                    "Error Creating Component",
+                    JOptionPane.ERROR_MESSAGE);
+            exit();
+            ShowNewTemplateDialog(templateName);
+            return;
+        }
+        else if (parent.network().hasTAPNCalled(templateName)) {
+            JOptionPane.showMessageDialog(parent.drawingSurface(),
+                    "A component named \"" + templateName + "\" already exists.\n\nThe new component could not be created.",
+                    "Error Creating Component",
+                    JOptionPane.ERROR_MESSAGE);
+            exit();
+            ShowNewTemplateDialog(templateName);
+            return;
+        }
+        else {
+            Template template = createNewTemplate(templateName);
+
+            int index = listModel.size();
+            undoManager.addNewEdit(new AddTemplateCommand(TemplateExplorer.this, template, index));
+            parent.addTemplate(template);
+        }
+
+        exit();
 	}
 	
 	private void exit() {
@@ -639,8 +636,7 @@
 	}
 
 	private void ShowNewTemplateDialog(String nameToShow) {
-		dialog = new EscapableDialog(CreateGui.getApp(),
-				"Enter Component Name", true);
+		dialog = new EscapableDialog(CreateGui.getApp(), "Enter Component Name", true);
 		initComponentsOfNewTemplateDialog(nameToShow);
 		dialog.add(container);
 		dialog.setResizable(false);
@@ -742,8 +738,7 @@
 	}
 
 	private void showRenameTemplateDialog(String nameToShow) {		
-		dialog = new EscapableDialog(CreateGui.getApp(),
-				"Enter Component Name", true);
+		dialog = new EscapableDialog(CreateGui.getApp(), "Enter Component Name", true);
 		Template template = selectedModel();
 		if (nameToShow.equals("")){
 			initComponentsOfRenameTemplateDialog(template.model().name());
@@ -777,7 +772,7 @@
 
 	public void openSelectedTemplate() {
 		Template tapn = selectedModel();
-		if (tapn != null && parent.isTabInFocus()) {
+		if (tapn != null) {
 			parent.changeToTemplate(tapn);
 		}
 		//parent.drawingSurface().repaintAll();
@@ -789,7 +784,7 @@
 
 	public void updateTemplateList() {
 		int selectedIndex = templateList.getSelectedIndex();
-		DefaultListModel newList = new DefaultListModel();
+		DefaultListModel<Template> newList = new DefaultListModel<>();
 		
 		if(isInAnimationMode) {
 			for (Template net : parent.activeTemplates()) {
@@ -852,7 +847,7 @@
         listModel.setElementAt(o, index+1);
     }
     @Override
-    public JList getJList(){
+    public JList<Template> getJList(){
 	    return templateList;
     }
 
@@ -995,21 +990,24 @@
 						}
 						renameButton.setEnabled(true);
 						copyButton.setEnabled(true);
-						if(templateList.getModel().getSize() >= 2)
-							sortButton.setEnabled(true);
-						else
-							sortButton.setEnabled(false);
-						
-						if(index > 0)
-							moveUpButton.setEnabled(true);
-						else
-							moveUpButton.setEnabled(false);
+						if(templateList.getModel().getSize() >= 2) {
+                            sortButton.setEnabled(true);
+                        } else {
+                            sortButton.setEnabled(false);
+                        }
+
+						if(index > 0) {
+                            moveUpButton.setEnabled(true);
+                        } else {
+                            moveUpButton.setEnabled(false);
+                        }
 								
 							
-						if(index < parent.network().allTemplates().size() - 1)
-							moveDownButton.setEnabled(true);
-						else
-							moveDownButton.setEnabled(false);
+						if(index < parent.network().allTemplates().size() - 1) {
+                            moveDownButton.setEnabled(true);
+                        } else {
+                            moveDownButton.setEnabled(false);
+                        }
 					}
 					templateList.ensureIndexIsVisible(index);
 					openSelectedTemplate();
 
=== modified file 'src/dk/aau/cs/gui/components/EnabledTransitionsList.java'
--- src/dk/aau/cs/gui/components/EnabledTransitionsList.java	2020-05-18 08:14:37 +0000
+++ src/dk/aau/cs/gui/components/EnabledTransitionsList.java	2020-07-09 12:55:48 +0000
@@ -38,17 +38,14 @@
 		initPanel();
 	}
 
-	DefaultListModel<TransitionListItem> transitions;
-	JList<TransitionListItem> transitionsList;
-	JScrollPane scrollPane;
+	final DefaultListModel<TransitionListItem> transitions = new DefaultListModel<>();
+	final JList<TransitionListItem> transitionsList = new JList<>(transitions);
+	final JScrollPane scrollPane = new JScrollPane(transitionsList);
 	TransitionListItem lastSelected;
 
 	public void initPanel(){
-		transitions = new DefaultListModel<>();
-		transitionsList = new JList<>(transitions);
-		transitionsList.setCellRenderer(new EnabledTransitionListCellRenderer());
 
-		transitionsList.addMouseListener(new MouseAdapter() {
+        transitionsList.addMouseListener(new MouseAdapter() {
 			@Override
 			public void mouseClicked(MouseEvent e) {
 				if(e.getClickCount() == 2){
@@ -64,9 +61,7 @@
 			}
 		});
 
-		scrollPane = new JScrollPane(transitionsList);
-
-		this.add(scrollPane, BorderLayout.CENTER);
+        this.add(scrollPane, BorderLayout.CENTER);
 	}
 	
 	public void startReInit(){
@@ -110,18 +105,12 @@
 	public void addTransition(Template template, Transition transition){
 		TransitionListItem item = new TransitionListItem(transition, template);
 
-		transition.isDelayEnabled();
 		if(!transitions.contains(item)){
 			transitions.addElement(item);
 		}
 	}
 
-	public void removeTransition(Template template, Transition transition){
-		TransitionListItem item = new TransitionListItem(transition, template);
-		transitions.removeElement(item);
-	}
-
-	public void fireSelectedTransition(){
+    public void fireSelectedTransition(){
 		TransitionListItem item = transitionsList.getSelectedValue();
 
 		if(item != null) {
@@ -131,27 +120,10 @@
 
 	interface ListItem extends Comparable<ListItem>{}
 
-	class SplitterListItem implements ListItem{
-
-		@Override
-		public int compareTo(ListItem o) {
-			if(o instanceof TransitionListItem){
-				return o.compareTo(this);
-			} else {
-				return 0;
-			}
-		}
-
-		@Override
-		public String toString() {
-			return "_";
-		}
-
-	}
 
 	static class TransitionListItem implements ListItem{
-		private Transition transition;
-		private Template template;
+		private final Transition transition;
+		private final Template template;
 
 		public TransitionListItem(Transition transition, Template template){
 			this.transition = transition;
@@ -160,8 +132,7 @@
 
 		public String toString(boolean showIntervals) {
 
-			String interval = transition.getDInterval() == null || !showIntervals ? 
-					"" : transition.getDInterval().toString() + " ";
+			String interval = transition.getDInterval() == null || !showIntervals ? "" : transition.getDInterval().toString() + " ";
 			
 			String transitionName = getTransition().getName(); 
 			if(isShared()){
@@ -237,51 +208,6 @@
 		}
 	}
 
-	//This class creates the stippled line shown between the enabled transitions and the delay-enabled transitions
-	class EnabledTransitionListCellRenderer extends DefaultListCellRenderer{
-
-		@Override
-		public Component getListCellRendererComponent(JList list, Object value,
-				int index, boolean isSelected, boolean cellHasFocus) {
-			if(value instanceof SplitterListItem){
-				JLabel separator = new JLabel();
-				separator.setBorder(new DashBorder());
-				separator.setPreferredSize(new Dimension(1, 1));
-				return separator;
-			} else {
-				return super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-			}
-		}
-
-		class DashBorder implements Border {
-			private final Insets	insets	= new Insets(1, 1, 1, 1);
-			private final int	 length	= 5;
-			private final int	 space	= 3;
-			public boolean isBorderOpaque() {
-				return false;
-			}
-			public void paintBorder(Component c, Graphics g, int x, int y,
-					int width, int height) {
-				g.setColor(Color.BLACK);
-				// --- draw horizontal ---
-				for (int i = 0; i < width; i += length) {
-					g.drawLine(i, y, i + length, y);
-					g.drawLine(i, height - 1, i + length, height - 1);
-					i += space;
-				}
-				// --- draw vertical ---
-				for (int i = 0; i < height; i += length) {
-					g.drawLine(0, i, 0, i + length);
-					g.drawLine(width - 1, i, width - 1, i + length);
-					i += space;
-				}
-			}
-			public Insets getBorderInsets(Component c) {
-				return insets;
-			}
-		}
-	}
-
 	public int getNumberOfTransitions() {
 		return transitions.size();
 	}
 
=== modified file 'src/dk/aau/cs/gui/components/NonsearchableJList.java'
--- src/dk/aau/cs/gui/components/NonsearchableJList.java	2020-04-18 12:27:02 +0000
+++ src/dk/aau/cs/gui/components/NonsearchableJList.java	2020-07-09 12:55:48 +0000
@@ -19,7 +19,7 @@
 		removeKeyListener();
 	}
 
-	public NonsearchableJList(ListModel dataModel){
+	public NonsearchableJList(ListModel<E> dataModel){
 		super (dataModel);
 		removeKeyListener();
 	}
 
=== modified file 'src/dk/aau/cs/gui/components/TransitionFireingComponent.java'
--- src/dk/aau/cs/gui/components/TransitionFireingComponent.java	2020-05-18 14:10:47 +0000
+++ src/dk/aau/cs/gui/components/TransitionFireingComponent.java	2020-07-09 12:55:48 +0000
@@ -28,14 +28,19 @@
 
 		enabledTransitionsList = new EnabledTransitionsList();
 
-		this.setBorder(BorderFactory.createCompoundBorder(
+		this.setBorder(
+		    BorderFactory.createCompoundBorder(
 				BorderFactory.createTitledBorder("Enabled Transitions"),
-				BorderFactory.createEmptyBorder(3, 3, 3, 3)));
-		this
-		.setToolTipText("List of currently enabled transitions (double click a transition to fire it)");
-		enabledTransitionsList.setPreferredSize(new Dimension(
+				BorderFactory.createEmptyBorder(3, 3, 3, 3)
+            )
+        );
+		this.setToolTipText("List of currently enabled transitions (double click a transition to fire it)");
+		enabledTransitionsList.setPreferredSize(
+		    new Dimension(
 				enabledTransitionsList.getPreferredSize().width,
-				enabledTransitionsList.getMinimumSize().height));
+				enabledTransitionsList.getMinimumSize().height
+            )
+        );
 
 		settingsButton = new JButton("Settings");
 		settingsButton.setPreferredSize(new Dimension(0, settingsButton.getPreferredSize().height)); //Make the two buttons equal in size
@@ -50,6 +55,7 @@
 				fireSelectedTransition();
 			}
 		});
+
 		fireButton.addKeyListener(new KeyAdapter() {			
 			@Override
 			public void keyPressed(KeyEvent e) {
 
=== modified file 'src/dk/aau/cs/gui/smartDraw/SmartDrawWorker.java'
--- src/dk/aau/cs/gui/smartDraw/SmartDrawWorker.java	2020-05-23 12:57:37 +0000
+++ src/dk/aau/cs/gui/smartDraw/SmartDrawWorker.java	2020-07-09 12:55:48 +0000
@@ -2,7 +2,6 @@
 
 import java.awt.Point;
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Random;
 
@@ -199,19 +198,16 @@
 		}
 	}
 	
-	private ArrayList<Arc> getAllArcsFromObject(PlaceTransitionObject object) {
+	private ArrayList<Arc> getAllArcsFromObject(PlaceTransitionObject pno) {
 		ArrayList<Arc> arcsForObject = new ArrayList<Arc>();
-		Iterator<Arc> fromIterator = object.getConnectFromIterator();
-		Iterator<Arc> toIterator = object.getConnectToIterator();
-		Arc arc;
-		while(fromIterator.hasNext()) {
-			arc = fromIterator.next();
-			arcsForObject.add(arc);
-		}
-		while(toIterator.hasNext()) {
-			arc = toIterator.next();
-			arcsForObject.add(arc);
-		}
+
+        for (Arc a : pno.getPreset()) {
+            arcsForObject.add(a);
+        }
+        for (Arc a : pno.getPostset()) {
+            arcsForObject.add(a);
+        }
+
 		return arcsForObject;
 	}
 	private void moveObject(PlaceTransitionObject object, Point point) {
 
=== modified file 'src/dk/aau/cs/gui/undo/TimedPlaceMarkingEdit.java'
--- src/dk/aau/cs/gui/undo/TimedPlaceMarkingEdit.java	2011-09-23 21:23:31 +0000
+++ src/dk/aau/cs/gui/undo/TimedPlaceMarkingEdit.java	2020-07-09 12:55:48 +0000
@@ -4,7 +4,7 @@
 
 // TODO: Fix this to work on the model class instead of the GUI class
 public class TimedPlaceMarkingEdit extends Command {
-	private int numberOfTokens;
+	private final int numberOfTokens;
 	private final TimedPlaceComponent timedPlaceComponent;
 
 	public TimedPlaceMarkingEdit(TimedPlaceComponent tpc, int numberOfTokens) {
@@ -15,9 +15,9 @@
 	@Override
 	public void redo() {
 		if (numberOfTokens > 0) {
-			timedPlaceComponent.addTokens(Math.abs(numberOfTokens));
+			timedPlaceComponent.underlyingPlace().addTokens(Math.abs(numberOfTokens));
 		} else {
-			timedPlaceComponent.removeTokens(Math.abs(numberOfTokens));
+			timedPlaceComponent.underlyingPlace().removeTokens(Math.abs(numberOfTokens));
 		}
 		timedPlaceComponent.repaint();
 	}
@@ -25,9 +25,9 @@
 	@Override
 	public void undo() {
 		if (numberOfTokens > 0) {
-			timedPlaceComponent.removeTokens(Math.abs(numberOfTokens));
+			timedPlaceComponent.underlyingPlace().removeTokens(Math.abs(numberOfTokens));
 		} else {
-			timedPlaceComponent.addTokens(Math.abs(numberOfTokens));
+			timedPlaceComponent.underlyingPlace().addTokens(Math.abs(numberOfTokens));
 		}
 		timedPlaceComponent.repaint();
 	}
 
=== modified file 'src/dk/aau/cs/io/TapnXmlLoader.java'
--- src/dk/aau/cs/io/TapnXmlLoader.java	2020-05-06 15:19:14 +0000
+++ src/dk/aau/cs/io/TapnXmlLoader.java	2020-07-09 12:55:48 +0000
@@ -162,10 +162,9 @@
 		}
 		
 		SharedPlace place = new SharedPlace(name, invariant);
+        place.addTokens(numberOfTokens);
 		place.setCurrentMarking(marking);
-		for(int j = 0; j < numberOfTokens; j++){
-			marking.add(new TimedToken(place));
-		}
+
 		return place;
 	}
 
 
=== modified file 'src/dk/aau/cs/model/tapn/LocalTimedPlace.java'
--- src/dk/aau/cs/model/tapn/LocalTimedPlace.java	2019-11-26 13:59:12 +0000
+++ src/dk/aau/cs/model/tapn/LocalTimedPlace.java	2020-07-09 12:55:48 +0000
@@ -1,28 +1,12 @@
 package dk.aau.cs.model.tapn;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Pattern;
-
-import dk.aau.cs.model.tapn.TimedPlace.PlaceType;
-import dk.aau.cs.model.tapn.event.TimedPlaceEvent;
-import dk.aau.cs.model.tapn.event.TimedPlaceListener;
-import dk.aau.cs.util.Require;
 import dk.aau.cs.util.Tuple;
 
 public class LocalTimedPlace  extends TimedPlace {
-	private static final Pattern namePattern = Pattern.compile("^[a-zA-Z_][a-zA-Z0-9_]*$");
-
-	private String name;
-	private TimeInvariant invariant;
 
 	private TimedArcPetriNet model;
-	private TimedMarking currentMarking;
-	private List<TimedPlaceListener> listeners = new ArrayList<TimedPlaceListener>();
-	
-	private Tuple<PlaceType, Integer> extrapolation = new Tuple<TimedPlace.PlaceType, Integer>(PlaceType.Dead, -2);
 
-	public LocalTimedPlace(String name) {
+    public LocalTimedPlace(String name) {
 		this(name, TimeInvariant.LESS_THAN_INFINITY);
 	}
 
@@ -39,111 +23,10 @@
 		this.model = model;
 	}
 
-	public void addTimedPlaceListener(TimedPlaceListener listener){
-		Require.that(listener != null, "Listener cannot be null");
-		listeners.add(listener);
-	}
-
-	public void removeTimedPlaceListener(TimedPlaceListener listener){
-		Require.that(listener != null, "Listener cannot be null");
-		listeners.remove(listener);
-	}
-
 	public boolean isShared() {
 		return false;
 	}
 
-	public void setCurrentMarking(TimedMarking marking) {
-		Require.that(marking != null, "marking cannot be null");
-		currentMarking = marking;
-		fireMarkingChanged();
-	}
-
-	public String name() {
-		return name;
-	}
-
-	public void setName(String newName) {
-		Require.that(newName != null && !newName.isEmpty(), "A timed place must have a name");
-		Require.that(isValid(newName) && !newName.toLowerCase().equals("true") && !newName.toLowerCase().equals("false"), "The specified name must conform to the pattern [a-zA-Z_][a-zA-Z0-9_]*");
-		this.name = newName;
-		fireNameChanged();
-	}
-
-	private void fireNameChanged() {
-		for(TimedPlaceListener listener : listeners){
-			listener.nameChanged(new TimedPlaceEvent(this));
-		}
-	}
-		
-	private void fireInvariantChanged(){
-		for(TimedPlaceListener listener : listeners){
-			listener.invariantChanged(new TimedPlaceEvent(this));
-		}
-	}
-	
-	private void fireMarkingChanged(){
-		for(TimedPlaceListener listener : listeners){
-			listener.markingChanged(new TimedPlaceEvent(this));
-		}
-	}
-	
-	private boolean isValid(String newName) {
-		return namePattern.matcher(newName).matches();
-	}
-
-	public TimeInvariant invariant() {
-		return invariant;
-	}
-
-	public void setInvariant(TimeInvariant invariant) {
-		Require.that(invariant != null, "A timed place must have a non-null invariant");
-		this.invariant = invariant;
-		fireInvariantChanged();
-	}
-
-	public List<TimedToken> tokens() {
-		return currentMarking.getTokensFor(this);
-	}
-
-	public int numberOfTokens() {
-		return tokens().size();
-	}
-
-	@Override
-	public void addToken(TimedToken timedToken) {
-		Require.that(timedToken != null, "timedToken cannot be null");
-		Require.that(timedToken.place().equals(this), "token is located in a different place");
-		
-		currentMarking.add(timedToken);
-		fireMarkingChanged();
-	}
-
-	@Override
-	public void addTokens(Iterable<TimedToken> tokens) {
-		Require.that(tokens != null, "tokens cannot be null");
-		
-		for(TimedToken token : tokens){
-			currentMarking.add(token); // avoid firing marking changed on every add
-		}
-		fireMarkingChanged();
-	}
-
-	@Override
-	public void removeToken(TimedToken timedToken) {
-		Require.that(timedToken != null, "timedToken cannot be null");
-		currentMarking.remove(timedToken);
-		fireMarkingChanged();
-	}
-
-	@Override
-	public void removeToken() {
-		if (numberOfTokens() > 0) {
-			currentMarking.remove(tokens().get(0));
-			fireMarkingChanged();
-		}
-	}
-
 	public LocalTimedPlace copy() {
 		LocalTimedPlace p = new LocalTimedPlace(name);
 
 
=== modified file 'src/dk/aau/cs/model/tapn/NetworkMarking.java'
--- src/dk/aau/cs/model/tapn/NetworkMarking.java	2020-05-23 13:29:16 +0000
+++ src/dk/aau/cs/model/tapn/NetworkMarking.java	2020-07-09 12:55:48 +0000
@@ -14,8 +14,8 @@
 import dk.aau.cs.util.Tuple;
 
 public class NetworkMarking implements TimedMarking {
-	private HashMap<TimedArcPetriNet, LocalTimedMarking> markings = new HashMap<TimedArcPetriNet, LocalTimedMarking>();
-	private HashMap<TimedPlace, List<TimedToken>> sharedPlacesTokens = new HashMap<TimedPlace, List<TimedToken>>();
+	private final HashMap<TimedArcPetriNet, LocalTimedMarking> markings = new HashMap<TimedArcPetriNet, LocalTimedMarking>();
+	private final HashMap<TimedPlace, List<TimedToken>> sharedPlacesTokens = new HashMap<TimedPlace, List<TimedToken>>();
 
 	public NetworkMarking() {
 	}
@@ -130,8 +130,9 @@
 	private Tuple<NetworkMarking, List<TimedToken>> fireSharedTransition(SharedTransition sharedTransition, FiringMode firingMode) {
 		// validity of arguments already checked above
 		NetworkMarking clone = clone();
-                Tuple<LocalTimedMarking, List<TimedToken>> ltm;
-                List<TimedToken> consumedTokens = new ArrayList<TimedToken>();
+		Tuple<LocalTimedMarking, List<TimedToken>> ltm;
+		List<TimedToken> consumedTokens = new ArrayList<TimedToken>();
+
 		for(TimedTransition transition : sharedTransition.transitions()){
 			if(transition.model().isActive()) {
 				ltm = clone.getMarkingFor(transition.model()).fireTransition(transition, firingMode);
 
=== modified file 'src/dk/aau/cs/model/tapn/SharedPlace.java'
--- src/dk/aau/cs/model/tapn/SharedPlace.java	2020-06-03 18:20:30 +0000
+++ src/dk/aau/cs/model/tapn/SharedPlace.java	2020-07-09 12:55:48 +0000
@@ -1,30 +1,16 @@
 package dk.aau.cs.model.tapn;
 
 import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Pattern;
 
 import pipe.dataLayer.Template;
 import pipe.gui.CreateGui;
-import dk.aau.cs.model.tapn.event.TimedPlaceEvent;
-import dk.aau.cs.model.tapn.event.TimedPlaceListener;
-import dk.aau.cs.util.Require;
 import dk.aau.cs.util.Tuple;
 
 public class SharedPlace extends TimedPlace{
-	private static final Pattern namePattern = Pattern.compile("^[a-zA-Z_][a-zA-Z0-9_]*$");
-	
-	private String name;
-    private List<TimedPlace> places = new ArrayList<TimedPlace>();
-    private TimeInvariant invariant;
-
-	private TimedArcPetriNetNetwork network;
-	private TimedMarking currentMarking;
-	private Tuple<PlaceType, Integer> extrapolation = new Tuple<TimedPlace.PlaceType, Integer>(PlaceType.Dead, -2);
-	
-	private List<TimedPlaceListener> listeners = new ArrayList<TimedPlaceListener>();
-
-	public SharedPlace(String name){
+
+    private TimedArcPetriNetNetwork network;
+
+    public SharedPlace(String name){
 		this(name, TimeInvariant.LESS_THAN_INFINITY);
 	}
 	
@@ -32,33 +18,8 @@
 		setName(name);
 		setInvariant(invariant);
 	}
-	
-	public String name() {
-		return name;
-	}
-	
-	public void setName(String newName) {
-		Require.that(newName != null && !newName.isEmpty(), "A timed transition must have a name");
-		Require.that(isValid(newName) && !newName.toLowerCase().equals("true") && !newName.toLowerCase().equals("false"), "The specified name must conform to the pattern [a-zA-Z_][a-zA-Z0-9_]*");
-		name = newName;
-		fireNameChanged();
-	}
-	
-	private boolean isValid(String newName) {
-		return namePattern.matcher(newName).matches();
-	}
-
-	public TimeInvariant invariant(){
-		return invariant;
-	}
-	
-	public void setInvariant(TimeInvariant invariant) {
-		Require.that(invariant != null, "invariant must not be null");
-		this.invariant = invariant;
-		fireInvariantChanged();
-	}
-
-	public void setNetwork(TimedArcPetriNetNetwork network) {
+
+    public void setNetwork(TimedArcPetriNetNetwork network) {
 		this.network = network;		
 	}
 	
@@ -66,15 +27,7 @@
 		return network;
 	}
 	
-	public void addTimedPlaceListener(TimedPlaceListener listener) {
-		Require.that(listener != null, "Listener cannot be null");
-		listeners.add(listener);
-	}
 
-	public void removeTimedPlaceListener(TimedPlaceListener listener) {
-		Require.that(listener != null, "Listener cannot be null");
-		listeners.remove(listener);
-	}
 
 	public TimedPlace copy() {
 		return new SharedPlace(this.name(), this.invariant().copy());
@@ -84,71 +37,6 @@
 		return true;
 	}
 
-	public void setCurrentMarking(TimedMarking marking) {
-		Require.that(marking != null, "marking cannot be null");
-		currentMarking = marking;
-		fireMarkingChanged();
-	}
-
-	@Override
-	public void addToken(TimedToken timedToken) {
-		Require.that(timedToken != null, "timedToken cannot be null");
-		Require.that(timedToken.place().equals(this), "token is located in a different place");
-		
-		currentMarking.add(timedToken);
-		fireMarkingChanged();
-	}
-
-	@Override
-	public void addTokens(Iterable<TimedToken> tokens) {
-		Require.that(tokens != null, "tokens cannot be null"); // TODO: maybe check that tokens are in this place?
-		
-		for(TimedToken token : tokens){
-			currentMarking.add(token); // avoid firing marking changed on every add
-		}
-		fireMarkingChanged();
-	}
-
-	@Override
-	public void removeToken(TimedToken timedToken) {
-		Require.that(timedToken != null, "timedToken cannot be null");
-		currentMarking.remove(timedToken);
-		fireMarkingChanged();
-	}
-
-	@Override
-	public void removeToken() {
-		if (numberOfTokens() > 0) {
-			currentMarking.remove(tokens().get(0));
-			fireMarkingChanged();
-		}
-	}
-
-	public List<TimedToken> tokens() {
-		return currentMarking.getTokensFor(this);
-	}	
-
-	public int numberOfTokens() {
-		return tokens().size();
-	}
-	
-	private void fireMarkingChanged() {
-		for(TimedPlaceListener listener : listeners){
-			listener.markingChanged(new TimedPlaceEvent(this));
-		}
-	}
-	
-	private void fireNameChanged() {
-		for(TimedPlaceListener listener : listeners){
-			listener.nameChanged(new TimedPlaceEvent(this));
-		}
-	}
-
-	private void fireInvariantChanged() {
-		for(TimedPlaceListener listener : listeners){
-			listener.invariantChanged(new TimedPlaceEvent(this));
-		}
-	}
 	
 	public ArrayList<String> getComponentsUsingThisPlace(){
 		ArrayList<String> components = new ArrayList<String>();
@@ -214,8 +102,4 @@
 		
 		return new Tuple<TimedPlace.PlaceType, Integer>(type, cmax);
 	}
-
-	public List<TimedPlace> getPlaces() {
-	    return places;
-    }
 }
 
=== modified file 'src/dk/aau/cs/model/tapn/TimedArcPetriNet.java'
--- src/dk/aau/cs/model/tapn/TimedArcPetriNet.java	2020-06-03 12:16:19 +0000
+++ src/dk/aau/cs/model/tapn/TimedArcPetriNet.java	2020-07-09 12:55:48 +0000
@@ -18,18 +18,17 @@
 	//This is used when loading big nets as the checking  of names is slow.
 	private boolean checkNames = true; 
 
-	private List<TimedPlace> places = new ArrayList<TimedPlace>();
-	private List<TimedTransition> transitions = new ArrayList<TimedTransition>();
-	private List<TimedInputArc> inputArcs = new ArrayList<TimedInputArc>();
-	private List<TimedOutputArc> outputArcs = new ArrayList<TimedOutputArc>();
-	private List<TimedInhibitorArc> inhibitorArcs = new ArrayList<TimedInhibitorArc>();
-	private List<TransportArc> transportArcs = new ArrayList<TransportArc>();
+	private final List<TimedPlace> places = new ArrayList<TimedPlace>();
+	private final List<TimedTransition> transitions = new ArrayList<TimedTransition>();
+	private final List<TimedInputArc> inputArcs = new ArrayList<TimedInputArc>();
+	private final List<TimedOutputArc> outputArcs = new ArrayList<TimedOutputArc>();
+	private final List<TimedInhibitorArc> inhibitorArcs = new ArrayList<TimedInhibitorArc>();
+	private final List<TransportArc> transportArcs = new ArrayList<TransportArc>();
 
-	private TimedMarking currentMarking;
+	private TimedMarking currentMarking = new LocalTimedMarking();
 
 	public TimedArcPetriNet(String name) {
 		setName(name);
-		setMarking(new LocalTimedMarking());
 		isActive = true;
 	}
 
@@ -127,11 +126,7 @@
 		currentMarking.add(token);
 	}
 
-	public void removeToken(TimedToken token) {
-		currentMarking.remove(token);
-	}
-
-	public void remove(TimedPlace place) {
+    public void remove(TimedPlace place) {
 		boolean removed = places.remove(place);
 		if (removed && !place.isShared()){
 			currentMarking.removePlaceFromMarking(place);
 
=== modified file 'src/dk/aau/cs/model/tapn/TimedArcPetriNetNetwork.java'
--- src/dk/aau/cs/model/tapn/TimedArcPetriNetNetwork.java	2019-03-22 13:57:03 +0000
+++ src/dk/aau/cs/model/tapn/TimedArcPetriNetNetwork.java	2020-07-09 12:55:48 +0000
@@ -15,16 +15,16 @@
 import dk.aau.cs.verification.TAPNComposer;
 
 public class TimedArcPetriNetNetwork {
-	private List<TimedArcPetriNet> tapns = new ArrayList<TimedArcPetriNet>();
-	private List<SharedPlace> sharedPlaces = new ArrayList<SharedPlace>();
-	private List<SharedTransition> sharedTransitions = new ArrayList<SharedTransition>();
+	private final List<TimedArcPetriNet> tapns = new ArrayList<TimedArcPetriNet>();
+	private final List<SharedPlace> sharedPlaces = new ArrayList<SharedPlace>();
+	private final List<SharedTransition> sharedTransitions = new ArrayList<SharedTransition>();
 	
-	private NetworkMarking currentMarking;
-	private ConstantStore constants;
+	private NetworkMarking currentMarking = new NetworkMarking();
+	private final ConstantStore constants;
 	
 	private int defaultBound = 3;
 	
-	private List<ConstantsListener> constantsListeners = new ArrayList<ConstantsListener>();
+	private final List<ConstantsListener> constantsListeners = new ArrayList<ConstantsListener>();
 	
 	private boolean paintNet = true;
 	
@@ -34,8 +34,7 @@
 	
 	public TimedArcPetriNetNetwork(ConstantStore constants){
 		this.constants = constants;
-		currentMarking = new NetworkMarking();
-		buildConstraints();
+        buildConstraints();
 	}
 	
 	public void addConstantsListener(ConstantsListener listener){
 
=== modified file 'src/dk/aau/cs/model/tapn/TimedInhibitorArc.java'
--- src/dk/aau/cs/model/tapn/TimedInhibitorArc.java	2012-09-19 18:15:59 +0000
+++ src/dk/aau/cs/model/tapn/TimedInhibitorArc.java	2020-07-09 12:55:48 +0000
@@ -14,8 +14,12 @@
 	public TimedInhibitorArc(TimedPlace source, TimedTransition destination, TimeInterval interval, Weight weight) {
 		super(source, destination, TimeInterval.ZERO_INF, weight);
 	}
-	
-	public List<TimeInterval> getDEnabledInterval(){
+
+    public TimedInhibitorArc(TimedPlace source, TimedTransition destination) {
+        this(source, destination, TimeInterval.ZERO_INF, new IntWeight(1));
+    }
+
+    public List<TimeInterval> getDEnabledInterval(){
 		if(source().tokens().size() < getWeight().value()){
 			return Arrays.asList(new TimeInterval(true, new RatBound(BigDecimal.ZERO), Bound.Infinity, false));
 		} else {
 
=== modified file 'src/dk/aau/cs/model/tapn/TimedPlace.java'
--- src/dk/aau/cs/model/tapn/TimedPlace.java	2020-06-03 12:16:19 +0000
+++ src/dk/aau/cs/model/tapn/TimedPlace.java	2020-07-09 12:55:48 +0000
@@ -1,13 +1,24 @@
 package dk.aau.cs.model.tapn;
 
+import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.regex.Pattern;
 
+import dk.aau.cs.model.tapn.event.TimedPlaceEvent;
 import dk.aau.cs.model.tapn.event.TimedPlaceListener;
 import dk.aau.cs.util.Require;
 import dk.aau.cs.util.Tuple;
 
 public abstract class TimedPlace {
+
+    protected static final Pattern namePattern = Pattern.compile("^[a-zA-Z_][a-zA-Z0-9_]*$");
+    protected final List<TimedPlaceListener> listeners = new ArrayList<TimedPlaceListener>();
+    protected Tuple<PlaceType, Integer> extrapolation = new Tuple<PlaceType, Integer>(PlaceType.Dead, -2);
+    protected String name;
+    protected TimeInvariant invariant;
+    protected TimedMarking currentMarking;
+
     private SharedPlace sharedPlace;
     private List<TimedOutputArc> postset = new ArrayList<TimedOutputArc>();
     private List<TimedInputArc> preset = new ArrayList<TimedInputArc>();
@@ -17,28 +28,67 @@
     public enum PlaceType{
 		Standard, Invariant, Dead
 	}
-	
-	public abstract void addTimedPlaceListener(TimedPlaceListener listener);
-	public abstract void removeTimedPlaceListener(TimedPlaceListener listener);
 
 	public abstract boolean isShared();
 
-	public abstract String name();
-	public abstract void setName(String newName);
-
-	public abstract TimeInvariant invariant();
-	public abstract void setInvariant(TimeInvariant invariant);
-
-	public abstract List<TimedToken> tokens();
-	public abstract int numberOfTokens();
-
-	public abstract void setCurrentMarking(TimedMarking marking);
-	
-	public abstract void addToken(TimedToken timedToken);
-	public abstract void addTokens(Iterable<TimedToken> tokens);
-
-	public abstract void removeToken(TimedToken timedToken);
-	public abstract void removeToken();
+    public String name() {
+        return name;
+    }
+
+    public void setName(String newName) {
+		Require.that(newName != null && !newName.isEmpty(), "A timed place must have a name");
+		Require.that(isValid(newName) && !newName.toLowerCase().equals("true") && !newName.toLowerCase().equals("false"), "The specified name must conform to the pattern [a-zA-Z_][a-zA-Z0-9_]*");
+		this.name = newName;
+		fireNameChanged();
+	}
+
+    public TimeInvariant invariant(){
+        return invariant;
+    }
+
+    public List<TimedToken> tokens() {
+        return currentMarking.getTokensFor(this);
+    }
+
+    public int numberOfTokens() {
+        return tokens().size();
+    }
+
+    public void addToken(TimedToken timedToken) {
+        Require.that(timedToken != null, "timedToken cannot be null");
+        Require.that(timedToken.place().equals(this), "token is located in a different place");
+
+        currentMarking.add(timedToken);
+        fireMarkingChanged();
+    }
+
+    public void addTokens(Iterable<TimedToken> tokens) {
+        Require.that(tokens != null, "tokens cannot be null");
+
+        for(TimedToken token : tokens){
+            currentMarking.add(token); // avoid firing marking changed on every add
+        }
+        fireMarkingChanged();
+    }
+
+    public void addTokens(int numberOfTokensToAdd) {
+        for (int i = 0; i < numberOfTokensToAdd; i++) {
+            addToken(new TimedToken(this, BigDecimal.ZERO));
+        }
+    }
+
+    public void removeTokens(int numberOfTokensToRemove) {
+        for (int i = 0; i < numberOfTokensToRemove; i++) {
+            removeToken();
+        }
+    }
+
+    public void removeToken() {
+        if (numberOfTokens() > 0) {
+            currentMarking.remove(tokens().get(0));
+            fireMarkingChanged();
+        }
+    }
 	
 	public abstract Tuple<PlaceType, Integer> extrapolate();
 	
@@ -65,6 +115,51 @@
 		return name() == other.name();
 	}
 
+
+    protected void fireMarkingChanged() {
+        for(TimedPlaceListener listener : listeners){
+            listener.markingChanged(new TimedPlaceEvent(this));
+        }
+    }
+
+    protected void fireNameChanged() {
+        for(TimedPlaceListener listener : listeners){
+            listener.nameChanged(new TimedPlaceEvent(this));
+        }
+    }
+
+    protected void fireInvariantChanged() {
+        for(TimedPlaceListener listener : listeners){
+            listener.invariantChanged(new TimedPlaceEvent(this));
+        }
+    }
+
+    protected boolean isValid(String newName) {
+        return namePattern.matcher(newName).matches();
+    }
+
+    public void setInvariant(TimeInvariant invariant) {
+        Require.that(invariant != null, "invariant must not be null");
+        this.invariant = invariant;
+        fireInvariantChanged();
+    }
+
+    public void addTimedPlaceListener(TimedPlaceListener listener) {
+        Require.that(listener != null, "Listener cannot be null");
+        listeners.add(listener);
+    }
+
+    public void removeTimedPlaceListener(TimedPlaceListener listener) {
+        Require.that(listener != null, "Listener cannot be null");
+        listeners.remove(listener);
+    }
+
+    public void setCurrentMarking(TimedMarking marking) {
+        Require.that(marking != null, "marking cannot be null");
+        currentMarking = marking;
+        fireMarkingChanged();
+    }
+
     public boolean isOrphan() {
         return presetSize() == 0 && postsetSize() == 0;
     }
@@ -112,16 +207,4 @@
         return postset.size() + transportArcs.size() + inhibitorArcs.size();
     }
 
-//	public abstract void addInhibitorArc(TimedInhibitorArc arc);
-//	public abstract void addToPreset(TransportArc arc);
-//	public abstract void addToPreset(TimedOutputArc arc);
-//	public abstract void addToPostset(TransportArc arc);
-//	public abstract void addToPostset(TimedInputArc arc);
-//
-//	public abstract void removeFromPostset(TimedInputArc arc);
-//	public abstract void removeFromPostset(TransportArc arc);
-//	public abstract void removeFromPreset(TransportArc arc);
-//	public abstract void removeFromPreset(TimedOutputArc arc);
-//	public abstract void removeInhibitorArc(TimedInhibitorArc arc);
-
 }
 \ No newline at end of file
 
=== modified file 'src/dk/aau/cs/model/tapn/TimedToken.java'
--- src/dk/aau/cs/model/tapn/TimedToken.java	2019-03-23 07:51:29 +0000
+++ src/dk/aau/cs/model/tapn/TimedToken.java	2020-07-09 12:55:48 +0000
@@ -31,8 +31,7 @@
 	}
 	
 	public TimedToken clone() {
-		return new TimedToken(place, age); // age is immutable so ok to pass it
-											// to constructor
+		return new TimedToken(place, age); // age is immutable so ok to pass it to constructor
 	}
 
 	public TimedToken delay(BigDecimal delay) {
@@ -44,12 +43,7 @@
 		DecimalFormat df = new DecimalFormat();
 		df.setMaximumFractionDigits(Pipe.AGE_DECIMAL_PRECISION);
 
-		StringBuilder buffer = new StringBuilder("(");
-		buffer.append(place.toString());
-		buffer.append(", ");
-		buffer.append(df.format(age));
-		buffer.append(')');
-		return buffer.toString();
+        return String.format("(%s, %s)", place.toString(), df.format(age));
 	}
 
 	@Override
 
=== modified file 'src/dk/aau/cs/model/tapn/TimedTransition.java'
--- src/dk/aau/cs/model/tapn/TimedTransition.java	2020-06-18 20:57:07 +0000
+++ src/dk/aau/cs/model/tapn/TimedTransition.java	2020-07-09 12:55:48 +0000
@@ -17,16 +17,16 @@
 	private static final Pattern namePattern = Pattern.compile("^[a-zA-Z_][a-zA-Z0-9_]*$");
 
 	private String name;
-	private List<TimedOutputArc> postset = new ArrayList<TimedOutputArc>();
-	private List<TimedInputArc> preset = new ArrayList<TimedInputArc>();
-	private List<TransportArc> transportArcsGoingThrough = new ArrayList<TransportArc>();
-	private List<TimedInhibitorArc> inhibitorArcs = new ArrayList<TimedInhibitorArc>();
+	private final List<TimedOutputArc> postset = new ArrayList<TimedOutputArc>();
+	private final List<TimedInputArc> preset = new ArrayList<TimedInputArc>();
+	private final List<TransportArc> transportArcsGoingThrough = new ArrayList<TransportArc>();
+	private final List<TimedInhibitorArc> inhibitorArcs = new ArrayList<TimedInhibitorArc>();
 	private TimeInterval dInterval = null;
 	private boolean isUrgent = false;
 
 	private SharedTransition sharedTransition;
 
-	private List<TimedTransitionListener> listeners = new ArrayList<TimedTransitionListener>();
+	private final List<TimedTransitionListener> listeners = new ArrayList<TimedTransitionListener>();
 
 	public TimedTransition(String name) {
 		this(name, false);
 
=== modified file 'src/dk/aau/cs/model/tapn/TransportArc.java'
--- src/dk/aau/cs/model/tapn/TransportArc.java	2018-05-13 19:54:55 +0000
+++ src/dk/aau/cs/model/tapn/TransportArc.java	2020-07-09 12:55:48 +0000
@@ -36,8 +36,12 @@
 		setTimeInterval(interval);
 		this.weight = weight;
 	}
-	
-	public Weight getWeight(){
+
+    public TransportArc(TimedPlace source, TimedTransition transitions, TimedPlace destination) {
+        this(source, transitions, destination, TimeInterval.ZERO_INF);
+    }
+
+    public Weight getWeight(){
 		return weight;
 	}
         
 
=== modified file 'src/net/tapaal/gui/DrawingSurfaceManager/AbstractDrawingSurfaceManager.java'
--- src/net/tapaal/gui/DrawingSurfaceManager/AbstractDrawingSurfaceManager.java	2020-04-18 14:41:05 +0000
+++ src/net/tapaal/gui/DrawingSurfaceManager/AbstractDrawingSurfaceManager.java	2020-07-09 12:55:48 +0000
@@ -1,5 +1,7 @@
 package net.tapaal.gui.DrawingSurfaceManager;
 
+import pipe.gui.canvas.DrawingSurfaceImpl;
+import pipe.gui.graphicElements.GraphicalElement;
 import pipe.gui.graphicElements.PetriNetObject;
 
 import java.awt.event.MouseEvent;
@@ -11,6 +13,8 @@
 
 public abstract class AbstractDrawingSurfaceManager {
 
+    protected DrawingSurfaceImpl canvas;
+
     public void drawingSurfaceMouseClicked(MouseEvent e) {}
     public void drawingSurfaceMousePressed(MouseEvent e) {}
     public void drawingSurfaceMouseReleased(MouseEvent e){}
@@ -20,6 +24,8 @@
 
     public enum MouseAction {
         clicked,
+        doubleClicked,
+        rightClicked,
         pressed,
         released,
         dragged,
@@ -31,12 +37,12 @@
     public static class DrawingSurfaceEvent {
 
 
-        public final PetriNetObject pno;
+        public final GraphicalElement pno;
         public final MouseEvent e;
         public final MouseAction a;
         //Mouse Event type eg click mouse over etc
 
-        public DrawingSurfaceEvent(PetriNetObject pno, MouseEvent e, MouseAction a) {
+        public DrawingSurfaceEvent(GraphicalElement pno, MouseEvent e, MouseAction a) {
             this.pno = pno;
             this.e = e;
             this.a = a;
@@ -47,8 +53,12 @@
     private final Map<Predicate<DrawingSurfaceEvent>, Consumer<DrawingSurfaceEvent>> filter = new LinkedHashMap<>();
     private final AbstractDrawingSurfaceManager next = null;
 
-    public void registerManager(){}
-    public void deregisterManager(){}
+    public void registerManager(DrawingSurfaceImpl canvas){
+        this.canvas = canvas;
+    }
+    public void deregisterManager(){
+        this.canvas = null;
+    }
 
     public AbstractDrawingSurfaceManager() {
 			registerEvents();
 
=== added file 'src/net/tapaal/swinghelpers/DispatchEventsToParentHandler.java'
--- src/net/tapaal/swinghelpers/DispatchEventsToParentHandler.java	1970-01-01 00:00:00 +0000
+++ src/net/tapaal/swinghelpers/DispatchEventsToParentHandler.java	2020-07-09 12:55:48 +0000
@@ -0,0 +1,58 @@
+package net.tapaal.swinghelpers;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public final class DispatchEventsToParentHandler implements MouseListener, MouseWheelListener, MouseMotionListener {
+
+    private static void dispatchEventToParent(MouseEvent e) {
+        if(e.getSource() instanceof Component) {
+            Component c = ((Component) e.getSource());
+            if (c.getParent() != null) {
+                SwingUtilities.convertPoint(c, e.getPoint(), c.getParent());
+                c.getParent().dispatchEvent(e);
+            }
+        }
+    }
+
+    @Override
+    public final void mouseClicked(MouseEvent e) {
+        dispatchEventToParent(e);
+    }
+
+    @Override
+    public final void mousePressed(MouseEvent e) {
+        dispatchEventToParent(e);
+    }
+
+    @Override
+    public final void mouseReleased(MouseEvent e) {
+        dispatchEventToParent(e);
+    }
+
+    @Override
+    public final void mouseEntered(MouseEvent e) {
+        dispatchEventToParent(e);
+    }
+
+    @Override
+    public final void mouseExited(MouseEvent e) {
+        dispatchEventToParent(e);
+    }
+
+    @Override
+    public final void mouseDragged(MouseEvent e) {
+        dispatchEventToParent(e);
+    }
+
+    @Override
+    public final void mouseMoved(MouseEvent e) {
+        dispatchEventToParent(e);
+    }
+
+    @Override
+    public final void mouseWheelMoved(MouseWheelEvent e) {
+        dispatchEventToParent(e);
+    }
+}
 
=== modified file 'src/pipe/dataLayer/DataLayer.java'
--- src/pipe/dataLayer/DataLayer.java	2020-05-18 10:06:28 +0000
+++ src/pipe/dataLayer/DataLayer.java	2020-07-09 12:55:48 +0000
@@ -29,36 +29,36 @@
 	//migth not be best solution long term.
 	private void removeFromViewIfConnected(PetriNetObject pno) {
 		if (view != null) {
-			view.removePetriNetObject(pno);
+			view.removePetriNetObject(pno.getGraphicalElement());
 		}
 	}
 
 	private void addToViewIfConnected(PetriNetObject pno) {
 		if (view != null) {
-			view.addNewPetriNetObject(pno);
+			view.addNewPetriNetObject(pno.getGraphicalElement());
 		}
 	}
 
 	/** PNML File Name */
 	public String pnmlName = null;
 	/** List containing all the Place objects in the Petri-Net */
-	private ArrayList<Place> placesArray = null;
+	private final ArrayList<Place> placesArray = new ArrayList<Place>();
 	/** ArrayList containing all the Transition objects in the Petri-Net */
-	private ArrayList<Transition> transitionsArray = null;
+	private final ArrayList<Transition> transitionsArray = new ArrayList<Transition>();
 	/** ArrayList containing all the Arc objects in the Petri-Net */
-	private ArrayList<Arc> arcsArray = null;
+	private final ArrayList<Arc> arcsArray = new ArrayList<Arc>();
 
 	/** Set holding all ArcPathPoints
 	 * Uses the reference as lookup key (not hash code)
 	 * Collections.newSetFromMap(new IdentityHashMap<E, Boolean>());
 	 * */
-	private Set<ArcPathPoint> arcPathSet = Collections.newSetFromMap(new IdentityHashMap<>());
+	private final Set<ArcPathPoint> arcPathSet = Collections.newSetFromMap(new IdentityHashMap<>());
 
 	/**
 	 * ArrayList for net-level label objects (as opposed to element-level
 	 * labels).
 	 */
-	private ArrayList<AnnotationNote> labelsArray = null;
+	private final ArrayList<AnnotationNote> labelsArray = new ArrayList<AnnotationNote>();
 
 	/**
 	 * An ArrayList used to point to either the Arc, Place or Transition
@@ -66,22 +66,23 @@
 	 */
 	private ArrayList<? extends PetriNetObject> changeArrayList = null;
 
-	/**
+    // may as well do the hashtable here as well
+    /**
 	 * Hashtable which maps PlaceTransitionObjects to their list of connected
 	 * arcs
 	 */
-	private Hashtable<PlaceTransitionObject, ArrayList<TimedOutputArcComponent>> arcsMap = null;
+	private final Hashtable<PlaceTransitionObject, ArrayList<TimedOutputArcComponent>> arcsMap = new Hashtable<PlaceTransitionObject, ArrayList<TimedOutputArcComponent>>();
 
 	/**
 	 * Hashtable which maps PlaceTransitionObjects to their list of connected
 	 * arcs
 	 */
-	private Hashtable<PlaceTransitionObject, ArrayList<TimedInhibitorArcComponent>> tapnInhibitorsMap = null;
+	private final Hashtable<PlaceTransitionObject, ArrayList<TimedInhibitorArcComponent>> tapnInhibitorsMap = new Hashtable<PlaceTransitionObject, ArrayList<TimedInhibitorArcComponent>>();
 
 
 	//XXX: Added from drawingsurface to have a way to acces all elements added,
     //Should be refactored later to combine the existing list, however this is the quick fix during refactoring
-    private ArrayList<PetriNetObject> petriNetObjects = new ArrayList<PetriNetObject>();
+    private final ArrayList<PetriNetObject> petriNetObjects = new ArrayList<PetriNetObject>();
 
     public ArrayList<PetriNetObject> getPNObjects() {
         return petriNetObjects;
@@ -101,16 +102,8 @@
 	 * Create empty Petri-Net object
 	 */
 	public DataLayer() {
-		placesArray = new ArrayList<Place>();
-		transitionsArray = new ArrayList<Transition>();
-		arcsArray = new ArrayList<Arc>();
-
-		labelsArray = new ArrayList<AnnotationNote>();
-
-		// may as well do the hashtable here as well
-		arcsMap = new Hashtable<PlaceTransitionObject, ArrayList<TimedOutputArcComponent>>();
-		tapnInhibitorsMap = new Hashtable<PlaceTransitionObject, ArrayList<TimedInhibitorArcComponent>>();
-	}
+        super();
+    }
 
 
 	/**
@@ -162,105 +155,94 @@
 
 		// Check if the arcs have a valid source and target
 		if (arcInput.getSource() == null || arcInput.getTarget() == null) {
-			System.err.println(("Cant add arc" + arcInput + " where source: "
+			System.err.println(
+			    "Cant add arc" + arcInput + " where source: "
 					+ arcInput.getSource() + " or target: "
-					+ arcInput.getTarget() + " is null"));
+					+ arcInput.getTarget() + " is null"
+            );
 			return;
 		}
 
-		if (arcInput != null) {
-			if (arcInput.getId() != null && arcInput.getId().length() > 0) {
-				for (int i = 0; i < arcsArray.size(); i++) {
-					if (arcInput.getId().equals((arcsArray.get(i)).getId())) {
-						unique = false;
-					}
-				}
-			} else {
-				String id = null;
-				if (arcsArray != null && arcsArray.size() > 0) {
-					int no = arcsArray.size();
-					do {
-						for (int i = 0; i < arcsArray.size(); i++) {
-							id = "A" + no;
-							if (arcsArray.get(i) != null) {
-								if (id.equals((arcsArray.get(i)).getId())) {
-									unique = false;
-									no++;
-								} else {
-									unique = true;
-								}
-							}
-						}
-					} while (!unique);
-				} else {
-					id = "A0";
-				}
-				if (id != null) {
-					arcInput.setId(id);
-				} else {
-					arcInput.setId("error");
-				}
-			}
-
-			//XXX: this is still nedede as nets loaded from file (XML/tapn) does not set connectedTo correctly //2019-09-18
-			// Transportarc fix boddy
-			if (arcInput instanceof TimedTransportArcComponent) {
-				TimedTransportArcComponent tmp = (TimedTransportArcComponent) arcInput;
-				PlaceTransitionObject first = tmp.getSource();
-
-				if (tmp.getConnectedTo() == null) {
-					if (first instanceof TimedPlaceComponent) {
-
-						for (Object o : tmp.getTarget().getPostset()) {
-
-							if (o instanceof TimedTransportArcComponent) {
-								if (tmp.getGroupNr() == ((TimedTransportArcComponent) o)
-										.getGroupNr()) {
-									// Found partner
-
-									tmp
-											.setConnectedTo(((TimedTransportArcComponent) o));
-									((TimedTransportArcComponent) o)
-											.setConnectedTo(tmp);
-
-									break;
-								}
-							}
-
-						}
-
-					} else {
-						// First is TimedTransition
-						tmp = (TimedTransportArcComponent) arcInput;
-
-						for (Object o : tmp.getSource().getPreset()) {
-
-							if (o instanceof TimedTransportArcComponent) {
-								if (tmp.getGroupNr() == ((TimedTransportArcComponent) o)
-										.getGroupNr()) {
-									// Found partner
-
-									tmp
-											.setConnectedTo(((TimedTransportArcComponent) o));
-									((TimedTransportArcComponent) o)
-											.setConnectedTo(tmp);
-
-									break;
-								}
-							}
-
-						}
-
-					}
-				}
-
-			}
-
-			arcsArray.add(arcInput);
-			addArcToArcsMap(arcInput);
-
-		}
-	}
+        if (arcInput.getId() != null && arcInput.getId().length() > 0) {
+            for (Arc arc : arcsArray) {
+                if (arcInput.getId().equals(arc.getId())) {
+                    unique = false;
+                }
+            }
+        } else {
+            String id = null;
+            if (arcsArray.size() > 0) {
+                int no = arcsArray.size();
+                do {
+                    for (Arc arc : arcsArray) {
+                        id = "A" + no;
+                        if (arc != null) {
+                            if (id.equals(arc.getId())) {
+                                unique = false;
+                                no++;
+                            } else {
+                                unique = true;
+                            }
+                        }
+                    }
+                } while (!unique);
+            } else {
+                id = "A0";
+            }
+            arcInput.setId(id);
+        }
+
+        //XXX: this is still nedede as nets loaded from file (XML/tapn) does not set connectedTo correctly //2019-09-18
+        // Transportarc fix boddy
+        if (arcInput instanceof TimedTransportArcComponent) {
+            TimedTransportArcComponent tmp = (TimedTransportArcComponent) arcInput;
+            PlaceTransitionObject first = tmp.getSource();
+
+            if (tmp.getConnectedTo() == null) {
+                if (first instanceof TimedPlaceComponent) {
+
+                    for (Object o : tmp.getTarget().getPostset()) {
+
+                        if (o instanceof TimedTransportArcComponent) {
+                            if (tmp.getGroupNr() == ((TimedTransportArcComponent) o).getGroupNr()) {
+                                // Found partner
+
+                                tmp.setConnectedTo(((TimedTransportArcComponent) o));
+                                ((TimedTransportArcComponent) o).setConnectedTo(tmp);
+
+                                break;
+                            }
+                        }
+
+                    }
+
+                } else {
+                    // First is TimedTransition
+
+                    for (Object o : tmp.getSource().getPreset()) {
+
+                        if (o instanceof TimedTransportArcComponent) {
+                            if (tmp.getGroupNr() == ((TimedTransportArcComponent) o).getGroupNr()) {
+                                // Found partner
+
+                                tmp.setConnectedTo(((TimedTransportArcComponent) o));
+                                ((TimedTransportArcComponent) o).setConnectedTo(tmp);
+
+                                break;
+                            }
+                        }
+
+                    }
+
+                }
+            }
+
+        }
+
+        arcsArray.add(arcInput);
+        addArcToArcsMap(arcInput);
+
+    }
 
 	private void addTransportArc(TimedTransportArcComponent transportArc) {
 		arcsArray.add(transportArc);
@@ -271,40 +253,34 @@
 		boolean unique = true;
 
 		if (inhibitorArcInput != null) {
-			if (inhibitorArcInput.getId() != null
-					&& inhibitorArcInput.getId().length() > 0) {
-				for (int i = 0; i < arcsArray.size(); i++) {
-					if (inhibitorArcInput.getId().equals(
-							(arcsArray.get(i)).getId())) {
-						unique = false;
-					}
-				}
+			if (inhibitorArcInput.getId() != null && inhibitorArcInput.getId().length() > 0) {
+                for (Arc arc : arcsArray) {
+                    if (inhibitorArcInput.getId().equals(arc.getId())) {
+                        unique = false;
+                    }
+                }
 			} else {
 				String id = null;
-				if (arcsArray != null && arcsArray.size() > 0) {
+				if (arcsArray.size() > 0) {
 					int no = arcsArray.size();
 					do {
-						for (int i = 0; i < arcsArray.size(); i++) {
-							id = "I" + no;
-							if (arcsArray.get(i) != null) {
-								if (id.equals((arcsArray.get(i)).getId())) {
-									unique = false;
-									no++;
-								} else {
-									unique = true;
-								}
-							}
-						}
+                        for (Arc arc : arcsArray) {
+                            id = "I" + no;
+                            if (arc != null) {
+                                if (id.equals(arc.getId())) {
+                                    unique = false;
+                                    no++;
+                                } else {
+                                    unique = true;
+                                }
+                            }
+                        }
 					} while (!unique);
 				} else {
 					id = "I0";
 				}
-				if (id != null) {
-					inhibitorArcInput.setId(id);
-				} else {
-					inhibitorArcInput.setId("error");
-				}
-			}
+                inhibitorArcInput.setId(id);
+            }
 
 			arcsArray.add(inhibitorArcInput);
 			addInhibitorArcToInhibitorsMap(inhibitorArcInput);
@@ -529,18 +505,13 @@
 					attached = ((Arc) pnObject).getTarget();
 
 					if (attached != null) {
-						if (tapnInhibitorsMap.get(attached) != null) { // causing
-																		// null
-																		// pointer
-																		// exceptions
-																		// (!)
+						if (tapnInhibitorsMap.get(attached) != null) { // causing null pointer exceptions (!)
 							tapnInhibitorsMap.get(attached).remove(pnObject);
 						}
 
 						attached.removeToArc((Arc) pnObject);
 						if (attached instanceof Transition) {
-							((Transition) attached)
-									.removeArcCompareObject((Arc) pnObject);
+							((Transition) attached).removeArcCompareObject((Arc) pnObject);
 						}
 						// attached.updateConnected(); //causing null pointer
 						// exceptions (?)
@@ -567,10 +538,7 @@
 
 					attached = ((Arc) pnObject).getTarget();
 					if (attached != null) {
-						if (arcsMap.get(attached) != null) { // causing null
-																// pointer
-																// exceptions
-																// (!)
+						if (arcsMap.get(attached) != null) { // causing null pointer exceptions (!)
 							arcsMap.get(attached).remove(pnObject);
 						}
 
@@ -586,8 +554,7 @@
 
 			}
 		} catch (NullPointerException npe) {
-			System.out.println("NullPointerException [debug]\n"
-					+ npe.getMessage());
+			System.out.println("NullPointerException [debug]\n" + npe.getMessage());
 			throw npe;
 		}
 		// we reset to null so that the wrong ArrayList can't get added to
@@ -599,8 +566,10 @@
 	 * set all enabled transitions to highlighted
 	 */
 	public Iterable<Transition> transitions() {
-	    return transitionsArray;
-    }
+
+		return transitionsArray;
+	}
+
 
 	/**
 	 * Sets an internal ArrayList according to the class of the object passed
@@ -735,16 +704,14 @@
 	public Transition getTransitionById(String transitionID) {
 		Transition returnTransition = null;
 
-		if (transitionsArray != null) {
-			if (transitionID != null) {
-				for (Transition transition : transitionsArray) {
-					if (transitionID.equalsIgnoreCase(transition.getId())) {
-						returnTransition = transition;
-					}
-				}
-			}
-		}
-		return returnTransition;
+        if (transitionID != null) {
+            for (Transition transition : transitionsArray) {
+                if (transitionID.equalsIgnoreCase(transition.getId())) {
+                    returnTransition = transition;
+                }
+            }
+        }
+        return returnTransition;
 	}
 
 	/**
@@ -758,16 +725,14 @@
 	public Transition getTransitionByName(String transitionName) {
 		Transition returnTransition = null;
 
-		if (transitionsArray != null) {
-			if (transitionName != null) {
-				for (Transition transition : transitionsArray) {
-					if (transitionName.equalsIgnoreCase(transition.getName())) {
-						returnTransition = transition;
-					}
-				}
-			}
-		}
-		return returnTransition;
+        if (transitionName != null) {
+            for (Transition transition : transitionsArray) {
+                if (transitionName.equalsIgnoreCase(transition.getName())) {
+                    returnTransition = transition;
+                }
+            }
+        }
+        return returnTransition;
 	}
 
 	/**
@@ -780,16 +745,14 @@
 	public Place getPlaceById(String placeID) {
 		Place returnPlace = null;
 
-		if (placesArray != null) {
-			if (placeID != null) {
-				for (Place place : placesArray) {
-					if (placeID.equalsIgnoreCase(place.getId())) {
-						returnPlace = place;
-					}
-				}
-			}
-		}
-		return returnPlace;
+        if (placeID != null) {
+            for (Place place : placesArray) {
+                if (placeID.equalsIgnoreCase(place.getId())) {
+                    returnPlace = place;
+                }
+            }
+        }
+        return returnPlace;
 	}
 
 	/**
@@ -802,16 +765,14 @@
 	public Place getPlaceByName(String placeName) {
 		Place returnPlace = null;
 
-		if (placesArray != null) {
-			if (placeName != null) {
-				for (Place place : placesArray) {
-					if (placeName.equalsIgnoreCase(place.getName())) {
-						returnPlace = place;
-					}
-				}
-			}
-		}
-		return returnPlace;
+        if (placeName != null) {
+            for (Place place : placesArray) {
+                if (placeName.equalsIgnoreCase(place.getName())) {
+                    returnPlace = place;
+                }
+            }
+        }
+        return returnPlace;
 	}
 
 	/**
 
=== modified file 'src/pipe/dataLayer/Template.java'
--- src/pipe/dataLayer/Template.java	2020-01-12 10:11:08 +0000
+++ src/pipe/dataLayer/Template.java	2020-07-09 12:55:48 +0000
@@ -5,9 +5,9 @@
 import dk.aau.cs.util.Require;
 
 public class Template {
-	private TimedArcPetriNet net;
-	private DataLayer guiModel;
-	private Zoomer zoomer;
+	private final TimedArcPetriNet net;
+	private final DataLayer guiModel;
+	private final Zoomer zoomer;
 	private boolean hasPositionalInfo = false;
 	
 	public Template(TimedArcPetriNet net, DataLayer guiModel, Zoomer zoomer) {
@@ -37,11 +37,6 @@
 		net.setActive(isActive);
 	}
 
-	public void setGuiModel(DataLayer guiModel) {
-		Require.notNull(guiModel, "GuiModel cannot be null");
-		this.guiModel = guiModel;
-	}
-
 	public Template copy() {
 		TimedArcPetriNet tapn = net.copy();
 		tapn.setName(tapn.name() + "Copy");
 
=== modified file 'src/pipe/gui/AnimationHistoryList.java'
--- src/pipe/gui/AnimationHistoryList.java	2020-05-18 11:23:28 +0000
+++ src/pipe/gui/AnimationHistoryList.java	2020-07-09 12:55:48 +0000
@@ -152,7 +152,7 @@
 		}
 		for (Template t : CreateGui.getCurrentTab().activeTemplates()){
 			for(Transition trans : t.guiModel().getTransitions()){
-				if(trans.isEnabled(true) || trans.isDelayEnabledTransition(true)){
+				if(trans.isTransitionEnabled() || trans.isDelayEnabled()){
 					return;
 				}
 			}
 
=== modified file 'src/pipe/gui/Animator.java'
--- src/pipe/gui/Animator.java	2020-05-25 07:16:04 +0000
+++ src/pipe/gui/Animator.java	2020-07-09 12:55:48 +0000
@@ -39,659 +39,648 @@
 import dk.aau.cs.verification.VerifyTAPN.TraceType;
 
 public class Animator {
-	private final ArrayList<TAPNNetworkTraceStep> actionHistory = new ArrayList<TAPNNetworkTraceStep>();
-	private int currentAction;
-	private final ArrayList<NetworkMarking> markings = new ArrayList<NetworkMarking>();
-	private int currentMarkingIndex = 0;
-	private TAPNNetworkTrace trace = null;
-
-	public FiringMode firingmode = new RandomFiringMode();
-	private TabContent tab;
-	private NetworkMarking initialMarking;
-
-	private boolean isDisplayingUntimedTrace = false;
-	private static boolean isUrgentTransitionEnabled = false;
-	
-	public static boolean isUrgentTransitionEnabled(){
-		return isUrgentTransitionEnabled;
-	}
-
-	public Animator(TabContent tab) {
-        currentAction = -1;
-        setTabContent(tab);
-	}
-
-	private void setTabContent(TabContent tab)  {
-		this.tab = tab;
-	}
-
-	private NetworkMarking currentMarking() {
-		return markings.get(currentMarkingIndex);
-	}
-
-	public void setTrace(TAPNNetworkTrace trace) {
+    private final ArrayList<TAPNNetworkTraceStep> actionHistory = new ArrayList<TAPNNetworkTraceStep>();
+    private int currentAction = -1;
+    private final ArrayList<NetworkMarking> markings = new ArrayList<NetworkMarking>();
+    private int currentMarkingIndex = 0;
+    private TAPNNetworkTrace trace = null;
+
+    public FiringMode firingmode = new RandomFiringMode();
+    private final TabContent tab;
+    private NetworkMarking initialMarking;
+
+    private boolean isDisplayingUntimedTrace = false;
+    private static boolean isUrgentTransitionEnabled = false;
+
+    public static boolean isUrgentTransitionEnabled(){
+        return isUrgentTransitionEnabled;
+    }
+
+    public Animator(TabContent tab) {
+        super();
+
+        this.tab = tab;
+    }
+
+    private NetworkMarking currentMarking() {
+        return markings.get(currentMarkingIndex);
+    }
+
+    public void setTrace(TAPNNetworkTrace trace) {
         CreateGui.getCurrentTab().setAnimationMode(true);
 
-		if (trace.isConcreteTrace()) {
-			this.trace = trace;
-			setTimedTrace(trace);
-		} else {
-			setUntimedTrace(trace);
-			isDisplayingUntimedTrace = true;
-		}
-		currentAction = -1;
-		currentMarkingIndex = 0;
-		tab.network().setMarking(markings.get(currentMarkingIndex));
-		tab.getAnimationHistorySidePanel().setSelectedIndex(0);
-		updateAnimationButtonsEnabled();
-		updateFireableTransitions();
-	}
-
-	private void setUntimedTrace(TAPNNetworkTrace trace) {
-		tab.addAbstractAnimationPane();
-		AnimationHistoryList untimedAnimationHistory = tab.getUntimedAnimationHistory();
-
-		for(TAPNNetworkTraceStep step : trace){
-			untimedAnimationHistory.addHistoryItem(step.toString());
-		}
-
-		tab.getUntimedAnimationHistory().setSelectedIndex(0);
-		setFiringmode("Random");
-
-		JOptionPane.showMessageDialog(CreateGui.getApp(),
-				"The verification process returned an untimed trace.\n\n"
-						+ "This means that with appropriate time delays the displayed\n"
-						+ "sequence of discrete transitions can become a concrete trace.\n"
-						+ "In case of liveness properties (EG, AF) the untimed trace\n"
-						+ "either ends in a deadlock, a time divergent computation without\n"
-						+ "any discrete transitions, or it loops back to some earlier configuration.\n"
-						+ "The user may experiment in the simulator with different time delays\n"
-						+ "in order to realize the suggested untimed trace in the model.",
-						"Verification Information", JOptionPane.INFORMATION_MESSAGE);
-	}
-
-	private void setTimedTrace(TAPNNetworkTrace trace) {
-		for (TAPNNetworkTraceStep step : trace) {
-			addMarking(step, step.performStepFrom(currentMarking()));
-		}
-		if(getTrace().getTraceType() != TraceType.NOT_EG){ //If the trace was not explicitly set, maybe we have calculated it is deadlock.
-			tab.getAnimationHistorySidePanel().setLastShown(getTrace().getTraceType());
-		}
-	}
-
-	private void addToTimedTrace(List<TAPNNetworkTraceStep> stepList){
-		for (TAPNNetworkTraceStep step : stepList) {
-			addMarking(step, step.performStepFrom(currentMarking()));
-		}
-	}
-
-	public NetworkMarking getInitialMarking(){
-		return initialMarking;
-	}
-	
-	/**
-	 * Highlights enabled transitions
-	 */
-	public void highlightEnabledTransitions() {
-		updateFireableTransitions();
-		DataLayer current = activeGuiModel();
-
-        for (Transition tempTransition : current.transitions()) {
-            if (tempTransition.isEnabled(true) || (tempTransition.isDelayEnabledTransition(true) && !isUrgentTransitionEnabled)) {
-                tempTransition.repaint();
-            }
-        }
-	}
-
-	/**
-	 * Called during animation to unhighlight previously highlighted transitions
-	 */
-	private void unhighlightDisabledTransitions() {
-		DataLayer current = activeGuiModel();
-
-        for (Transition t : current.transitions()) {
-            if (!(t.isEnabled(true)) || !t.isDelayEnabledTransition(true) || (t.isDelayEnabledTransition(true) && isUrgentTransitionEnabled)) {
-                t.repaint();
-            }
-        }
-	}
-
-	public void updateFireableTransitions(){
-		TransitionFireingComponent transFireComponent = tab.getTransitionFireingComponent();
-		transFireComponent.startReInit();
-		isUrgentTransitionEnabled = false;
-		
-		outer: for( Template temp : tab.activeTemplates()){
-            for (Transition tempTransition : temp.guiModel().transitions()) {
-                if (tempTransition.isEnabled(true) && temp.model().getTransitionByName(tempTransition.getName()).isUrgent()) {
+        if (trace.isConcreteTrace()) {
+            this.trace = trace;
+            setTimedTrace(trace);
+        } else {
+            setUntimedTrace(trace);
+            isDisplayingUntimedTrace = true;
+        }
+        currentAction = -1;
+        currentMarkingIndex = 0;
+        tab.network().setMarking(markings.get(currentMarkingIndex));
+        tab.getAnimationHistorySidePanel().setSelectedIndex(0);
+        updateAnimationButtonsEnabled();
+        updateFireableTransitions();
+    }
+
+    private void setUntimedTrace(TAPNNetworkTrace trace) {
+        tab.addAbstractAnimationPane();
+        AnimationHistoryList untimedAnimationHistory = tab.getUntimedAnimationHistory();
+
+        for(TAPNNetworkTraceStep step : trace){
+            untimedAnimationHistory.addHistoryItem(step.toString());
+        }
+
+        tab.getUntimedAnimationHistory().setSelectedIndex(0);
+        setFiringmode("Random");
+
+        JOptionPane.showMessageDialog(CreateGui.getApp(),
+            "The verification process returned an untimed trace.\n\n"
+                + "This means that with appropriate time delays the displayed\n"
+                + "sequence of discrete transitions can become a concrete trace.\n"
+                + "In case of liveness properties (EG, AF) the untimed trace\n"
+                + "either ends in a deadlock, a time divergent computation without\n"
+                + "any discrete transitions, or it loops back to some earlier configuration.\n"
+                + "The user may experiment in the simulator with different time delays\n"
+                + "in order to realize the suggested untimed trace in the model.",
+            "Verification Information", JOptionPane.INFORMATION_MESSAGE);
+    }
+
+    private void setTimedTrace(TAPNNetworkTrace trace) {
+        for (TAPNNetworkTraceStep step : trace) {
+            addMarking(step, step.performStepFrom(currentMarking()));
+        }
+        if(getTrace().getTraceType() != TraceType.NOT_EG){ //If the trace was not explicitly set, maybe we have calculated it is deadlock.
+            tab.getAnimationHistorySidePanel().setLastShown(getTrace().getTraceType());
+        }
+    }
+
+    private void addToTimedTrace(List<TAPNNetworkTraceStep> stepList){
+        for (TAPNNetworkTraceStep step : stepList) {
+            addMarking(step, step.performStepFrom(currentMarking()));
+        }
+    }
+
+    public NetworkMarking getInitialMarking(){
+        return initialMarking;
+    }
+
+    /**
+     * Highlights enabled transitions
+     */
+    public void highlightEnabledTransitions() {
+        updateFireableTransitions();
+    }
+
+    /**
+     * Called during animation to unhighlight previously highlighted transitions
+     */
+    private void unhighlightDisabledTransitions() {
+        disableTransitions();
+    }
+
+    public void updateFireableTransitions(){
+        TransitionFireingComponent transFireComponent = tab.getTransitionFireingComponent();
+        transFireComponent.startReInit();
+        isUrgentTransitionEnabled = false;
+
+        outer: for( Template template : tab.activeTemplates()){
+            for (TimedTransition t : template.model().transitions()) {
+                if (t.isUrgent() && t.isEnabled()) {
                     isUrgentTransitionEnabled = true;
                     break outer;
                 }
             }
-		}
-		
-		for( Template temp : tab.activeTemplates()){
-            for (Transition tempTransition : temp.guiModel().transitions()) {
-                if (tempTransition.isEnabled(true) || (tempTransition.isDelayEnabledTransition(true) && CreateGui.getApp().isShowingDelayEnabledTransitions() && !isUrgentTransitionEnabled)) {
-                    transFireComponent.addTransition(temp, tempTransition);
+        }
+
+        for( Template template : tab.activeTemplates()){
+            for (Transition t : template.guiModel().transitions()) {
+                if (t.isTransitionEnabled()) {
+                    t.markTransitionEnabled(true);
+                    transFireComponent.addTransition(template, t);
+                } else if (CreateGui.getApp().isShowingDelayEnabledTransitions() &&
+                    t.isDelayEnabled() && !isUrgentTransitionEnabled
+                ) {
+                    t.markTransitionDelayEnabled(true);
+                    transFireComponent.addTransition(template, t);
                 }
+
             }
-		}
-
-		transFireComponent.reInitDone();
-	}
-
-	/**
-	 * Called at end of animation and resets all Transitions to false and
-	 * unhighlighted
-	 */
-	private void disableTransitions() {
-		for(Template template : tab.allTemplates())
-		{
+        }
+
+        transFireComponent.reInitDone();
+    }
+
+    /**
+     * Called at end of animation and resets all Transitions to false and
+     * unhighlighted
+     */
+    private void disableTransitions() {
+        for(Template template : tab.allTemplates())
+        {
             for (Transition tempTransition : template.guiModel().transitions()) {
-                tempTransition.setEnabledFalse();
-                tempTransition.setDelayEnabledTransitionFalse();
+                tempTransition.disableHightligh();
+
                 tempTransition.repaint();
             }
-		}
-	}
-
-	/**
-	 * Stores model at start of animation
-	 */
-	public void storeModel() {
-		initialMarking = tab.network().marking();
-		resethistory();
-		markings.add(initialMarking);
-	}
-
-	/**
-	 * Restores model at end of animation and sets all transitions to false and
-	 * unhighlighted
-	 */
-	public void restoreModel() {
-		if (tab != null) {
-			disableTransitions();
-			if (initialMarking != null) {
-                tab.network().setMarking(initialMarking);
-            }
-			currentAction = -1;
-		}
-	}
-
-	/**
-	 * Steps back through previously fired transitions
-	 * 
-	 * @author jokke refactored and added backwards firing for TAPNTransitions
-	 */
-
-	public void stepBack() {
+        }
+    }
+
+    /**
+     * Stores model at start of animation
+     */
+    public void storeModel() {
+        initialMarking = tab.network().marking();
+        resethistory();
+        markings.add(initialMarking);
+    }
+
+    /**
+     * Restores model at end of animation and sets all transitions to false and
+     * unhighlighted
+     */
+    public void restoreModel() {
+        if (tab != null) {
+            disableTransitions();
+            tab.network().setMarking(initialMarking);
+            currentAction = -1;
+        }
+    }
+
+    /**
+     * Steps back through previously fired transitions
+     *
+     * @author jokke refactored and added backwards firing for TAPNTransitions
+     */
+
+    public void stepBack() {
         tab.getAnimationHistorySidePanel().stepBackwards();
-		if (!actionHistory.isEmpty()){
-			TAPNNetworkTraceStep lastStep = actionHistory.get(currentAction);
-			if(isDisplayingUntimedTrace && lastStep instanceof TAPNNetworkTimedTransitionStep){
-				AnimationHistoryList untimedAnimationHistory = tab.getUntimedAnimationHistory();
-				String previousInUntimedTrace = untimedAnimationHistory.getElement(untimedAnimationHistory.getSelectedIndex());
-				if(previousInUntimedTrace.equals(lastStep.toString())){
-					untimedAnimationHistory.stepBackwards();
-				}
-			}			
-			tab.network().setMarking(markings.get(currentMarkingIndex - 1));
+        if (!actionHistory.isEmpty()){
+            TAPNNetworkTraceStep lastStep = actionHistory.get(currentAction);
+            if(isDisplayingUntimedTrace && lastStep instanceof TAPNNetworkTimedTransitionStep){
+                AnimationHistoryList untimedAnimationHistory = tab.getUntimedAnimationHistory();
+                String previousInUntimedTrace = untimedAnimationHistory.getElement(untimedAnimationHistory.getSelectedIndex());
+                if(previousInUntimedTrace.equals(lastStep.toString())){
+                    untimedAnimationHistory.stepBackwards();
+                }
+            }
+            tab.network().setMarking(markings.get(currentMarkingIndex - 1));
 
-			activeGuiModel().repaintPlaces();
-			unhighlightDisabledTransitions();
-			highlightEnabledTransitions();
-			currentAction--;
-			currentMarkingIndex--;
+            activeGuiModel().repaintPlaces();
+            unhighlightDisabledTransitions();
+            highlightEnabledTransitions();
+            currentAction--;
+            currentMarkingIndex--;
 
             updateAnimationButtonsEnabled();
             updateMouseOverInformation();
-			reportBlockingPlaces();
-		}
-	}
-
-	/**
-	 * Steps forward through previously fired transitions
-	 */
-
-	public void stepForward() {
+            reportBlockingPlaces();
+        }
+    }
+
+    /**
+     * Steps forward through previously fired transitions
+     */
+
+    public void stepForward() {
         tab.getAnimationHistorySidePanel().stepForward();
-		if(currentAction == actionHistory.size()-1 && trace != null){
-			int selectedIndex = tab.getAnimationHistorySidePanel().getSelectedIndex();
-			int action = currentAction;
-			int markingIndex = currentMarkingIndex;
-
-			if(getTrace().getTraceType() == TraceType.EG_DELAY_FOREVER){
-				addMarking(new TAPNNetworkTimeDelayStep(BigDecimal.ONE), currentMarking().delay(BigDecimal.ONE));
-			}
-			if(getTrace().getLoopToIndex() != -1){
-				addToTimedTrace(getTrace().getLoopSteps());
-			}
-
-			tab.getAnimationHistorySidePanel().setSelectedIndex(selectedIndex);
-			currentAction = action;
-			currentMarkingIndex = markingIndex;
-		}
-
-		if (currentAction < actionHistory.size() - 1) {
-			TAPNNetworkTraceStep nextStep = actionHistory.get(currentAction+1);
-			if(isDisplayingUntimedTrace && nextStep instanceof TAPNNetworkTimedTransitionStep){
-				AnimationHistoryList untimedAnimationHistory = tab.getUntimedAnimationHistory();
-				String nextInUntimedTrace = untimedAnimationHistory.getElement(untimedAnimationHistory.getSelectedIndex()+1);
-				if(nextInUntimedTrace.equals(nextStep.toString())){
-					untimedAnimationHistory.stepForward();
-				}
-			}			
-			tab.network().setMarking(markings.get(currentMarkingIndex + 1));
-
-			activeGuiModel().repaintPlaces();
-			unhighlightDisabledTransitions();
-			highlightEnabledTransitions();
-			currentAction++;
-			currentMarkingIndex++;
-			activeGuiModel().redrawVisibleTokenLists();
+        if(currentAction == actionHistory.size()-1 && trace != null){
+            int selectedIndex = tab.getAnimationHistorySidePanel().getSelectedIndex();
+            int action = currentAction;
+            int markingIndex = currentMarkingIndex;
+
+            if(getTrace().getTraceType() == TraceType.EG_DELAY_FOREVER){
+                addMarking(new TAPNNetworkTimeDelayStep(BigDecimal.ONE), currentMarking().delay(BigDecimal.ONE));
+            }
+            if(getTrace().getLoopToIndex() != -1){
+                addToTimedTrace(getTrace().getLoopSteps());
+            }
+
+            tab.getAnimationHistorySidePanel().setSelectedIndex(selectedIndex);
+            currentAction = action;
+            currentMarkingIndex = markingIndex;
+        }
+
+        if (currentAction < actionHistory.size() - 1) {
+            TAPNNetworkTraceStep nextStep = actionHistory.get(currentAction+1);
+            if(isDisplayingUntimedTrace && nextStep instanceof TAPNNetworkTimedTransitionStep){
+                AnimationHistoryList untimedAnimationHistory = tab.getUntimedAnimationHistory();
+                String nextInUntimedTrace = untimedAnimationHistory.getElement(untimedAnimationHistory.getSelectedIndex()+1);
+                if(nextInUntimedTrace.equals(nextStep.toString())){
+                    untimedAnimationHistory.stepForward();
+                }
+            }
+            tab.network().setMarking(markings.get(currentMarkingIndex + 1));
+
+            activeGuiModel().repaintPlaces();
+            unhighlightDisabledTransitions();
+            highlightEnabledTransitions();
+            currentAction++;
+            currentMarkingIndex++;
+            activeGuiModel().redrawVisibleTokenLists();
 
             updateAnimationButtonsEnabled();
             updateMouseOverInformation();
-			reportBlockingPlaces();
-
-		}
-	}	
-	
-	/**
-	 * Make the selected transition in the animation box blink, based on the
-	 * list element label
-	 */
-	
-	public void blinkSelected(String label){
-		if(label.contains(".")){
-			label = label.split("\\.")[1];
-		}
-		
-		Transition t = activeGuiModel().getTransitionByName(label);
-		if(t != null){
-			t.blink();
-		}
-	}
-	
-	public void dFireTransition(TimedTransition transition){
-		if(!CreateGui.getApp().isShowingDelayEnabledTransitions() || isUrgentTransitionEnabled()){
-			fireTransition(transition);
-			return;
-		}
-		
-		TimeInterval dInterval = transition.getdInterval();
-		
-		BigDecimal delayGranularity = tab.getDelayEnabledTransitionControl().getValue();
-		//Make sure the granularity is small enough
-		BigDecimal lowerBound = IntervalOperations.getRatBound(dInterval.lowerBound()).getBound();
-		if(!dInterval.IsLowerBoundNonStrict() && !dInterval.isIncluded(lowerBound.add(delayGranularity))){
-			do{
-				delayGranularity = delayGranularity.divide(BigDecimal.TEN);
-			} while (delayGranularity.compareTo(new BigDecimal("0.00001")) >= 0 && !dInterval.isIncluded(lowerBound.add(delayGranularity)));
-		}
-		
-		if(delayGranularity.compareTo(new BigDecimal("0.00001")) < 0){
-			JOptionPane.showMessageDialog(CreateGui.getApp(), "<html>Due to the limit of only five decimal points in the simulator</br> its not possible to fire the transition</html>");
-		} else {
-			BigDecimal delay = tab.getDelayEnabledTransitionControl().getDelayMode().GetDelay(transition, dInterval, delayGranularity);
-			if(delay != null){
-				if(delay.compareTo(BigDecimal.ZERO) != 0){ //Don't delay if the chosen delay is 0
-					if(!letTimePass(delay)){
-						return;
-					}
-				}
-			
-				fireTransition(transition);
-
-			}
-		}
-	}
-
-	// TODO: Clean up this method
-	private void fireTransition(TimedTransition transition) {
-
-		if(!clearStepsForward()){
-			return;
-		}
-
-		Tuple<NetworkMarking, List<TimedToken>> next = null;
-		List<TimedToken> tokensToConsume = null;
-
-		try{
-			if (getFiringmode() != null) {
-				next = currentMarking().fireTransition(transition, getFiringmode());
-			} else {
-				tokensToConsume = getTokensToConsume(transition);
-				if(tokensToConsume == null) return; // Cancelled
-				next = new Tuple<NetworkMarking, List<TimedToken>> (currentMarking().fireTransition(transition, tokensToConsume), tokensToConsume);
-			}
-		}catch(RequireException e){
-			JOptionPane.showMessageDialog(CreateGui.getApp(), "There was an error firing the transition. Reason: " + e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
-			return;
-		}
-
-		// It is important that this comes after the above, since 
-		// cancelling the token selection dialogue above should not result in changes 
-		// to the untimed animation history
-		if (isDisplayingUntimedTrace){
-			AnimationHistoryList untimedAnimationHistory = tab.getUntimedAnimationHistory();
-			if(untimedAnimationHistory.isStepForwardAllowed()){
-				String nextFromUntimedTrace = untimedAnimationHistory.getElement(untimedAnimationHistory.getSelectedIndex()+1);
-
-				if(nextFromUntimedTrace.equals(transition.model().name() + "." + transition.name()) || transition.isShared() && nextFromUntimedTrace.equals(transition.name())){
-					untimedAnimationHistory.stepForward();
-				}else{
-					int fireTransition = JOptionPane.showConfirmDialog(CreateGui.getApp(),
-							"Are you sure you want to fire a transition which does not follow the untimed trace?\n"
-									+ "Firing this transition will discard the untimed trace and revert to standard simulation.",
-									"Discrading Untimed Trace", JOptionPane.YES_NO_OPTION );
-
-					if (fireTransition == JOptionPane.NO_OPTION){
-						return;
-					}else{
-						removeSetTrace(false);
-					}
-				}
-			}
-		}
-
-		tab.network().setMarking(next.value1());
-		
-		activeGuiModel().repaintPlaces();
-		highlightEnabledTransitions();
-		unhighlightDisabledTransitions();
-		addMarking(new TAPNNetworkTimedTransitionStep(transition, next.value2()), next.value1());
-
-		updateAnimationButtonsEnabled();
-        updateMouseOverInformation();
-		reportBlockingPlaces();
-
-	}
-
-	public boolean letTimePass(BigDecimal delay) {
-
-		if(!clearStepsForward()){
-			return false;
-		}
-
-		boolean result = false;
-		if (delay.compareTo(new BigDecimal(0))==0 || (currentMarking().isDelayPossible(delay) && !isUrgentTransitionEnabled)) {
-			NetworkMarking delayedMarking = currentMarking().delay(delay);
-			tab.network().setMarking(delayedMarking);
-			addMarking(new TAPNNetworkTimeDelayStep(delay), delayedMarking);
-			result = true;
-		}
-
-		activeGuiModel().repaintPlaces();
-		highlightEnabledTransitions();
-		unhighlightDisabledTransitions();
-
-        updateAnimationButtonsEnabled();
-        updateMouseOverInformation();
-		reportBlockingPlaces();
-
-		return result;
-	}
-
-	public void reportBlockingPlaces(){
-
-		try{
-			BigDecimal delay = tab.getAnimationController().getCurrentDelay();
-		if(isUrgentTransitionEnabled && delay.compareTo(new BigDecimal(0))>0){
-			tab.getAnimationController().getOkButton().setEnabled(false);
-			StringBuilder sb = new StringBuilder();
-			sb.append("<html>Time delay is disabled due to the<br /> following enabled urgent transitions:<br /><br />");
-			for( Template temp : tab.activeTemplates()){
-                for (Transition tempTransition : temp.guiModel().transitions()) {
-                    if (tempTransition.isEnabled(true) && temp.model().getTransitionByName(tempTransition.getName()).isUrgent()) {
-                        sb.append(temp.toString() + "." + tempTransition.getName() + "<br />");
-                    }
-                }
-			}
-			sb.append("</html>");
-			tab.getAnimationController().getOkButton().setToolTipText(sb.toString());
-			return;
-		}
-			if(delay.compareTo(new BigDecimal(0))<0){
-				tab.getAnimationController().getOkButton().setEnabled(false);
-				tab.getAnimationController().getOkButton().setToolTipText("Time delay is possible only for nonnegative rational numbers");
-			} else {
-				List<TimedPlace> blockingPlaces = currentMarking().getBlockingPlaces(delay);
-				if(blockingPlaces.size() == 0){
-					tab.getAnimationController().getOkButton().setEnabled(true);
-					tab.getAnimationController().getOkButton().setToolTipText("Press to add the delay");
-				} else {
-					StringBuilder sb = new StringBuilder();
-					sb.append("<html>Time delay of " + delay + " time unit(s) is disabled due to <br /> age invariants in the following places:<br /><br />");
-					for (TimedPlace t :blockingPlaces){
-						sb.append(t.toString() + "<br />");
-					}
-					//JOptionPane.showMessageDialog(null, sb.toString());
-					sb.append("</html>");
-					tab.getAnimationController().getOkButton().setEnabled(false);
-					tab.getAnimationController().getOkButton().setToolTipText(sb.toString());
-				}
-			}
-		} catch (NumberFormatException e) {
-			// Do nothing, invalud number
-		} catch (ParseException e) {
-			tab.getAnimationController().getOkButton().setEnabled(false);
-			tab.getAnimationController().getOkButton().setToolTipText("The text in the input field is not a number");
-		}
-	}
-
-	private DataLayer activeGuiModel() {
-		return tab.currentTemplate().guiModel();
-	}
-
-	private void resethistory() {
-		actionHistory.clear();
-		markings.clear();
-		currentAction = -1;
-		currentMarkingIndex = 0;
-		tab.getAnimationHistorySidePanel().reset();
-		if(tab.getUntimedAnimationHistory() != null){
-			tab.getUntimedAnimationHistory().reset();
-		}
-	}
-
-	public FiringMode getFiringmode() {
-		return firingmode;
-	}
-
-	// removes stored markings and actions from index "startWith" (included)
-	private void removeStoredActions(int startWith) {
-		int lastIndex = actionHistory.size() - 1;
-		for (int i = startWith; i <= lastIndex; i++) {
-			removeLastHistoryStep();
-		}
-	}
-
-	private void addMarking(TAPNNetworkTraceStep action, NetworkMarking marking) {
-		if (currentAction < actionHistory.size() - 1) {
+            reportBlockingPlaces();
+
+        }
+    }
+
+    /**
+     * Make the selected transition in the animation box blink, based on the
+     * list element label
+     */
+
+    public void blinkSelected(String label){
+        if(label.contains(".")){
+            label = label.split("\\.")[1];
+        }
+
+        Transition t = activeGuiModel().getTransitionByName(label);
+        if(t != null){
+            t.blink();
+        }
+    }
+
+    public void dFireTransition(TimedTransition transition){
+        if(!CreateGui.getApp().isShowingDelayEnabledTransitions() || isUrgentTransitionEnabled()){
+            fireTransition(transition);
+            return;
+        }
+
+        TimeInterval dInterval = transition.getdInterval();
+
+        BigDecimal delayGranularity = tab.getDelayEnabledTransitionControl().getValue();
+        //Make sure the granularity is small enough
+        BigDecimal lowerBound = IntervalOperations.getRatBound(dInterval.lowerBound()).getBound();
+        if(!dInterval.IsLowerBoundNonStrict() && !dInterval.isIncluded(lowerBound.add(delayGranularity))){
+            do{
+                delayGranularity = delayGranularity.divide(BigDecimal.TEN);
+            } while (delayGranularity.compareTo(new BigDecimal("0.00001")) >= 0 && !dInterval.isIncluded(lowerBound.add(delayGranularity)));
+        }
+
+        if(delayGranularity.compareTo(new BigDecimal("0.00001")) < 0){
+            JOptionPane.showMessageDialog(CreateGui.getApp(), "<html>Due to the limit of only five decimal points in the simulator</br> its not possible to fire the transition</html>");
+        } else {
+            BigDecimal delay = tab.getDelayEnabledTransitionControl().getDelayMode().GetDelay(transition, dInterval, delayGranularity);
+            if(delay != null){
+                if(delay.compareTo(BigDecimal.ZERO) != 0){ //Don't delay if the chosen delay is 0
+                    if(!letTimePass(delay)){
+                        return;
+                    }
+                }
+
+                fireTransition(transition);
+            }
+        }
+    }
+
+    // TODO: Clean up this method
+    private void fireTransition(TimedTransition transition) {
+
+        if(!clearStepsForward()){
+            return;
+        }
+
+        Tuple<NetworkMarking, List<TimedToken>> next = null;
+        List<TimedToken> tokensToConsume = null;
+        try{
+            if (getFiringmode() != null) {
+                next = currentMarking().fireTransition(transition, getFiringmode());
+            } else {
+                tokensToConsume = getTokensToConsume(transition);
+                if(tokensToConsume == null) return; // Cancelled
+                next = new Tuple<NetworkMarking, List<TimedToken>> (currentMarking().fireTransition(transition, tokensToConsume), tokensToConsume);
+            }
+        }catch(RequireException e){
+            JOptionPane.showMessageDialog(CreateGui.getApp(), "There was an error firing the transition. Reason: " + e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
+            return;
+        }
+
+        // It is important that this comes after the above, since
+        // cancelling the token selection dialogue above should not result in changes
+        // to the untimed animation history
+        if (isDisplayingUntimedTrace){
+            AnimationHistoryList untimedAnimationHistory = tab.getUntimedAnimationHistory();
+            if(untimedAnimationHistory.isStepForwardAllowed()){
+                String nextFromUntimedTrace = untimedAnimationHistory.getElement(untimedAnimationHistory.getSelectedIndex()+1);
+
+                if(nextFromUntimedTrace.equals(transition.model().name() + "." + transition.name()) || transition.isShared() && nextFromUntimedTrace.equals(transition.name())){
+                    untimedAnimationHistory.stepForward();
+                }else{
+                    int fireTransition = JOptionPane.showConfirmDialog(CreateGui.getApp(),
+                        "Are you sure you want to fire a transition which does not follow the untimed trace?\n"
+                            + "Firing this transition will discard the untimed trace and revert to standard simulation.",
+                        "Discrading Untimed Trace", JOptionPane.YES_NO_OPTION );
+
+                    if (fireTransition == JOptionPane.NO_OPTION){
+                        return;
+                    }else{
+                        removeSetTrace(false);
+                    }
+                }
+            }
+        }
+
+        tab.network().setMarking(next.value1());
+
+        activeGuiModel().repaintPlaces();
+        unhighlightDisabledTransitions();
+        highlightEnabledTransitions();
+
+        addMarking(new TAPNNetworkTimedTransitionStep(transition, next.value2()), next.value1());
+
+        updateAnimationButtonsEnabled();
+        updateMouseOverInformation();
+        reportBlockingPlaces();
+
+    }
+
+    public boolean letTimePass(BigDecimal delay) {
+
+        if(!clearStepsForward()){
+            return false;
+        }
+
+        boolean result = false;
+        if (delay.compareTo(new BigDecimal(0))==0 || (currentMarking().isDelayPossible(delay) && !isUrgentTransitionEnabled)) {
+            NetworkMarking delayedMarking = currentMarking().delay(delay);
+            tab.network().setMarking(delayedMarking);
+            addMarking(new TAPNNetworkTimeDelayStep(delay), delayedMarking);
+            result = true;
+        }
+
+        activeGuiModel().repaintPlaces();
+        unhighlightDisabledTransitions();
+        highlightEnabledTransitions();
+
+        updateAnimationButtonsEnabled();
+        updateMouseOverInformation();
+        reportBlockingPlaces();
+        return result;
+    }
+
+    public void reportBlockingPlaces() {
+
+        try {
+            BigDecimal delay = tab.getAnimationController().getCurrentDelay();
+
+            if (isUrgentTransitionEnabled && !delay.equals(BigDecimal.ZERO) ) {
+                tab.getAnimationController().getOkButton().setEnabled(false);
+
+                StringBuilder sb = new StringBuilder();
+                sb.append("<html>Time delay is disabled due to the<br /> following enabled urgent transitions:<br /><br />");
+                for (Template template : tab.activeTemplates()) {
+                    for (Transition t : template.guiModel().transitions()) {
+                        if (t.isTransitionEnabled() && template.model().getTransitionByName(t.getName()).isUrgent()) {
+                            sb.append(template.toString() + "." + t.getName() + "<br />");
+                        }
+                    }
+                }
+                sb.append("</html>");
+
+                tab.getAnimationController().getOkButton().setToolTipText(sb.toString());
+
+                return;
+            }
+
+            if (delay.compareTo(new BigDecimal(0)) < 0) {
+                tab.getAnimationController().getOkButton().setEnabled(false);
+                tab.getAnimationController().getOkButton().setToolTipText("Time delay is possible only for nonnegative rational numbers");
+            } else {
+                List<TimedPlace> blockingPlaces = currentMarking().getBlockingPlaces(delay);
+                if (blockingPlaces.size() == 0) {
+                    tab.getAnimationController().getOkButton().setEnabled(true);
+                    tab.getAnimationController().getOkButton().setToolTipText("Press to add the delay");
+                } else {
+                    StringBuilder sb = new StringBuilder();
+                    sb.append("<html>Time delay of " + delay + " time unit(s) is disabled due to <br /> age invariants in the following places:<br /><br />");
+                    for (TimedPlace t : blockingPlaces) {
+                        sb.append(t.toString() + "<br />");
+                    }
+                    //JOptionPane.showMessageDialog(null, sb.toString());
+                    sb.append("</html>");
+                    tab.getAnimationController().getOkButton().setEnabled(false);
+                    tab.getAnimationController().getOkButton().setToolTipText(sb.toString());
+                }
+            }
+        } catch (ParseException | NumberFormatException e) {
+            tab.getAnimationController().getOkButton().setEnabled(false);
+            tab.getAnimationController().getOkButton().setToolTipText("The text in the input field is not a number");
+        }
+    }
+
+    private DataLayer activeGuiModel() {
+        return tab.currentTemplate().guiModel();
+    }
+
+    private void resethistory() {
+        actionHistory.clear();
+        markings.clear();
+        currentAction = -1;
+        currentMarkingIndex = 0;
+        tab.getAnimationHistorySidePanel().reset();
+        if(tab.getUntimedAnimationHistory() != null){
+            tab.getUntimedAnimationHistory().reset();
+        }
+    }
+
+    public FiringMode getFiringmode() {
+        return firingmode;
+    }
+
+    // removes stored markings and actions from index "startWith" (included)
+    private void removeStoredActions(int startWith) {
+        int lastIndex = actionHistory.size() - 1;
+        for (int i = startWith; i <= lastIndex; i++) {
+            removeLastHistoryStep();
+        }
+    }
+
+    private void addMarking(TAPNNetworkTraceStep action, NetworkMarking marking) {
+        if (currentAction < actionHistory.size() - 1) {
             removeStoredActions(currentAction + 1);
         }
 
-		tab.network().setMarking(marking);
-		tab.getAnimationHistorySidePanel().addHistoryItem(action.toString());
-		actionHistory.add(action);
-		markings.add(marking);
-		currentAction++;
-		currentMarkingIndex++;
-	}
-
-	private void removeLastHistoryStep() {
-		actionHistory.remove(actionHistory.size() - 1);
-		markings.remove(markings.size() - 1);
-	}
-
-	//XXX: should be enum?
+        tab.network().setMarking(marking);
+        tab.getAnimationHistorySidePanel().addHistoryItem(action.toString());
+        actionHistory.add(action);
+        markings.add(marking);
+        currentAction++;
+        currentMarkingIndex++;
+    }
+
+    private void removeLastHistoryStep() {
+            actionHistory.remove(actionHistory.size() - 1);
+        markings.remove(markings.size() - 1);
+    }
+
+    //XXX: should be enum?
     public static final String[] FIRINGMODES = { "Random", "Oldest", "Youngest", "Manual" };
-	public void setFiringmode(String t) {
-		switch (t) {
-			case "Random":
-				firingmode = new RandomFiringMode();
-				break;
-			case "Youngest":
-				firingmode = new YoungestFiringMode();
-				break;
-			case "Oldest":
-				firingmode = new OldestFiringMode();
-				break;
-			case "Manual":
-				firingmode = null;
-				break;
-			default:
-				System.err
-						.println("Illegal firing mode mode: " + t + " not found.");
-				break;
-		}
-
-		tab.getAnimationController().updateFiringModeComboBox();
-		tab.getAnimationController().setToolTipText("Select a method for choosing tokens during transition firing");
-	}	
-
-	enum FillListStatus{
-		lessThanWeight,
-		weight,
-		moreThanWeight
-	}
-
-	//Creates a list of tokens if there is only weight tokens in each of the places
-	//Used by getTokensToConsume
-	private  FillListStatus fillList(TimedTransition transition, List<TimedToken> listToFill){
-		for(TimedInputArc in: transition.getInputArcs()){
-			List<TimedToken> elligibleTokens = in.getElligibleTokens();
-			if(elligibleTokens.size() < in.getWeight().value()){
-				return FillListStatus.lessThanWeight;
-			} else if(elligibleTokens.size() == in.getWeight().value()){
-				listToFill.addAll(elligibleTokens);
-			} else {
-				return FillListStatus.moreThanWeight;
-			}
-		}
-		for(TransportArc in: transition.getTransportArcsGoingThrough()){
-			List<TimedToken> elligibleTokens = in.getElligibleTokens();
-			if(elligibleTokens.size() < in.getWeight().value()){
-				return FillListStatus.lessThanWeight;
-			} else if(elligibleTokens.size() == in.getWeight().value()){
-				listToFill.addAll(elligibleTokens);
-			} else {
-				return FillListStatus.moreThanWeight;
-			}
-		}
-		return FillListStatus.weight;
-	}
-
-	private List<TimedToken> getTokensToConsume(TimedTransition transition){
-		//If there are only "weight tokens in each place
-		List<TimedToken> result = new ArrayList<TimedToken>();
-		boolean userShouldChoose = false;
-		if(transition.isShared()){
-			for(TimedTransition t : transition.sharedTransition().transitions()){
-				FillListStatus status = fillList(t, result);
-				if(status == FillListStatus.lessThanWeight){
-					return null;
-				} else if(status == FillListStatus.moreThanWeight){
-					userShouldChoose = true;
-					break;
-				}
-			}
-		} else {
-			FillListStatus status = fillList(transition, result);
-			if(status == FillListStatus.lessThanWeight){
-				return null;
-			} else if(status == FillListStatus.moreThanWeight){
-				userShouldChoose = true;
-			}
-		}
-
-		if (userShouldChoose){
-			return showSelectSimulatorDialogue(transition);
-		} else {
-			return result;
-		}
-	}
-
-	private List<TimedToken> showSelectSimulatorDialogue(TimedTransition transition) {
-		EscapableDialog guiDialog = new EscapableDialog(CreateGui.getApp(), "Select Tokens", true);
-
-		Container contentPane = guiDialog.getContentPane();
-		contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.PAGE_AXIS));
-		AnimationTokenSelectDialog animationTokenSelectDialog = new AnimationTokenSelectDialog(transition);
-		contentPane.add(animationTokenSelectDialog);
-		guiDialog.setResizable(true);
-
-		// Make window fit contents' preferred size
-		guiDialog.pack();
-
-		// Move window to the middle of the screen
-		guiDialog.setLocationRelativeTo(null);
-		guiDialog.setVisible(true);
-
-		return animationTokenSelectDialog.getTokens();
-	}
-
-	public void reset(boolean keepInitial){
-		resethistory();
-		removeSetTrace(false);
-		if(keepInitial && initialMarking != null){
-			markings.add(initialMarking);
-			tab.network().setMarking(initialMarking);
-			currentAction = -1;
-			updateFireableTransitions();
-		}
-	}
-
-	private boolean removeSetTrace(boolean askUser){
-		if(askUser && isShowingTrace()){ //Warn about deleting trace
-			int answer = JOptionPane.showConfirmDialog(CreateGui.getApp(), 
-					"You are about to remove the current trace.", 
-					"Removing Trace", JOptionPane.OK_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);
-			if(answer != JOptionPane.OK_OPTION) return false;
-		}
-		if(isDisplayingUntimedTrace){
-			tab.removeAbstractAnimationPane();
-		}
-		isDisplayingUntimedTrace = false;
-		trace = null;
-		return true;
-	}
-
-	public TimedTAPNNetworkTrace getTrace(){
-		return (TimedTAPNNetworkTrace)trace;
-	}
-
-	private boolean clearStepsForward(){
-		boolean answer = true;
-		if(!isDisplayingUntimedTrace){
-			answer = removeSetTrace(true);
-		}
-		if(answer){
-			tab.getAnimationHistorySidePanel().clearStepsForward();
-		}
-		return answer;
-	}
-
-	private boolean isShowingTrace(){
-		return isDisplayingUntimedTrace || trace != null;
-	}
-        
-	public ArrayList<TAPNNetworkTraceStep> getActionHistory() {
-		return actionHistory;
-	}
+    public void setFiringmode(String t) {
+        switch (t) {
+            case "Random":
+                firingmode = new RandomFiringMode();
+                break;
+            case "Youngest":
+                firingmode = new YoungestFiringMode();
+                break;
+            case "Oldest":
+                firingmode = new OldestFiringMode();
+                break;
+            case "Manual":
+                firingmode = null;
+                break;
+            default:
+                System.err
+                    .println("Illegal firing mode mode: " + t + " not found.");
+                break;
+        }
+
+        tab.getAnimationController().updateFiringModeComboBox();
+        tab.getAnimationController().setToolTipText("Select a method for choosing tokens during transition firing");
+    }
+
+    enum FillListStatus{
+        lessThanWeight,
+        weight,
+        moreThanWeight
+    }
+
+    //Creates a list of tokens if there is only weight tokens in each of the places
+    //Used by getTokensToConsume
+    private  FillListStatus fillList(TimedTransition transition, List<TimedToken> listToFill){
+        for(TimedInputArc in: transition.getInputArcs()){
+            List<TimedToken> elligibleTokens = in.getElligibleTokens();
+            if(elligibleTokens.size() < in.getWeight().value()){
+                return FillListStatus.lessThanWeight;
+            } else if(elligibleTokens.size() == in.getWeight().value()){
+                listToFill.addAll(elligibleTokens);
+            } else {
+                return FillListStatus.moreThanWeight;
+            }
+        }
+        for(TransportArc in: transition.getTransportArcsGoingThrough()){
+            List<TimedToken> elligibleTokens = in.getElligibleTokens();
+            if(elligibleTokens.size() < in.getWeight().value()){
+                return FillListStatus.lessThanWeight;
+            } else if(elligibleTokens.size() == in.getWeight().value()){
+                listToFill.addAll(elligibleTokens);
+            } else {
+                return FillListStatus.moreThanWeight;
+            }
+        }
+        return FillListStatus.weight;
+    }
+
+    private List<TimedToken> getTokensToConsume(TimedTransition transition){
+        //If there are only "weight tokens in each place
+        List<TimedToken> result = new ArrayList<TimedToken>();
+        boolean userShouldChoose = false;
+        if(transition.isShared()){
+            for(TimedTransition t : transition.sharedTransition().transitions()){
+                FillListStatus status = fillList(t, result);
+                if(status == FillListStatus.lessThanWeight){
+                    return null;
+                } else if(status == FillListStatus.moreThanWeight){
+                    userShouldChoose = true;
+                    break;
+                }
+            }
+        } else {
+            FillListStatus status = fillList(transition, result);
+            if(status == FillListStatus.lessThanWeight){
+                return null;
+            } else if(status == FillListStatus.moreThanWeight){
+                userShouldChoose = true;
+            }
+        }
+
+        if (userShouldChoose){
+            return showSelectSimulatorDialogue(transition);
+        } else {
+            return result;
+        }
+    }
+
+    private List<TimedToken> showSelectSimulatorDialogue(TimedTransition transition) {
+        EscapableDialog guiDialog = new EscapableDialog(CreateGui.getApp(), "Select Tokens", true);
+
+        Container contentPane = guiDialog.getContentPane();
+        contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.PAGE_AXIS));
+        AnimationTokenSelectDialog animationSelectmodeDialog = new AnimationTokenSelectDialog(transition);
+        contentPane.add(animationSelectmodeDialog);
+        guiDialog.setResizable(true);
+
+        // Make window fit contents' preferred size
+        guiDialog.pack();
+
+        // Move window to the middle of the screen
+        guiDialog.setLocationRelativeTo(null);
+        guiDialog.setVisible(true);
+
+        return animationSelectmodeDialog.getTokens();
+    }
+
+    public void reset(boolean keepInitial){
+        resethistory();
+        removeSetTrace(false);
+        if(keepInitial && initialMarking != null){
+            markings.add(initialMarking);
+            tab.network().setMarking(initialMarking);
+            currentAction = -1;
+            updateFireableTransitions();
+        }
+    }
+
+    private boolean removeSetTrace(boolean askUser){
+        if(askUser && isShowingTrace()){ //Warn about deleting trace
+            int answer = JOptionPane.showConfirmDialog(CreateGui.getApp(),
+                "You are about to remove the current trace.",
+                "Removing Trace", JOptionPane.OK_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);
+            if(answer != JOptionPane.OK_OPTION) return false;
+        }
+        if(isDisplayingUntimedTrace){
+            tab.removeAbstractAnimationPane();
+        }
+        isDisplayingUntimedTrace = false;
+        trace = null;
+        return true;
+    }
+
+    public TimedTAPNNetworkTrace getTrace(){
+        return (TimedTAPNNetworkTrace)trace;
+    }
+
+    private boolean clearStepsForward(){
+        boolean answer = true;
+        if(!isDisplayingUntimedTrace){
+            answer = removeSetTrace(true);
+        }
+        if(answer){
+            tab.getAnimationHistorySidePanel().clearStepsForward();
+        }
+        return answer;
+    }
+
+    private boolean isShowingTrace(){
+        return isDisplayingUntimedTrace || trace != null;
+    }
+
+    public ArrayList<TAPNNetworkTraceStep> getActionHistory() {
+        return actionHistory;
+    }
 
 
     private void setEnabledStepbackwardAction(boolean b) {
         stepbackwardAction.setEnabled(b);
-
     }
 
     private void setEnabledStepforwardAction(boolean b) {
         stepforwardAction.setEnabled(b);
+    }
 
-    }
     public final GuiAction stepforwardAction = CreateGui.getAppGui().stepforwardAction;
     public final GuiAction stepbackwardAction = CreateGui.getAppGui().stepbackwardAction;
 
@@ -703,8 +692,6 @@
 
     }
 
-    /* GUI Model / Actions helpers */
-    //XXX: Should be moved to animationController or similar
     /**
      * Updates the mouseOver label showing token ages in animationmode
      * when a "animation" action is happening. "live updates" any mouseOver label
@@ -717,4 +704,5 @@
             }
         }
     }
+
 }
 
=== modified file 'src/pipe/gui/CreateGui.java'
--- src/pipe/gui/CreateGui.java	2020-05-27 13:07:27 +0000
+++ src/pipe/gui/CreateGui.java	2020-07-09 12:55:48 +0000
@@ -14,16 +14,14 @@
 
 public class CreateGui {
 
-	private static GuiFrame appGui;
-    private static GuiFrameController appGuiController;
+	private final static GuiFrame appGui = new GuiFrame(TAPAAL.getProgramName());
+    private final static GuiFrameController appGuiController = new GuiFrameController(appGui);
 
-	private static ArrayList<TabContent> tabs = new ArrayList<TabContent>();
+	private static final ArrayList<TabContent> tabs = new ArrayList<TabContent>();
 
 	public static void init() {
-		appGui = new GuiFrame(TAPAAL.getProgramName());
-        appGuiController = new GuiFrameController(appGui);
 
-		if (Platform.isMac()){
+        if (Platform.isMac()){
 			try {
 				SpecialMacHandler.postprocess();
 			} catch (NoClassDefFoundError e) {
@@ -37,8 +35,7 @@
 
 	@Deprecated
 	public static DataLayer getModel() {
-	    if (appGui==null) return null;
-		return getModel(appGui.getSelectedTabIndex());
+        return getModel(appGui.getSelectedTabIndex());
 	}
 
 	@Deprecated
@@ -140,4 +137,6 @@
     }
 
 
+    public static boolean useExtendedBounds = false;
+
 }
 
=== modified file 'src/pipe/gui/DelayEnabledTransitionControl.java'
--- src/pipe/gui/DelayEnabledTransitionControl.java	2020-05-18 14:33:45 +0000
+++ src/pipe/gui/DelayEnabledTransitionControl.java	2020-07-09 12:55:48 +0000
@@ -30,11 +30,11 @@
 	private static BigDecimal defaultGranularity = new BigDecimal("0.1");
 	private static boolean defaultIsRandomTrasition;
 	
-	private JLabel precitionLabel;
-	private JSlider delayEnabledPrecision;
-	private JLabel delayModeLabel;
-	private JComboBox<DelayMode> delayMode;
-	JCheckBox randomMode;
+	private final JLabel precitionLabel;
+	private final JSlider delayEnabledPrecision;
+	private final JLabel delayModeLabel;
+	private final JComboBox<DelayMode> delayMode;
+	final JCheckBox randomMode = new JCheckBox("Choose next transition randomly");
 	
 	private DelayEnabledTransitionControl() {
 		super(new GridBagLayout());
@@ -61,9 +61,8 @@
 		DelayMode[] items = {ShortestDelayMode.getInstance(), RandomDelayMode.getInstance(), ManualDelayMode.getInstance()};
 		delayMode = new JComboBox(items);
 		setDelayMode(defaultDelayMode);
-		
-		randomMode = new JCheckBox("Choose next transition randomly");
-		setRandomTransitionMode(defaultIsRandomTrasition);
+
+        setRandomTransitionMode(defaultIsRandomTrasition);
         
 		GridBagConstraints gbc = new GridBagConstraints();
 		gbc.gridwidth = 2;
 
=== modified file 'src/pipe/gui/GuiFrame.java'
--- src/pipe/gui/GuiFrame.java	2020-06-22 08:06:22 +0000
+++ src/pipe/gui/GuiFrame.java	2020-07-09 12:55:48 +0000
@@ -40,1103 +40,1175 @@
 import dk.aau.cs.verification.VerifyTAPN.VerifyTAPNDiscreteVerification;
 
 
-public class GuiFrame extends JFrame implements GuiFrameActions, SafeGuiFrameActions  {
-
-	// for zoom combobox and dropdown
-	private final int[] zoomLevels = { 40, 60, 80, 100, 120, 140, 160, 180, 200, 300 };
-	
-	private String frameTitle;
-
-	private Pipe.ElementType mode;
-
-	private int newNameCounter = 1;
-
-	final MutableReference<GuiFrameControllerActions> guiFrameController = new MutableReference<>();
-
-	private ExtendedJTabbedPane<TabContent> appTab;
-
-	private StatusBar statusBar;
-	private JMenuBar menuBar;
-	private JToolBar drawingToolBar;
-	private JComboBox<String> zoomComboBox;
-
-	private GuiAction createAction;
-	private GuiAction openAction;
-	private GuiAction closeAction;
-	private GuiAction saveAction;
-	private GuiAction saveAsAction;
-	private GuiAction exitAction;
-	private GuiAction printAction;
-	private GuiAction importPNMLAction;
-	private GuiAction importSUMOAction;
-	private GuiAction importXMLAction;
-	private GuiAction exportPNGAction;
-	private GuiAction exportPSAction;
-	private GuiAction exportToTikZAction;
-	private GuiAction exportToPNMLAction;
-	private GuiAction exportToXMLAction;
-	private GuiAction exportTraceAction;
-	private GuiAction importTraceAction;
-	private GuiAction exportBatchAction;
-
-	private GuiAction /* copyAction, cutAction, pasteAction, */undoAction, redoAction;
-	private GuiAction toggleGrid;
-	private GuiAction alignToGrid;
-	private GuiAction netStatisticsAction;
-	private GuiAction batchProcessingAction;
-	private GuiAction engineSelectionAction;
-	private GuiAction clearPreferencesAction;
-
-	private GuiAction verifyAction;
-	private GuiAction workflowDialogAction;
-	private GuiAction smartDrawAction;
-	private GuiAction mergeComponentsDialogAction;
-	private GuiAction stripTimeDialogAction;
-
-	private GuiAction zoomOutAction;
-	private GuiAction zoomInAction;
-	private GuiAction zoomToAction;
-
-	private GuiAction incSpacingAction;
-	private GuiAction decSpacingAction;
-	public GuiAction deleteAction;
-
-	private GuiAction annotationAction;
-	private GuiAction inhibarcAction;
-	private GuiAction transAction;
-	private GuiAction tokenAction;
-	private GuiAction selectAction;
-	private GuiAction deleteTokenAction;
-	private GuiAction timedPlaceAction;
-
-	private GuiAction timedArcAction;
-	private GuiAction transportArcAction;
-
-	private GuiAction showTokenAgeAction;
-    private GuiAction showComponentsAction;
-    private GuiAction showSharedPTAction;
-	private GuiAction showQueriesAction;
-	private GuiAction showConstantsAction;
-	private GuiAction showZeroToInfinityIntervalsAction;
-	private GuiAction showEnabledTransitionsAction;
-	private GuiAction showDelayEnabledTransitionsAction;
-	private GuiAction showToolTipsAction;
-	private GuiAction showAdvancedWorkspaceAction;
-	private GuiAction showSimpleWorkspaceAction;
-	private GuiAction saveWorkSpaceAction;
-	private GuiAction showAboutAction;
-	private GuiAction showHomepage;
-	private GuiAction showAskQuestionAction;
-	private GuiAction showReportBugAction;
-	private GuiAction showFAQAction;
-	private GuiAction checkUpdate;
-	
-
-	private GuiAction selectAllAction;
-
-	private GuiAction startAction;
-	public GuiAction stepforwardAction;
-	public GuiAction stepbackwardAction;
-	private GuiAction timeAction;
-	private GuiAction delayFireAction;
-	private GuiAction prevcomponentAction;
-	private GuiAction nextcomponentAction;
-
-	public enum GUIMode {
-		draw, animation, noNet
-	}
-
-	private JCheckBoxMenuItem showZeroToInfinityIntervalsCheckBox;
-	private JCheckBoxMenuItem showTokenAgeCheckBox;
-
-	private JMenu zoomMenu;
-
-	public GuiFrame(String title) {
-		// HAK-arrange for frameTitle to be initialized and the default file
-		// name to be appended to basic window title
-
-		frameTitle = title;
-		setTitle(null);
-		trySetLookAndFeel();
-
-		Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
-		this.setSize(screenSize.width * 80 / 100, screenSize.height * 80 / 100);
-		this.setLocationRelativeTo(null);
-		this.setMinimumSize(new Dimension(825, 480));
-
-		setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
-
-		//XXX: Moved appTab from creategui needs further refacotring
-		//kyrke 2018-05-20
-		appTab = new ExtendedJTabbedPane<TabContent>() {
-			@Override
-			public Component generator() {
-				return new TabComponent(this) {
+public class GuiFrame extends JFrame implements GuiFrameActions, SafeGuiFrameActions {
+
+    // for zoom combobox and dropdown
+    private final int[] zoomLevels = {40, 60, 80, 100, 120, 140, 160, 180, 200, 300};
+
+    private String frameTitle;
+
+    private Pipe.ElementType mode;
+
+    private int newNameCounter = 1;
+
+    final MutableReference<GuiFrameControllerActions> guiFrameController = new MutableReference<>();
+
+    private ExtendedJTabbedPane<TabContent> appTab;
+
+    private StatusBar statusBar;
+    private JMenuBar menuBar;
+    private JToolBar drawingToolBar;
+    private JComboBox<String> zoomComboBox;
+
+    private static final int shortcutkey = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
+
+    private final GuiAction createAction = new GuiAction("New", "Create a new Petri net", KeyStroke.getKeyStroke('N', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            guiFrameController.ifPresent(GuiFrameControllerActions::showNewPNDialog);
+        }
+    };
+    private final GuiAction openAction = new GuiAction("Open", "Open", KeyStroke.getKeyStroke('O', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            guiFrameController.ifPresent(GuiFrameControllerActions::openTAPNFile);
+        }
+    };
+    private final GuiAction closeAction = new GuiAction("Close", "Close the current tab", KeyStroke.getKeyStroke('W', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            TabContent index = (TabContent) appTab.getSelectedComponent();
+            guiFrameController.ifPresent(o -> o.closeTab(index));
+        }
+    };
+    private final GuiAction saveAction = new GuiAction("Save", "Save", KeyStroke.getKeyStroke('S', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            if (canNetBeSavedAndShowMessage()) {
+                guiFrameController.ifPresent(GuiFrameControllerActions::save);
+            }
+        }
+    };
+    private final GuiAction saveAsAction = new GuiAction("Save as", "Save as...", KeyStroke.getKeyStroke('S', (shortcutkey + InputEvent.SHIFT_MASK))) {
+        public void actionPerformed(ActionEvent arg0) {
+            if (canNetBeSavedAndShowMessage()) {
+                guiFrameController.ifPresent(GuiFrameControllerActions::saveAs);
+            }
+        }
+    };
+    private final GuiAction exitAction = new GuiAction("Exit", "Close the program", KeyStroke.getKeyStroke('Q', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            guiFrameController.ifPresent(GuiFrameControllerActions::exit);
+        }
+    };
+    private final GuiAction printAction = new GuiAction("Print", "Print", KeyStroke.getKeyStroke('P', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            Export.exportGuiView(getCurrentTab().drawingSurface(), Export.PRINTER, null);
+        }
+    };
+    private final GuiAction importPNMLAction = new GuiAction("PNML untimed net", "Import an untimed net in the PNML format", KeyStroke.getKeyStroke('X', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            guiFrameController.ifPresent(GuiFrameControllerActions::importPNMLFile);
+        }
+    };
+    private final GuiAction importSUMOAction = new GuiAction("SUMO queries (.txt)", "Import SUMO queries in a plain text format") {
+        public void actionPerformed(ActionEvent arg0) {
+            currentTab.ifPresent(TabContentActions::importSUMOQueries);
+        }
+    };
+    private final GuiAction importXMLAction = new GuiAction("XML queries (.xml)", "Import MCC queries in XML format", KeyStroke.getKeyStroke('R', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            currentTab.ifPresent(TabContentActions::importXMLQueries);
+        }
+    };
+    private final GuiAction exportPNGAction = new GuiAction("PNG", "Export the net to PNG format", KeyStroke.getKeyStroke('G', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            if (canNetBeSavedAndShowMessage()) {
+                Export.exportGuiView(getCurrentTab().drawingSurface(), Export.PNG, null);
+            }
+        }
+    };
+    private final GuiAction exportPSAction = new GuiAction("PostScript", "Export the net to PostScript format", KeyStroke.getKeyStroke('T', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            if (canNetBeSavedAndShowMessage()) {
+                Export.exportGuiView(getCurrentTab().drawingSurface(), Export.POSTSCRIPT, null);
+            }
+        }
+    };
+    private final GuiAction exportToTikZAction = new GuiAction("TikZ", "Export the net to LaTex (TikZ) format", KeyStroke.getKeyStroke('L', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            if (canNetBeSavedAndShowMessage()) {
+                Export.exportGuiView(getCurrentTab().drawingSurface(), Export.TIKZ, getCurrentTab().drawingSurface().getGuiModel());
+            }
+        }
+    };
+    private final GuiAction exportToPNMLAction = new GuiAction("PNML", "Export the net to PNML format", KeyStroke.getKeyStroke('D', shortcutkey)) {
+        public void actionPerformed(ActionEvent arg0) {
+            if (canNetBeSavedAndShowMessage()) {
+                if (Preferences.getInstance().getShowPNMLWarning()) {
+                    JCheckBox showAgain = new JCheckBox("Do not show this warning.");
+                    String message = "In the saved PNML all timing information will be lost\n" +