← Back to branch summary

~danilovesky/workcraft/trunk-menu-tools

« back to all changes in this revision

Viewing changes to SONPlugin/src/org/workcraft/plugins/son/gui/ParallelSimDialog.java

  • Committer: Danil Sokolov
  • Date: 2015-05-15 15:46:50 UTC
  • mfrom: (599.1.8 trunk-son-mbson)
  • Revision ID: danilovesky@gmail.com-20150515154650-es3cqmx1x1d4p757
Merge proposal for blueprint son-bson-extension approved.

Show diffs side-by-side

added added

removed removed

Lines of Context:
SONPlugin/src/org/workcraft/plugins/son/gui/ParallelSimDialog.java
44
44
        
45
45
        private SON net;
46
46
        
47
 
        boolean reverse = false;
48
 
        private List<TransitionNode> possibleFires, minFires, maxFires;
 
47
        boolean isRev = false;
 
48
        private Color color = new Color(255, 228, 181);
 
49
        private List<TransitionNode> possibleFire, minFire;
49
50
        private TransitionNode clickedEvent;
50
51
        
51
52
        private JPanel eventPanel, interfacePanel, buttonsPanel, eventInfoPanel;
122
123
                                                
123
124
                DefaultListModel listModel = new DefaultListModel();
124
125
 
125
 
                for(TransitionNode event : this.possibleFires){
126
 
                        EventItem item = new EventItem(net.getNodeReference(event)+"  "+event.getLabel(), event, possibleFires);
 
126
                for(TransitionNode event : this.possibleFire){
 
127
                        EventItem item = new EventItem(net.getNodeReference(event)+"  "+event.getLabel(), event, possibleFire);
127
128
                        listModel.addElement(item);
128
129
                }
129
130
                
154
155
                                                if(item.isSelected() ){
155
156
                                                        selectedEvents.add(item.getEvent());
156
157
                                                        
157
 
                                                        List<TransitionNode> set;
158
 
                                                        if(!reverse)
159
 
                                                                set = simuAlg.getMinFires(item.getEvent(), sync, possibleFires);
160
 
                                                        else
161
 
                                                                set = simuAlg.getMaxFires(item.getEvent(), sync, possibleFires);
 
158
                                                        List<TransitionNode> minFire = simuAlg.getMinFire(item.getEvent(), sync, possibleFire, isRev);
162
159
                                                        
163
 
                                                        for(TransitionNode e : set){
 
160
                                                        for(TransitionNode e : minFire){
164
161
                                                                for(EventItem eventItem : itemList){
165
162
                                                                        if(e==eventItem.getEvent()){
166
163
                                                                                selectedEvents.add(e);
167
164
                                                                                eventItem.setSelected(true);
168
 
                                                                                eventItem.setForegroudColor(Color.BLUE);
 
165
                                                                                eventItem.setFillColor(color);
169
166
                                                                        }       
170
167
                                                                }
171
168
                                                        }
172
 
                                                        item.setForegroudColor(Color.BLUE);     
 
169
                                                        item.setFillColor(color);       
173
170
                                                }
174
171
                                                
175
172
                                                if(!item.isSelected() ){
176
173
                                                        selectedEvents.remove(item.getEvent());
177
174
                                                        
178
 
                                                        List<TransitionNode> set;
179
 
                                                        if(!reverse)
180
 
                                                                set = simuAlg.getMaxFires(item.getEvent(), sync, possibleFires);
181
 
                                                        else
182
 
                                                                set = simuAlg.getMinFires(item.getEvent(), sync, possibleFires);
 
175
                                                        List<TransitionNode> minFire = simuAlg.getMinFire(item.getEvent(), sync, possibleFire, !isRev);
183
176
 
184
177
                                                                //unselected related synchronous events.
185
 
                                                        for(TransitionNode e : set){
 
178
                                                        for(TransitionNode e : minFire){
186
179
                                                                for(EventItem eventItem : itemList){
187
180
                                                                        if(e==eventItem.getEvent()){
188
181
                                                                                selectedEvents.remove(e);
189
182
                                                                                eventItem.setSelected(false);
190
 
                                                                                eventItem.setForegroudColor(CommonSimulationSettings.getEnabledForegroundColor());
 
183
                                                                                eventItem.setFillColor(Color.WHITE);
191
184
                                                                        }       
192
185
                                                                }
193
186
                                                        }
194
187
                                                        
195
 
                                                        item.setForegroudColor(CommonSimulationSettings.getEnabledForegroundColor());
 
188
                                                        item.setFillColor(Color.WHITE);
196
189
                                                }
197
190
                                                
198
191
                                                for(int i=0; i<list.getModel().getSize(); i++)
263
256
        }
264
257
        
265
258
        private String[][] createData(){
266
 
                String dataVal[][] = new String[this.minFires.size()+1][2];
 
259
                String dataVal[][] = new String[this.minFire.size()+1][2];
267
260
                
268
261
                dataVal[0][0] = net.getNodeReference(clickedEvent)+ "(clicked)";
269
262
                dataVal[0][1] = this.clickedEvent.getLabel();
270
263
                
271
 
                if(!minFires.isEmpty()){
272
 
                        for(int i=1 ; i < minFires.size()+1; i++)
273
 
                                dataVal[i][0]=net.getNodeReference(minFires.get(i-1));
274
 
                        for(int i=1 ; i < minFires.size()+1; i++)
275
 
                                dataVal[i][1] = minFires.get(i-1).getLabel();
 
264
                if(!minFire.isEmpty()){
 
265
                        for(int i=1 ; i < minFire.size()+1; i++)
 
266
                                dataVal[i][0]=net.getNodeReference(minFire.get(i-1));
 
267
                        for(int i=1 ; i < minFire.size()+1; i++)
 
268
                                dataVal[i][1] = minFire.get(i-1).getLabel();
276
269
                }
277
270
                                
278
271
                return dataVal; 
280
273
        }
281
274
        
282
275
        public  ParallelSimDialog (Window owner, SON net, 
283
 
                        List<TransitionNode> possibleFires, List<TransitionNode> minFires, 
284
 
                        List<TransitionNode> maxFires, TransitionNode event, boolean reverse,
 
276
                        List<TransitionNode> possibleFire, List<TransitionNode> minFire, 
 
277
                        TransitionNode event, boolean isRev,
285
278
                        Collection<Path> sync){
286
279
                super(owner, "Parallel Execution Setting", ModalityType.TOOLKIT_MODAL);
287
280
                
288
281
                this.net = net;
289
 
                this.reverse = reverse;
290
 
                this.possibleFires = possibleFires;
291
 
                this.minFires = minFires;
292
 
                this.maxFires = maxFires;
 
282
                this.isRev = isRev;
 
283
                this.possibleFire = possibleFire;
 
284
                this.minFire = minFire;
293
285
                this.clickedEvent = event;
294
286
                this.sync = sync;
295
287
                
296
 
                setEventsColor(minFires, event);
 
288
                setColor(minFire, event);
297
289
 
298
290
                //this.setSize(new Dimension(280, 260));
299
291
                createButtonsPanel();
331
323
                
332
324
        }
333
325
        
334
 
        private void setEventsColor(List<TransitionNode> preEvents, TransitionNode event){
335
 
                event.setForegroundColor(Color.BLUE);
 
326
        private void setColor(List<TransitionNode> preEvents, TransitionNode event){
 
327
                event.setFillColor(color);
336
328
                for(TransitionNode e : preEvents)
337
 
                        e.setForegroundColor(Color.BLUE);
 
329
                        e.setFillColor(color);
338
330
        }
339
331
        
340
332
        public SON getSONModel(){