← Back to branch summary

~peta-power-group/+junk/vIDE-trunk

« back to all changes in this revision

Viewing changes to net.launchpad.vide.diagram/src/net/launchpad/vide/flowchart/diagram/navigator/FlowchartNavigatorContentProvider.java

  • Committer: Dražen Lučanin
  • Date: 2010-11-11 16:39:46 UTC
  • Revision ID: kermit666@gmail.com-20101111163946-c1cmu5z600jk3wki
First working version of the graphical editor.

Show diffs side-by-side

added added

removed removed

Lines of Context:
net.launchpad.vide.diagram/src/net/launchpad/vide/flowchart/diagram/navigator/FlowchartNavigatorContentProvider.java
 
1
package net.launchpad.vide.flowchart.diagram.navigator;
 
2
 
 
3
import java.util.ArrayList;
 
4
import java.util.Collection;
 
5
import java.util.Collections;
 
6
import java.util.HashMap;
 
7
import java.util.LinkedList;
 
8
 
 
9
import net.launchpad.vide.flowchart.diagram.edit.parts.FunctionalCommandEditPart;
 
10
import net.launchpad.vide.flowchart.diagram.edit.parts.FunctionalCommandOutputEditPart;
 
11
import net.launchpad.vide.flowchart.diagram.edit.parts.ProgramEditPart;
 
12
import net.launchpad.vide.flowchart.diagram.part.FlowchartVisualIDRegistry;
 
13
import net.launchpad.vide.flowchart.diagram.part.Messages;
 
14
 
 
15
import org.eclipse.core.resources.IFile;
 
16
import org.eclipse.emf.common.util.URI;
 
17
import org.eclipse.emf.ecore.EObject;
 
18
import org.eclipse.emf.ecore.resource.Resource;
 
19
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
 
20
import org.eclipse.emf.transaction.TransactionalEditingDomain;
 
21
import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
 
22
import org.eclipse.gmf.runtime.emf.core.GMFEditingDomainFactory;
 
23
import org.eclipse.gmf.runtime.notation.Diagram;
 
24
import org.eclipse.gmf.runtime.notation.Edge;
 
25
import org.eclipse.gmf.runtime.notation.Node;
 
26
import org.eclipse.gmf.runtime.notation.View;
 
27
import org.eclipse.jface.viewers.Viewer;
 
28
import org.eclipse.ui.IMemento;
 
29
import org.eclipse.ui.navigator.ICommonContentExtensionSite;
 
30
import org.eclipse.ui.navigator.ICommonContentProvider;
 
31
 
 
32
/**
 
33
 * @generated
 
34
 */
 
35
public class FlowchartNavigatorContentProvider implements
 
36
                ICommonContentProvider {
 
37
 
 
38
        /**
 
39
         * @generated
 
40
         */
 
41
        private static final Object[] EMPTY_ARRAY = new Object[0];
 
42
 
 
43
        /**
 
44
         * @generated
 
45
         */
 
46
        private Viewer myViewer;
 
47
 
 
48
        /**
 
49
         * @generated
 
50
         */
 
51
        private AdapterFactoryEditingDomain myEditingDomain;
 
52
 
 
53
        /**
 
54
         * @generated
 
55
         */
 
56
        private WorkspaceSynchronizer myWorkspaceSynchronizer;
 
57
 
 
58
        /**
 
59
         * @generated
 
60
         */
 
61
        private Runnable myViewerRefreshRunnable;
 
62
 
 
63
        /**
 
64
         * @generated
 
65
         */
 
66
        @SuppressWarnings({ "unchecked", "serial", "rawtypes" })
 
67
        public FlowchartNavigatorContentProvider() {
 
68
                TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE
 
69
                                .createEditingDomain();
 
70
                myEditingDomain = (AdapterFactoryEditingDomain) editingDomain;
 
71
                myEditingDomain.setResourceToReadOnlyMap(new HashMap() {
 
72
                        public Object get(Object key) {
 
73
                                if (!containsKey(key)) {
 
74
                                        put(key, Boolean.TRUE);
 
75
                                }
 
76
                                return super.get(key);
 
77
                        }
 
78
                });
 
79
                myViewerRefreshRunnable = new Runnable() {
 
80
                        public void run() {
 
81
                                if (myViewer != null) {
 
82
                                        myViewer.refresh();
 
83
                                }
 
84
                        }
 
85
                };
 
86
                myWorkspaceSynchronizer = new WorkspaceSynchronizer(editingDomain,
 
87
                                new WorkspaceSynchronizer.Delegate() {
 
88
                                        public void dispose() {
 
89
                                        }
 
90
 
 
91
                                        public boolean handleResourceChanged(final Resource resource) {
 
92
                                                unloadAllResources();
 
93
                                                asyncRefresh();
 
94
                                                return true;
 
95
                                        }
 
96
 
 
97
                                        public boolean handleResourceDeleted(Resource resource) {
 
98
                                                unloadAllResources();
 
99
                                                asyncRefresh();
 
100
                                                return true;
 
101
                                        }
 
102
 
 
103
                                        public boolean handleResourceMoved(Resource resource,
 
104
                                                        final URI newURI) {
 
105
                                                unloadAllResources();
 
106
                                                asyncRefresh();
 
107
                                                return true;
 
108
                                        }
 
109
                                });
 
110
        }
 
111
 
 
112
        /**
 
113
         * @generated
 
114
         */
 
115
        public void dispose() {
 
116
                myWorkspaceSynchronizer.dispose();
 
117
                myWorkspaceSynchronizer = null;
 
118
                myViewerRefreshRunnable = null;
 
119
                myViewer = null;
 
120
                unloadAllResources();
 
121
                ((TransactionalEditingDomain) myEditingDomain).dispose();
 
122
                myEditingDomain = null;
 
123
        }
 
124
 
 
125
        /**
 
126
         * @generated
 
127
         */
 
128
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 
129
                myViewer = viewer;
 
130
        }
 
131
 
 
132
        /**
 
133
         * @generated
 
134
         */
 
135
        void unloadAllResources() {
 
136
                for (Resource nextResource : myEditingDomain.getResourceSet()
 
137
                                .getResources()) {
 
138
                        nextResource.unload();
 
139
                }
 
140
        }
 
141
 
 
142
        /**
 
143
         * @generated
 
144
         */
 
145
        void asyncRefresh() {
 
146
                if (myViewer != null && !myViewer.getControl().isDisposed()) {
 
147
                        myViewer.getControl().getDisplay()
 
148
                                        .asyncExec(myViewerRefreshRunnable);
 
149
                }
 
150
        }
 
151
 
 
152
        /**
 
153
         * @generated
 
154
         */
 
155
        public Object[] getElements(Object inputElement) {
 
156
                return getChildren(inputElement);
 
157
        }
 
158
 
 
159
        /**
 
160
         * @generated
 
161
         */
 
162
        public void restoreState(IMemento aMemento) {
 
163
        }
 
164
 
 
165
        /**
 
166
         * @generated
 
167
         */
 
168
        public void saveState(IMemento aMemento) {
 
169
        }
 
170
 
 
171
        /**
 
172
         * @generated
 
173
         */
 
174
        public void init(ICommonContentExtensionSite aConfig) {
 
175
        }
 
176
 
 
177
        /**
 
178
         * @generated
 
179
         */
 
180
        public Object[] getChildren(Object parentElement) {
 
181
                if (parentElement instanceof IFile) {
 
182
                        IFile file = (IFile) parentElement;
 
183
                        URI fileURI = URI.createPlatformResourceURI(file.getFullPath()
 
184
                                        .toString(), true);
 
185
                        Resource resource = myEditingDomain.getResourceSet().getResource(
 
186
                                        fileURI, true);
 
187
                        ArrayList<FlowchartNavigatorItem> result = new ArrayList<FlowchartNavigatorItem>();
 
188
                        ArrayList<View> topViews = new ArrayList<View>(resource
 
189
                                        .getContents().size());
 
190
                        for (EObject o : resource.getContents()) {
 
191
                                if (o instanceof View) {
 
192
                                        topViews.add((View) o);
 
193
                                }
 
194
                        }
 
195
                        result.addAll(createNavigatorItems(
 
196
                                        selectViewsByType(topViews, ProgramEditPart.MODEL_ID),
 
197
                                        file, false));
 
198
                        return result.toArray();
 
199
                }
 
200
 
 
201
                if (parentElement instanceof FlowchartNavigatorGroup) {
 
202
                        FlowchartNavigatorGroup group = (FlowchartNavigatorGroup) parentElement;
 
203
                        return group.getChildren();
 
204
                }
 
205
 
 
206
                if (parentElement instanceof FlowchartNavigatorItem) {
 
207
                        FlowchartNavigatorItem navigatorItem = (FlowchartNavigatorItem) parentElement;
 
208
                        if (navigatorItem.isLeaf() || !isOwnView(navigatorItem.getView())) {
 
209
                                return EMPTY_ARRAY;
 
210
                        }
 
211
                        return getViewChildren(navigatorItem.getView(), parentElement);
 
212
                }
 
213
 
 
214
                return EMPTY_ARRAY;
 
215
        }
 
216
 
 
217
        /**
 
218
         * @generated
 
219
         */
 
220
        private Object[] getViewChildren(View view, Object parentElement) {
 
221
                switch (FlowchartVisualIDRegistry.getVisualID(view)) {
 
222
 
 
223
                case FunctionalCommandOutputEditPart.VISUAL_ID: {
 
224
                        LinkedList<FlowchartAbstractNavigatorItem> result = new LinkedList<FlowchartAbstractNavigatorItem>();
 
225
                        Edge sv = (Edge) view;
 
226
                        FlowchartNavigatorGroup target = new FlowchartNavigatorGroup(
 
227
                                        Messages.NavigatorGroupName_FunctionalCommandOutput_4001_target,
 
228
                                        "icons/linkTargetNavigatorGroup.gif", parentElement); //$NON-NLS-1$
 
229
                        FlowchartNavigatorGroup source = new FlowchartNavigatorGroup(
 
230
                                        Messages.NavigatorGroupName_FunctionalCommandOutput_4001_source,
 
231
                                        "icons/linkSourceNavigatorGroup.gif", parentElement); //$NON-NLS-1$
 
232
                        Collection<View> connectedViews;
 
233
                        connectedViews = getLinksTargetByType(Collections.singleton(sv),
 
234
                                        FlowchartVisualIDRegistry
 
235
                                                        .getType(FunctionalCommandEditPart.VISUAL_ID));
 
236
                        target.addChildren(createNavigatorItems(connectedViews, target,
 
237
                                        true));
 
238
                        connectedViews = getLinksSourceByType(Collections.singleton(sv),
 
239
                                        FlowchartVisualIDRegistry
 
240
                                                        .getType(FunctionalCommandEditPart.VISUAL_ID));
 
241
                        source.addChildren(createNavigatorItems(connectedViews, source,
 
242
                                        true));
 
243
                        if (!target.isEmpty()) {
 
244
                                result.add(target);
 
245
                        }
 
246
                        if (!source.isEmpty()) {
 
247
                                result.add(source);
 
248
                        }
 
249
                        return result.toArray();
 
250
                }
 
251
 
 
252
                case ProgramEditPart.VISUAL_ID: {
 
253
                        LinkedList<FlowchartAbstractNavigatorItem> result = new LinkedList<FlowchartAbstractNavigatorItem>();
 
254
                        Diagram sv = (Diagram) view;
 
255
                        FlowchartNavigatorGroup links = new FlowchartNavigatorGroup(
 
256
                                        Messages.NavigatorGroupName_Program_1000_links,
 
257
                                        "icons/linksNavigatorGroup.gif", parentElement); //$NON-NLS-1$
 
258
                        Collection<View> connectedViews;
 
259
                        connectedViews = getChildrenByType(Collections.singleton(sv),
 
260
                                        FlowchartVisualIDRegistry
 
261
                                                        .getType(FunctionalCommandEditPart.VISUAL_ID));
 
262
                        result.addAll(createNavigatorItems(connectedViews, parentElement,
 
263
                                        false));
 
264
                        connectedViews = getDiagramLinksByType(Collections.singleton(sv),
 
265
                                        FlowchartVisualIDRegistry
 
266
                                                        .getType(FunctionalCommandOutputEditPart.VISUAL_ID));
 
267
                        links.addChildren(createNavigatorItems(connectedViews, links, false));
 
268
                        if (!links.isEmpty()) {
 
269
                                result.add(links);
 
270
                        }
 
271
                        return result.toArray();
 
272
                }
 
273
 
 
274
                case FunctionalCommandEditPart.VISUAL_ID: {
 
275
                        LinkedList<FlowchartAbstractNavigatorItem> result = new LinkedList<FlowchartAbstractNavigatorItem>();
 
276
                        Node sv = (Node) view;
 
277
                        FlowchartNavigatorGroup incominglinks = new FlowchartNavigatorGroup(
 
278
                                        Messages.NavigatorGroupName_FunctionalCommand_2001_incominglinks,
 
279
                                        "icons/incomingLinksNavigatorGroup.gif", parentElement); //$NON-NLS-1$
 
280
                        FlowchartNavigatorGroup outgoinglinks = new FlowchartNavigatorGroup(
 
281
                                        Messages.NavigatorGroupName_FunctionalCommand_2001_outgoinglinks,
 
282
                                        "icons/outgoingLinksNavigatorGroup.gif", parentElement); //$NON-NLS-1$
 
283
                        Collection<View> connectedViews;
 
284
                        connectedViews = getIncomingLinksByType(Collections.singleton(sv),
 
285
                                        FlowchartVisualIDRegistry
 
286
                                                        .getType(FunctionalCommandOutputEditPart.VISUAL_ID));
 
287
                        incominglinks.addChildren(createNavigatorItems(connectedViews,
 
288
                                        incominglinks, true));
 
289
                        connectedViews = getOutgoingLinksByType(Collections.singleton(sv),
 
290
                                        FlowchartVisualIDRegistry
 
291
                                                        .getType(FunctionalCommandOutputEditPart.VISUAL_ID));
 
292
                        outgoinglinks.addChildren(createNavigatorItems(connectedViews,
 
293
                                        outgoinglinks, true));
 
294
                        if (!incominglinks.isEmpty()) {
 
295
                                result.add(incominglinks);
 
296
                        }
 
297
                        if (!outgoinglinks.isEmpty()) {
 
298
                                result.add(outgoinglinks);
 
299
                        }
 
300
                        return result.toArray();
 
301
                }
 
302
                }
 
303
                return EMPTY_ARRAY;
 
304
        }
 
305
 
 
306
        /**
 
307
         * @generated
 
308
         */
 
309
        private Collection<View> getLinksSourceByType(Collection<Edge> edges,
 
310
                        String type) {
 
311
                LinkedList<View> result = new LinkedList<View>();
 
312
                for (Edge nextEdge : edges) {
 
313
                        View nextEdgeSource = nextEdge.getSource();
 
314
                        if (type.equals(nextEdgeSource.getType())
 
315
                                        && isOwnView(nextEdgeSource)) {
 
316
                                result.add(nextEdgeSource);
 
317
                        }
 
318
                }
 
319
                return result;
 
320
        }
 
321
 
 
322
        /**
 
323
         * @generated
 
324
         */
 
325
        private Collection<View> getLinksTargetByType(Collection<Edge> edges,
 
326
                        String type) {
 
327
                LinkedList<View> result = new LinkedList<View>();
 
328
                for (Edge nextEdge : edges) {
 
329
                        View nextEdgeTarget = nextEdge.getTarget();
 
330
                        if (type.equals(nextEdgeTarget.getType())
 
331
                                        && isOwnView(nextEdgeTarget)) {
 
332
                                result.add(nextEdgeTarget);
 
333
                        }
 
334
                }
 
335
                return result;
 
336
        }
 
337
 
 
338
        /**
 
339
         * @generated
 
340
         */
 
341
        private Collection<View> getOutgoingLinksByType(
 
342
                        Collection<? extends View> nodes, String type) {
 
343
                LinkedList<View> result = new LinkedList<View>();
 
344
                for (View nextNode : nodes) {
 
345
                        result.addAll(selectViewsByType(nextNode.getSourceEdges(), type));
 
346
                }
 
347
                return result;
 
348
        }
 
349
 
 
350
        /**
 
351
         * @generated
 
352
         */
 
353
        private Collection<View> getIncomingLinksByType(
 
354
                        Collection<? extends View> nodes, String type) {
 
355
                LinkedList<View> result = new LinkedList<View>();
 
356
                for (View nextNode : nodes) {
 
357
                        result.addAll(selectViewsByType(nextNode.getTargetEdges(), type));
 
358
                }
 
359
                return result;
 
360
        }
 
361
 
 
362
        /**
 
363
         * @generated
 
364
         */
 
365
        private Collection<View> getChildrenByType(
 
366
                        Collection<? extends View> nodes, String type) {
 
367
                LinkedList<View> result = new LinkedList<View>();
 
368
                for (View nextNode : nodes) {
 
369
                        result.addAll(selectViewsByType(nextNode.getChildren(), type));
 
370
                }
 
371
                return result;
 
372
        }
 
373
 
 
374
        /**
 
375
         * @generated
 
376
         */
 
377
        private Collection<View> getDiagramLinksByType(
 
378
                        Collection<Diagram> diagrams, String type) {
 
379
                ArrayList<View> result = new ArrayList<View>();
 
380
                for (Diagram nextDiagram : diagrams) {
 
381
                        result.addAll(selectViewsByType(nextDiagram.getEdges(), type));
 
382
                }
 
383
                return result;
 
384
        }
 
385
 
 
386
        // TODO refactor as static method
 
387
        /**
 
388
         * @generated
 
389
         */
 
390
        private Collection<View> selectViewsByType(Collection<View> views,
 
391
                        String type) {
 
392
                ArrayList<View> result = new ArrayList<View>();
 
393
                for (View nextView : views) {
 
394
                        if (type.equals(nextView.getType()) && isOwnView(nextView)) {
 
395
                                result.add(nextView);
 
396
                        }
 
397
                }
 
398
                return result;
 
399
        }
 
400
 
 
401
        /**
 
402
         * @generated
 
403
         */
 
404
        private boolean isOwnView(View view) {
 
405
                return ProgramEditPart.MODEL_ID.equals(FlowchartVisualIDRegistry
 
406
                                .getModelID(view));
 
407
        }
 
408
 
 
409
        /**
 
410
         * @generated
 
411
         */
 
412
        private Collection<FlowchartNavigatorItem> createNavigatorItems(
 
413
                        Collection<View> views, Object parent, boolean isLeafs) {
 
414
                ArrayList<FlowchartNavigatorItem> result = new ArrayList<FlowchartNavigatorItem>(
 
415
                                views.size());
 
416
                for (View nextView : views) {
 
417
                        result.add(new FlowchartNavigatorItem(nextView, parent, isLeafs));
 
418
                }
 
419
                return result;
 
420
        }
 
421
 
 
422
        /**
 
423
         * @generated
 
424
         */
 
425
        public Object getParent(Object element) {
 
426
                if (element instanceof FlowchartAbstractNavigatorItem) {
 
427
                        FlowchartAbstractNavigatorItem abstractNavigatorItem = (FlowchartAbstractNavigatorItem) element;
 
428
                        return abstractNavigatorItem.getParent();
 
429
                }
 
430
                return null;
 
431
        }
 
432
 
 
433
        /**
 
434
         * @generated
 
435
         */
 
436
        public boolean hasChildren(Object element) {
 
437
                return element instanceof IFile || getChildren(element).length > 0;
 
438
        }
 
439
 
 
440
}