← Back to branch summary

~tapaal-contributor/tapaal/disappearing-tokens-1940098

« back to all changes in this revision

Viewing changes to src/pipe/dataLayer/TimedTransitionComponent.java

  • Committer: Kenneth Yrke Jørgensen
  • Date: 2011-04-12 09:50:16 UTC
  • mfrom: (329.1.188 tapaal-1.5)
  • Revision ID: mail@yrke.dk-20110412095016-e4hqdgab5596ja09
Merged with branch addning support for new 1.5 features

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pipe/dataLayer/TimedTransitionComponent.java
 
1
package pipe.dataLayer;
 
2
 
 
3
import java.awt.BasicStroke;
 
4
import java.awt.Container;
 
5
import java.awt.Graphics;
 
6
import java.awt.Graphics2D;
 
7
import java.awt.RenderingHints;
 
8
import java.awt.Stroke;
 
9
import java.awt.geom.AffineTransform;
 
10
import java.awt.geom.GeneralPath;
 
11
import java.awt.geom.Rectangle2D;
 
12
 
 
13
import javax.swing.BoxLayout;
 
14
 
 
15
import pipe.gui.CreateGui;
 
16
import pipe.gui.DrawingSurfaceImpl;
 
17
import pipe.gui.Pipe;
 
18
import pipe.gui.handler.AnimationHandler;
 
19
import pipe.gui.handler.LabelHandler;
 
20
import pipe.gui.handler.TAPNTransitionHandler;
 
21
import pipe.gui.handler.TransitionHandler;
 
22
import pipe.gui.widgets.EscapableDialog;
 
23
import pipe.gui.widgets.TAPNTransitionEditor;
 
24
import dk.aau.cs.gui.Context;
 
25
import dk.aau.cs.gui.undo.Command;
 
26
import dk.aau.cs.model.tapn.TimedArcPetriNet;
 
27
import dk.aau.cs.model.tapn.TimedTransition;
 
28
import dk.aau.cs.model.tapn.event.TimedTransitionEvent;
 
29
import dk.aau.cs.model.tapn.event.TimedTransitionListener;
 
30
 
 
31
public class TimedTransitionComponent extends Transition {
 
32
        private static final long serialVersionUID = -2280012053262288174L;
 
33
        private dk.aau.cs.model.tapn.TimedTransition transition;
 
34
        private dk.aau.cs.model.tapn.event.TimedTransitionListener listener;
 
35
        private GeneralPath dashedOutline;
 
36
 
 
37
        public TimedTransitionComponent(double positionXInput, double positionYInput,
 
38
                        dk.aau.cs.model.tapn.TimedTransition transition) {
 
39
                super(positionXInput, positionYInput);
 
40
                this.transition = transition;
 
41
                this.listener = timedTransitionListener();
 
42
                transition.addTimedTransitionListener(listener);
 
43
        }
 
44
 
 
45
        public TimedTransitionComponent(double positionXInput,
 
46
                        double positionYInput, String idInput, String nameInput,
 
47
                        double nameOffsetXInput, double nameOffsetYInput,
 
48
                        boolean timedTransition, boolean infServer, int angleInput,
 
49
                        int priority) {
 
50
                super(positionXInput, positionYInput, idInput, nameInput,
 
51
                                nameOffsetXInput, nameOffsetYInput, timedTransition, infServer,
 
52
                                angleInput, priority);
 
53
                this.listener = timedTransitionListener();
 
54
                //transition = new dk.aau.cs.model.tapn.TimedTransition(nameInput);
 
55
        }
 
56
        
 
57
        private TimedTransitionListener timedTransitionListener(){
 
58
                return new TimedTransitionListener() {
 
59
                        public void nameChanged(TimedTransitionEvent e) {
 
60
                                TimedTransition source = e.source();
 
61
                                TimedTransitionComponent.super.setName(source.name());
 
62
                        }
 
63
 
 
64
                        public void sharedStateChanged(TimedTransitionEvent e) { repaint(); }
 
65
                };
 
66
        }
 
67
 
 
68
        @Override
 
69
        public void delete() {
 
70
                if (transition != null)
 
71
                        transition.delete();
 
72
                super.delete();
 
73
        }
 
74
 
 
75
        @Override
 
76
        public void showEditor() {
 
77
                // Build interface
 
78
                EscapableDialog guiDialog = new EscapableDialog(CreateGui.getApp(),
 
79
                                Pipe.getProgramName(), true);
 
80
 
 
81
                Container contentPane = guiDialog.getContentPane();
 
82
 
 
83
                // 1 Set layout
 
84
                contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.PAGE_AXIS));
 
85
 
 
86
                // 2 Add Place editor
 
87
                contentPane.add(new TAPNTransitionEditor(guiDialog.getRootPane(), this, new Context(CreateGui.getCurrentTab())));
 
88
 
 
89
                guiDialog.setResizable(true);
 
90
 
 
91
                // Make window fit contents' preferred size
 
92
                guiDialog.pack();
 
93
 
 
94
                // Move window to the middle of the screen
 
95
                guiDialog.setLocationRelativeTo(null);
 
96
                guiDialog.setVisible(true);
 
97
        }
 
98
 
 
99
//      @Override
 
100
//      public boolean isEnabled(boolean animationStatus) {
 
101
//              if (animationStatus) {
 
102
//                      if (isEnabled()) {
 
103
//                              highlighted = true;
 
104
//                              return true;
 
105
//                      } else {
 
106
//                              highlighted = false;
 
107
//                      }
 
108
//              }
 
109
//              return false;
 
110
//      }
 
111
 
 
112
        @Override
 
113
        public boolean isEnabled() {
 
114
                return transition.isEnabled();
 
115
        }
 
116
 
 
117
        public dk.aau.cs.model.tapn.TimedTransition underlyingTransition() {
 
118
                return transition;
 
119
        }
 
120
 
 
121
        public void setUnderlyingTransition(TimedTransition transition) {
 
122
                if(this.transition != null && listener != null){
 
123
                        transition.removeListener(listener);
 
124
                }
 
125
                transition.addTimedTransitionListener(listener);
 
126
                this.transition = transition;
 
127
                this.setName(transition.name());
 
128
                repaint();
 
129
        }
 
130
 
 
131
        @Override
 
132
        public void setName(String nameInput) {
 
133
                transition.setName(nameInput);
 
134
                super.setName(nameInput);
 
135
        }
 
136
        
 
137
        public String getName() {
 
138
                return transition != null ? transition.name() : "";
 
139
        }
 
140
        
 
141
        @Override
 
142
        public void update(boolean displayConstantNames) {
 
143
                if(transition != null) {
 
144
                        pnName.setName(transition.name());
 
145
                        pnName.zoomUpdate(zoom);
 
146
                }
 
147
                else {
 
148
                        pnName.setText("");
 
149
                }
 
150
                //updateBounds();
 
151
                //updateLabelLocation();
 
152
                //updateConnected();
 
153
                
 
154
                repaint();
 
155
        }
 
156
        
 
157
        @Override
 
158
        public void paintComponent(Graphics g) {
 
159
                super.paintComponent(g);
 
160
                if(transition.isShared()){
 
161
                        Graphics2D graphics = (Graphics2D)g;
 
162
                        Stroke oldStroke = graphics.getStroke();
 
163
                        
 
164
                        BasicStroke dashed = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 1.0f, new float[] {5.0f}, 0.0f);
 
165
                        graphics.setStroke(dashed);
 
166
                        
 
167
                        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 
168
                        graphics.draw(dashedOutline);
 
169
                                                
 
170
                        graphics.setStroke(oldStroke);
 
171
                }
 
172
        }
 
173
        
 
174
        @Override
 
175
        protected void constructTransition() {
 
176
                super.constructTransition();
 
177
                double x = ((componentWidth - TRANSITION_WIDTH - Pipe.DASHED_PADDING) / 2);
 
178
                double y = -Pipe.DASHED_PADDING/2;
 
179
                double width = TRANSITION_WIDTH + Pipe.DASHED_PADDING;
 
180
                double height = TRANSITION_HEIGHT + Pipe.DASHED_PADDING;
 
181
                dashedOutline = new GeneralPath(new Rectangle2D.Double(x, y, width, height));
 
182
        }
 
183
        
 
184
        @Override
 
185
        public Command rotate(int angleInc) {
 
186
                dashedOutline.transform(AffineTransform.getRotateInstance(Math.toRadians(angleInc), (componentWidth) / 2, (componentHeight)  / 2));
 
187
                return super.rotate(angleInc);
 
188
        }
 
189
 
 
190
        public TimedTransitionComponent copy(TimedArcPetriNet tapn, DataLayer guiModel) {
 
191
                TimedTransitionComponent transitionComponent = new TimedTransitionComponent(positionX, positionY, id, transition.name(), nameOffsetX, nameOffsetY, true, isInfiniteServer(), getAngle(), getPriority());
 
192
                transitionComponent.setUnderlyingTransition(tapn.getTransitionByName(transition.name()));
 
193
                
 
194
                LabelHandler labelHandler = new LabelHandler(transitionComponent.getNameLabel(), transitionComponent);
 
195
                transitionComponent.getNameLabel().addMouseListener(labelHandler);
 
196
                transitionComponent.getNameLabel().addMouseMotionListener(labelHandler);
 
197
                transitionComponent.getNameLabel().addMouseWheelListener(labelHandler);
 
198
                
 
199
                TransitionHandler transitionHandler = new TAPNTransitionHandler((DrawingSurfaceImpl)getParent(), transitionComponent, guiModel, tapn);
 
200
                transitionComponent.addMouseListener(transitionHandler);
 
201
                transitionComponent.addMouseMotionListener(transitionHandler);
 
202
                transitionComponent.addMouseWheelListener(transitionHandler);
 
203
 
 
204
                transitionComponent.addMouseListener(new AnimationHandler());
 
205
        
 
206
                transitionComponent.setGuiModel(guiModel);
 
207
                
 
208
                return transitionComponent;
 
209
        }
 
210
 
 
211
}