UI locking fixes for GraphExplorer implementations
[simantics/platform.git] / bundles / org.simantics.browsing.ui.swt / src / org / simantics / browsing / ui / swt / GraphExplorerImpl2.java
1 /*******************************************************************************
2  * Copyright (c) 2013 Association for Decentralized Information Management
3  * in Industry THTH ry.
4  * All rights reserved. This program and the accompanying materials
5  * are made available under the terms of the Eclipse Public License v1.0
6  * which accompanies this distribution, and is available at
7  * http://www.eclipse.org/legal/epl-v10.html
8  *
9  * Contributors:
10  *     VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.browsing.ui.swt;
13
14 import java.util.ArrayList;
15 import java.util.Arrays;
16 import java.util.Collection;
17 import java.util.Collections;
18 import java.util.Deque;
19 import java.util.HashMap;
20 import java.util.HashSet;
21 import java.util.LinkedList;
22 import java.util.List;
23 import java.util.Map;
24 import java.util.Set;
25 import java.util.WeakHashMap;
26 import java.util.concurrent.CopyOnWriteArrayList;
27 import java.util.concurrent.ExecutorService;
28 import java.util.concurrent.ScheduledExecutorService;
29 import java.util.concurrent.Semaphore;
30 import java.util.concurrent.TimeUnit;
31 import java.util.concurrent.atomic.AtomicBoolean;
32 import java.util.concurrent.atomic.AtomicReference;
33 import java.util.function.BiFunction;
34 import java.util.function.Consumer;
35
36 import org.eclipse.core.runtime.Assert;
37 import org.eclipse.core.runtime.IAdaptable;
38 import org.eclipse.core.runtime.IProgressMonitor;
39 import org.eclipse.core.runtime.IStatus;
40 import org.eclipse.core.runtime.MultiStatus;
41 import org.eclipse.core.runtime.Status;
42 import org.eclipse.core.runtime.jobs.Job;
43 import org.eclipse.jface.layout.GridDataFactory;
44 import org.eclipse.jface.layout.TreeColumnLayout;
45 import org.eclipse.jface.resource.ColorDescriptor;
46 import org.eclipse.jface.resource.DeviceResourceException;
47 import org.eclipse.jface.resource.DeviceResourceManager;
48 import org.eclipse.jface.resource.FontDescriptor;
49 import org.eclipse.jface.resource.ImageDescriptor;
50 import org.eclipse.jface.resource.JFaceResources;
51 import org.eclipse.jface.resource.LocalResourceManager;
52 import org.eclipse.jface.viewers.CellEditor;
53 import org.eclipse.jface.viewers.CellLabelProvider;
54 import org.eclipse.jface.viewers.ColumnViewer;
55 import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
56 import org.eclipse.jface.viewers.ColumnViewerEditorActivationListener;
57 import org.eclipse.jface.viewers.ColumnViewerEditorDeactivationEvent;
58 import org.eclipse.jface.viewers.ColumnWeightData;
59 import org.eclipse.jface.viewers.ComboBoxCellEditor;
60 import org.eclipse.jface.viewers.DialogCellEditor;
61 import org.eclipse.jface.viewers.EditingSupport;
62 import org.eclipse.jface.viewers.ICellEditorValidator;
63 import org.eclipse.jface.viewers.IPostSelectionProvider;
64 import org.eclipse.jface.viewers.ISelection;
65 import org.eclipse.jface.viewers.ISelectionChangedListener;
66 import org.eclipse.jface.viewers.ISelectionProvider;
67 import org.eclipse.jface.viewers.ITreeContentProvider;
68 import org.eclipse.jface.viewers.ITreeViewerListener;
69 import org.eclipse.jface.viewers.SelectionChangedEvent;
70 import org.eclipse.jface.viewers.StructuredSelection;
71 import org.eclipse.jface.viewers.TextCellEditor;
72 import org.eclipse.jface.viewers.TreeExpansionEvent;
73 import org.eclipse.jface.viewers.TreeSelection;
74 import org.eclipse.jface.viewers.TreeViewer;
75 import org.eclipse.jface.viewers.TreeViewerColumn;
76 import org.eclipse.jface.viewers.Viewer;
77 import org.eclipse.jface.viewers.ViewerCell;
78 import org.eclipse.swt.SWT;
79 import org.eclipse.swt.events.DisposeEvent;
80 import org.eclipse.swt.events.DisposeListener;
81 import org.eclipse.swt.events.FocusEvent;
82 import org.eclipse.swt.events.FocusListener;
83 import org.eclipse.swt.events.KeyEvent;
84 import org.eclipse.swt.events.KeyListener;
85 import org.eclipse.swt.events.MouseEvent;
86 import org.eclipse.swt.events.MouseListener;
87 import org.eclipse.swt.events.SelectionListener;
88 import org.eclipse.swt.graphics.Color;
89 import org.eclipse.swt.graphics.Font;
90 import org.eclipse.swt.graphics.Image;
91 import org.eclipse.swt.graphics.Point;
92 import org.eclipse.swt.graphics.RGB;
93 import org.eclipse.swt.layout.FillLayout;
94 import org.eclipse.swt.widgets.Composite;
95 import org.eclipse.swt.widgets.Control;
96 import org.eclipse.swt.widgets.Display;
97 import org.eclipse.swt.widgets.Event;
98 import org.eclipse.swt.widgets.Listener;
99 import org.eclipse.swt.widgets.ScrollBar;
100 import org.eclipse.swt.widgets.Tree;
101 import org.eclipse.swt.widgets.TreeColumn;
102 import org.eclipse.swt.widgets.TreeItem;
103 import org.eclipse.ui.PlatformUI;
104 import org.eclipse.ui.contexts.IContextActivation;
105 import org.eclipse.ui.contexts.IContextService;
106 import org.eclipse.ui.services.IServiceLocator;
107 import org.eclipse.ui.swt.IFocusService;
108 import org.simantics.browsing.ui.BuiltinKeys;
109 import org.simantics.browsing.ui.Column;
110 import org.simantics.browsing.ui.Column.Align;
111 import org.simantics.browsing.ui.DataSource;
112 import org.simantics.browsing.ui.ExplorerState;
113 import org.simantics.browsing.ui.GraphExplorer;
114 import org.simantics.browsing.ui.NodeContext;
115 import org.simantics.browsing.ui.NodeContext.CacheKey;
116 import org.simantics.browsing.ui.NodeContext.PrimitiveQueryKey;
117 import org.simantics.browsing.ui.NodeContext.QueryKey;
118 import org.simantics.browsing.ui.NodeQueryManager;
119 import org.simantics.browsing.ui.NodeQueryProcessor;
120 import org.simantics.browsing.ui.PrimitiveQueryProcessor;
121 import org.simantics.browsing.ui.PrimitiveQueryUpdater;
122 import org.simantics.browsing.ui.SelectionDataResolver;
123 import org.simantics.browsing.ui.SelectionFilter;
124 import org.simantics.browsing.ui.StatePersistor;
125 import org.simantics.browsing.ui.common.AdaptableHintContext;
126 import org.simantics.browsing.ui.common.ColumnKeys;
127 import org.simantics.browsing.ui.common.ErrorLogger;
128 import org.simantics.browsing.ui.common.NodeContextBuilder;
129 import org.simantics.browsing.ui.common.NodeContextUtil;
130 import org.simantics.browsing.ui.common.internal.GENodeQueryManager;
131 import org.simantics.browsing.ui.common.internal.IGECache;
132 import org.simantics.browsing.ui.common.internal.IGraphExplorerContext;
133 import org.simantics.browsing.ui.common.internal.UIElementReference;
134 import org.simantics.browsing.ui.common.processors.AbstractPrimitiveQueryProcessor;
135 import org.simantics.browsing.ui.common.processors.DefaultCheckedStateProcessor;
136 import org.simantics.browsing.ui.common.processors.DefaultComparableChildrenProcessor;
137 import org.simantics.browsing.ui.common.processors.DefaultFinalChildrenProcessor;
138 import org.simantics.browsing.ui.common.processors.DefaultImageDecoratorProcessor;
139 import org.simantics.browsing.ui.common.processors.DefaultImagerFactoriesProcessor;
140 import org.simantics.browsing.ui.common.processors.DefaultImagerProcessor;
141 import org.simantics.browsing.ui.common.processors.DefaultLabelDecoratorProcessor;
142 import org.simantics.browsing.ui.common.processors.DefaultLabelerFactoriesProcessor;
143 import org.simantics.browsing.ui.common.processors.DefaultLabelerProcessor;
144 import org.simantics.browsing.ui.common.processors.DefaultPrunedChildrenProcessor;
145 import org.simantics.browsing.ui.common.processors.DefaultSelectedImageDecoratorFactoriesProcessor;
146 import org.simantics.browsing.ui.common.processors.DefaultSelectedLabelDecoratorFactoriesProcessor;
147 import org.simantics.browsing.ui.common.processors.DefaultSelectedLabelerProcessor;
148 import org.simantics.browsing.ui.common.processors.DefaultSelectedViewpointFactoryProcessor;
149 import org.simantics.browsing.ui.common.processors.DefaultSelectedViewpointProcessor;
150 import org.simantics.browsing.ui.common.processors.DefaultViewpointContributionProcessor;
151 import org.simantics.browsing.ui.common.processors.DefaultViewpointContributionsProcessor;
152 import org.simantics.browsing.ui.common.processors.DefaultViewpointProcessor;
153 import org.simantics.browsing.ui.common.processors.IsExpandedProcessor;
154 import org.simantics.browsing.ui.common.processors.NoSelectionRequestProcessor;
155 import org.simantics.browsing.ui.common.processors.ProcessorLifecycle;
156 import org.simantics.browsing.ui.common.state.ExplorerStates;
157 import org.simantics.browsing.ui.content.ImageDecorator;
158 import org.simantics.browsing.ui.content.Imager;
159 import org.simantics.browsing.ui.content.LabelDecorator;
160 import org.simantics.browsing.ui.content.Labeler;
161 import org.simantics.browsing.ui.content.Labeler.CustomModifier;
162 import org.simantics.browsing.ui.content.Labeler.DialogModifier;
163 import org.simantics.browsing.ui.content.Labeler.EnumerationModifier;
164 import org.simantics.browsing.ui.content.Labeler.Modifier;
165 import org.simantics.browsing.ui.swt.internal.Threads;
166 import org.simantics.db.layer0.SelectionHints;
167 import org.simantics.ui.SimanticsUI;
168 import org.simantics.utils.datastructures.BijectionMap;
169 import org.simantics.utils.datastructures.MapList;
170 import org.simantics.utils.datastructures.disposable.AbstractDisposable;
171 import org.simantics.utils.datastructures.hints.IHintContext;
172 import org.simantics.utils.threads.IThreadWorkQueue;
173 import org.simantics.utils.threads.SWTThread;
174 import org.simantics.utils.threads.ThreadUtils;
175 import org.simantics.utils.ui.AdaptionUtils;
176 import org.simantics.utils.ui.ISelectionUtils;
177 import org.simantics.utils.ui.SWTUtils;
178 import org.simantics.utils.ui.jface.BasePostSelectionProvider;
179
180 import gnu.trove.map.hash.THashMap;
181 import gnu.trove.map.hash.TObjectIntHashMap;
182
183 /**
184  * TreeView based GraphExplorer
185  * 
186  * 
187  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
188  */
189 public class GraphExplorerImpl2 extends GraphExplorerImplBase implements GraphExplorer {
190         
191         private static final boolean DEBUG_SELECTION_LISTENERS = false;
192         private static final boolean DEBUG = false;
193         
194         private TreeViewer viewer;
195         
196         private LocalResourceManager localResourceManager;
197         private DeviceResourceManager resourceManager;
198         
199         
200         private IThreadWorkQueue thread;
201         
202         @SuppressWarnings({ "rawtypes" })
203         final HashMap<CacheKey<?>, NodeQueryProcessor> processors = new HashMap<CacheKey<?>, NodeQueryProcessor>();
204         @SuppressWarnings({ "rawtypes" })
205         final HashMap<Object, PrimitiveQueryProcessor> primitiveProcessors = new HashMap<Object, PrimitiveQueryProcessor>();
206         @SuppressWarnings({ "rawtypes" })
207         final HashMap<Class, DataSource> dataSources = new HashMap<Class, DataSource>();
208         
209         private FontDescriptor originalFont;
210     protected ColorDescriptor originalForeground;
211     protected ColorDescriptor originalBackground;
212     private Color invalidModificationColor;
213
214         private Column[] columns;
215         private Map<String,Integer> columnKeyToIndex;
216         private boolean columnsAreVisible = true;
217
218         
219         private NodeContext rootContext;
220         private TreeNode rootNode;
221         private StatePersistor persistor = null;
222
223         private boolean editable = true;
224         
225         private boolean disposed = false;
226         
227         private final CopyOnWriteArrayList<FocusListener> focusListeners = new CopyOnWriteArrayList<FocusListener>();
228     private final CopyOnWriteArrayList<MouseListener> mouseListeners = new CopyOnWriteArrayList<MouseListener>();
229     private final CopyOnWriteArrayList<KeyListener> keyListeners = new CopyOnWriteArrayList<KeyListener>();
230         
231     private int autoExpandLevel = 0;
232     private IServiceLocator serviceLocator;
233     private IContextService contextService = null;
234     private IFocusService focusService = null;
235     private IContextActivation editingContext = null;
236         
237     GeViewerContext explorerContext = new GeViewerContext(this);
238     
239     private GraphExplorerPostSelectionProvider postSelectionProvider = new GraphExplorerPostSelectionProvider(this);
240     private BasePostSelectionProvider selectionProvider        = new BasePostSelectionProvider();
241     private SelectionDataResolver selectionDataResolver;
242     private SelectionFilter selectionFilter;
243     
244     private Set<TreeNode> collapsedNodes = new HashSet<TreeNode>();
245     private MapList<NodeContext, TreeNode> contextToNodeMap = new MapList<NodeContext, TreeNode>();
246     
247     private ModificationContext                          modificationContext = null;
248     
249     private boolean filterSelectionEdit = true;
250     
251     private TreeColumnLayout treeColumnLayout;
252     
253     private boolean expand;
254     private boolean verticalBarVisible = false;
255     
256     private BiFunction<GraphExplorer, Object[], Object[]> selectionTransformation = new BiFunction<GraphExplorer, Object[], Object[]>() {
257
258         @Override
259         public Object[] apply(GraphExplorer explorer, Object[] objects) {
260             Object[] result = new Object[objects.length];
261             for (int i = 0; i < objects.length; i++) {
262                 IHintContext context = new AdaptableHintContext(SelectionHints.KEY_MAIN);
263                 context.setHint(SelectionHints.KEY_MAIN, objects[i]);
264                 result[i] = context;
265             }
266             return result;
267         }
268
269     };
270     
271     static class TransientStateImpl implements TransientExplorerState {
272
273         private Integer activeColumn = null;
274         
275                 @Override
276                 public synchronized Integer getActiveColumn() {
277                         return activeColumn;
278                 }
279                 
280                 public synchronized void setActiveColumn(Integer column) {
281                         activeColumn = column;
282                 }
283         
284     }
285     
286     private TransientStateImpl transientState = new TransientStateImpl();
287     
288         
289         public GraphExplorerImpl2(Composite parent) {
290                 this(parent, SWT.BORDER | SWT.MULTI );
291         }
292
293         public GraphExplorerImpl2(Composite parent, int style) {
294                 this.localResourceManager = new LocalResourceManager(JFaceResources.getResources());
295                 this.resourceManager = new DeviceResourceManager(parent.getDisplay());
296
297                 this.imageLoaderJob = new ImageLoaderJob(this);
298                 this.imageLoaderJob.setPriority(Job.DECORATE);
299
300                 invalidModificationColor = (Color) localResourceManager.get(ColorDescriptor.createFrom(new RGB(255, 128, 128)));
301
302                 this.thread = SWTThread.getThreadAccess(parent);
303
304                 for (int i = 0; i < 10; i++)
305                         explorerContext.activity.push(0);
306
307                 boolean useLayout = true;
308                 // FIXME: hack, GraphExplorerComposite uses its own TreeColumnLayout. 
309                 if (useLayout && !(parent.getLayout() instanceof TreeColumnLayout)) {
310
311                         Composite rootTreeComposite = new Composite(parent, SWT.NONE);
312                         treeColumnLayout = new TreeColumnLayout();
313                         rootTreeComposite.setLayout(treeColumnLayout);
314
315                         viewer = new TreeViewer(rootTreeComposite,style|SWT.H_SCROLL|SWT.V_SCROLL);
316                         
317                         GridDataFactory.fillDefaults().grab(true, true).span(3,1).applyTo(rootTreeComposite);
318                         
319                 } else {
320                         viewer = new TreeViewer(parent,style | SWT.H_SCROLL | SWT.V_SCROLL);
321                 }
322                 
323                 viewer.getColumnViewerEditor().addEditorActivationListener(new ColumnViewerEditorActivationListener() {
324                         
325                         @Override
326                         public void beforeEditorDeactivated(ColumnViewerEditorDeactivationEvent event) {
327                                 
328                         }
329                         
330                         @Override
331                         public void beforeEditorActivated(ColumnViewerEditorActivationEvent event) {
332                                 // cancel editor activation for double click events.
333                                 // TODO: this may not work similarly to GraphExplorerImpl
334                                 if ((event.time - focusGainedAt) < 250L) {
335                                         event.cancel = true;
336                                 }
337                         }
338                         
339                         @Override
340                         public void afterEditorDeactivated(ColumnViewerEditorDeactivationEvent event) {
341                                 
342                         }
343                         
344                         @Override
345                         public void afterEditorActivated(ColumnViewerEditorActivationEvent event) {
346                                 
347                         }
348                 });
349                 
350                 viewer.setUseHashlookup(true);
351                 viewer.setContentProvider(new GeViewerContentProvider());
352                 
353                 
354
355                 originalFont = JFaceResources.getDefaultFontDescriptor();
356
357                 viewer.getTree().setFont((Font) localResourceManager.get(originalFont));
358                 
359                 setBasicListeners();
360                 setDefaultProcessors();
361                 
362                 viewer.getTree().addDisposeListener(new DisposeListener() {
363                         
364                         @Override
365                         public void widgetDisposed(DisposeEvent e) {
366                                 doDispose();
367                                 
368                         }
369                 });
370                 
371                 
372                 // Add listener to tree for delayed tree population. 
373                 
374                 Listener listener = new Listener() {
375                         
376                         @Override
377                         public void handleEvent(Event event) {
378                                 
379                                 switch (event.type) {
380                                         case SWT.Activate:
381                                         case SWT.Show:
382                                         case SWT.Paint:
383                                         {
384                                                 visible = true;
385                                                 activate();
386                                                 break;
387                                         }
388                                         case SWT.Deactivate:
389                                         case SWT.Hide:
390                                                 visible = false;
391                                 }
392                         }
393                 };
394                 
395                 viewer.getTree().addListener(SWT.Activate, listener);
396                 viewer.getTree().addListener(SWT.Deactivate, listener);
397                 viewer.getTree().addListener(SWT.Show, listener);
398                 viewer.getTree().addListener(SWT.Hide, listener);
399                 viewer.getTree().addListener(SWT.Paint,listener);
400                 
401                 
402                 viewer.addTreeListener(new ITreeViewerListener() {
403                         
404                         @Override
405                         public void treeExpanded(TreeExpansionEvent event) {
406                                 
407                         }
408                         
409                         @Override
410                         public void treeCollapsed(TreeExpansionEvent event) {
411                                 collapsedNodes.add((TreeNode)event.getElement());
412                         }
413                 });
414                 
415                 setColumns( new Column[] { new Column(ColumnKeys.SINGLE) });
416         }
417         
418         private long focusGainedAt = 0L;
419         private boolean visible = false;
420         
421         private Collection<TreeNode> selectedNodes = new ArrayList<TreeNode>();
422         
423         protected void setBasicListeners() {
424                 Tree tree = viewer.getTree();
425                 
426                  tree.addFocusListener(new FocusListener() {
427                     @Override
428                     public void focusGained(FocusEvent e) {
429                         focusGainedAt = ((long) e.time) & 0xFFFFFFFFL;
430                         for (FocusListener listener : focusListeners)
431                             listener.focusGained(e);
432                     }
433                     @Override
434                     public void focusLost(FocusEvent e) {
435                         for (FocusListener listener : focusListeners)
436                             listener.focusLost(e);
437                     }
438                 });
439                 tree.addMouseListener(new MouseListener() {
440                     @Override
441                     public void mouseDoubleClick(MouseEvent e) {
442                         for (MouseListener listener : mouseListeners) {
443                             listener.mouseDoubleClick(e);
444                         }
445                     }
446                     @Override
447                     public void mouseDown(MouseEvent e) {
448                         for (MouseListener listener : mouseListeners) {
449                             listener.mouseDown(e);
450                         }
451                     }
452                     @Override
453                     public void mouseUp(MouseEvent e) {
454                         for (MouseListener listener : mouseListeners) {
455                             listener.mouseUp(e);
456                         }
457                     }
458                 });
459                 tree.addKeyListener(new KeyListener() {
460                     @Override
461                     public void keyPressed(KeyEvent e) {
462                         for (KeyListener listener : keyListeners) {
463                             listener.keyPressed(e);
464                         }
465                     }
466                     @Override
467                     public void keyReleased(KeyEvent e) {
468                         for (KeyListener listener : keyListeners) {
469                             listener.keyReleased(e);
470                         }
471                     }
472                 });
473                 
474                 viewer.addSelectionChangedListener(new ISelectionChangedListener() {
475                                 
476                                 @Override
477                                 public void selectionChanged(SelectionChangedEvent event) {
478                                         //System.out.println("GraphExplorerImpl2.fireSelection");
479                                         selectedNodes = AdaptionUtils.adaptToCollection(event.getSelection(), TreeNode.class);
480                                         Collection<NodeContext> selectedContexts = AdaptionUtils.adaptToCollection(event.getSelection(), NodeContext.class);
481                                         selectionProvider.setAndFireSelection(constructSelection(selectedContexts.toArray(new NodeContext[selectedContexts.size()])));
482                                 }
483                         });
484                 
485                 viewer.addPostSelectionChangedListener(new ISelectionChangedListener() {
486                                 
487                                 @Override
488                                 public void selectionChanged(SelectionChangedEvent event) {
489                                         //System.out.println("GraphExplorerImpl2.firePostSelection");
490                                         Collection<NodeContext> selectedContexts = AdaptionUtils.adaptToCollection(event.getSelection(), NodeContext.class);
491                                         selectionProvider.firePostSelection(constructSelection(selectedContexts.toArray(new NodeContext[selectedContexts.size()])));
492                                         
493                                 }
494                         });
495
496         }
497         
498         private NodeContext pendingRoot;
499         
500         private void activate() {
501                 if (pendingRoot != null && !expand) {
502                         doSetRoot(pendingRoot);
503                         pendingRoot = null;
504                 }
505         }
506         
507     /**
508      * Invoke only from SWT thread to reset the root of the graph explorer tree.
509      * 
510      * @param root
511      */
512     private void doSetRoot(NodeContext root) {
513         Display display = viewer.getTree().getDisplay();
514                 if (display.getThread() != Thread.currentThread()) {
515                         throw new RuntimeException("Invoke from SWT thread only");
516                 }
517 //      System.out.println("doSetRoot " + root);
518         if (isDisposed())
519             return;
520         if (viewer.getTree().isDisposed())
521                 return;
522         if (root.getConstant(BuiltinKeys.INPUT) == null) {
523             ErrorLogger.defaultLogError("root node context does not contain BuiltinKeys.INPUT key. Node = " + root, new Exception("trace"));
524             return;
525         }
526         
527         
528
529         // Empty caches, release queries.
530         if (rootNode != null) {
531                 rootNode.dispose();
532         }       
533         GeViewerContext oldContext = explorerContext;
534         GeViewerContext newContext = new GeViewerContext(this);
535         this.explorerContext = newContext;
536         oldContext.safeDispose();
537
538         // Need to empty these or otherwise they won't be emptied until the
539         // explorer is disposed which would mean that many unwanted references
540         // will be held by this map.
541         clearPrimitiveProcessors();
542
543         this.rootContext = root.getConstant(BuiltinKeys.IS_ROOT) != null ? root
544                 : NodeContextUtil.withConstant(root, BuiltinKeys.IS_ROOT, Boolean.TRUE);
545
546         explorerContext.getCache().incRef(this.rootContext);
547
548         initializeState();
549         
550         
551         select(rootContext);
552         //refreshColumnSizes();
553         rootNode = new TreeNode(rootContext);
554         if (DEBUG) System.out.println("setRoot " + rootNode);
555       
556         viewer.setInput(rootNode);
557         
558         // Delay content reading.
559         
560         // This is required for cases when GEImpl2 is attached to selection view. Reading content
561         // instantly could stagnate SWT thread under rapid changes in selection. By delaying the 
562         // content reading we give the system a change to dispose the GEImpl2 before the content is read.
563         display.asyncExec(new Runnable() {
564                         
565                         @Override
566                         public void run() {
567                                 if (rootNode != null) {
568                                     rootNode.updateChildren();
569                                 }
570                         }
571                 });
572        
573     }
574     
575     private void initializeState() {
576         if (persistor == null)
577             return;
578         ExplorerStates.scheduleRead(getRoot(), persistor)
579         .thenAccept(state -> SWTUtils.asyncExec(viewer.getTree(), () -> restoreState(state)));
580     }
581
582     private void restoreState(ExplorerState state) {
583         Object processor = getPrimitiveProcessor(BuiltinKeys.IS_EXPANDED);
584         if (processor instanceof DefaultIsExpandedProcessor) {
585             DefaultIsExpandedProcessor isExpandedProcessor = (DefaultIsExpandedProcessor)processor;
586             for(NodeContext expanded : state.expandedNodes) {
587                 isExpandedProcessor.replaceExpanded(expanded, true);
588             }
589         }
590     }
591
592     @Override
593     public NodeContext getRoot() {
594         return rootContext;
595     }
596     
597     @Override
598     public IThreadWorkQueue getThread() {
599         return thread;
600     }
601
602     @Override
603     public NodeContext getParentContext(NodeContext context) {
604         if (disposed)
605             throw new IllegalStateException("disposed");
606         if (!thread.currentThreadAccess())
607             throw new IllegalStateException("not in SWT display thread " + thread.getThread());
608
609         List<TreeNode> nodes = contextToNodeMap.getValuesUnsafe(context);
610         for (int i = 0; i < nodes.size(); i++) {
611                 if (nodes.get(i).getParent() != null)
612                         return nodes.get(i).getParent().getContext();
613         }
614         return null;
615         
616     }
617     
618     
619     @SuppressWarnings("unchecked")
620     @Override
621     public <T> T getAdapter(Class<T> adapter) {
622         if(ISelectionProvider.class == adapter) return (T) postSelectionProvider;
623         else if(IPostSelectionProvider.class == adapter) return (T) postSelectionProvider;
624         return null;
625     }
626
627         
628         protected void setDefaultProcessors() {
629                 // Add a simple IMAGER query processor that always returns null.
630                 // With this processor no images will ever be shown.
631                 // setPrimitiveProcessor(new StaticImagerProcessor(null));
632
633                 setProcessor(new DefaultComparableChildrenProcessor());
634                 setProcessor(new DefaultLabelDecoratorsProcessor());
635                 setProcessor(new DefaultImageDecoratorsProcessor());
636                 setProcessor(new DefaultSelectedLabelerProcessor());
637                 setProcessor(new DefaultLabelerFactoriesProcessor());
638                 setProcessor(new DefaultSelectedImagerProcessor());
639                 setProcessor(new DefaultImagerFactoriesProcessor());
640                 setPrimitiveProcessor(new DefaultLabelerProcessor());
641                 setPrimitiveProcessor(new DefaultCheckedStateProcessor());
642                 setPrimitiveProcessor(new DefaultImagerProcessor());
643                 setPrimitiveProcessor(new DefaultLabelDecoratorProcessor());
644                 setPrimitiveProcessor(new DefaultImageDecoratorProcessor());
645                 setPrimitiveProcessor(new NoSelectionRequestProcessor());
646
647                 setProcessor(new DefaultFinalChildrenProcessor(this));
648
649                 setProcessor(new DefaultPrunedChildrenProcessor());
650                 setProcessor(new DefaultSelectedViewpointProcessor());
651                 setProcessor(new DefaultSelectedLabelDecoratorFactoriesProcessor());
652                 setProcessor(new DefaultSelectedImageDecoratorFactoriesProcessor());
653                 setProcessor(new DefaultViewpointContributionsProcessor());
654
655                 setPrimitiveProcessor(new DefaultViewpointProcessor());
656                 setPrimitiveProcessor(new DefaultViewpointContributionProcessor());
657                 setPrimitiveProcessor(new DefaultSelectedViewpointFactoryProcessor());
658                 setPrimitiveProcessor(new TreeNodeIsExpandedProcessor());
659                 setPrimitiveProcessor(new DefaultShowMaxChildrenProcessor());
660         }
661         
662         @Override
663     public Column[] getColumns() {
664         return Arrays.copyOf(columns, columns.length);
665     }
666         
667     @Override
668     public void setColumnsVisible(boolean visible) {
669         columnsAreVisible = visible;
670         if(viewer.getTree() != null) viewer.getTree().setHeaderVisible(columnsAreVisible);
671     }
672
673     @Override
674     public void setColumns(final Column[] columns) {
675         setColumns(columns, null);
676     }
677
678     @Override
679     public void setColumns(final Column[] columns, Consumer<Map<Column, Object>> callback) {
680         assertNotDisposed();
681         checkUniqueColumnKeys(columns);
682
683         Display d = viewer.getTree().getDisplay();
684         if (d.getThread() == Thread.currentThread()) {
685             doSetColumns(columns, callback);
686             viewer.refresh(true);
687          }else
688             d.asyncExec(new Runnable() {
689                 @Override
690                 public void run() {
691                         if (viewer == null)
692                                 return;
693                     if (viewer.getTree().isDisposed())
694                         return;
695                     doSetColumns(columns, callback);
696                     viewer.refresh(true);
697                     viewer.getTree().getParent().layout();
698                 }
699             });
700     }
701     
702     private void checkUniqueColumnKeys(Column[] cols) {
703         Set<String> usedColumnKeys = new HashSet<String>();
704         List<Column> duplicateColumns = new ArrayList<Column>();
705         for (Column c : cols) {
706             if (!usedColumnKeys.add(c.getKey()))
707                 duplicateColumns.add(c);
708         }
709         if (!duplicateColumns.isEmpty()) {
710             throw new IllegalArgumentException("All columns do not have unique keys: " + cols + ", overlapping: " + duplicateColumns);
711         }
712     }
713     
714     private List<TreeViewerColumn> treeViewerColumns = new ArrayList<TreeViewerColumn>();
715     private CellLabelProvider cellLabelProvider = new GeViewerLabelProvider();
716     private List<EditingSupport> editingSupports = new ArrayList<EditingSupport>();
717     
718     private void doSetColumns(Column[] cols, Consumer<Map<Column, Object>> callback) {
719         // Attempt to keep previous column widths.
720         Map<String, Integer> prevWidths = new HashMap<>();
721         for (TreeViewerColumn c : treeViewerColumns) {
722             Column col = (Column) (c.getColumn().getData());
723             if (col != null)
724                 prevWidths.put(col.getKey(), c.getColumn().getWidth());
725             c.getColumn().dispose();
726         }
727
728         treeViewerColumns.clear();
729         
730         HashMap<String, Integer> keyToIndex = new HashMap<String, Integer>();
731         for (int i = 0; i < cols.length; ++i) {
732             keyToIndex.put(cols[i].getKey(), i);
733         }
734
735         this.columns = Arrays.copyOf(cols, cols.length);
736         //this.columns[cols.length] = FILLER_COLUMN;
737         this.columnKeyToIndex = keyToIndex;
738
739         Map<Column, Object> map = new HashMap<Column, Object>();
740
741         // FIXME : temporary workaround for ModelBrowser.
742         viewer.getTree().setHeaderVisible(columns.length == 1 ? false : columnsAreVisible);
743         
744         int columnIndex = 0;
745
746         for (Column column : columns) {
747                 TreeViewerColumn tvc = new TreeViewerColumn(viewer, toSWT(column.getAlignment()));
748                 treeViewerColumns.add(tvc);
749                 tvc.setLabelProvider(cellLabelProvider);
750                 EditingSupport support = null;
751                 if (editingSupports.size() > columnIndex)
752                         support = editingSupports.get(columnIndex);
753                 else {
754                         support = new GeEditingSupport(viewer, columnIndex);
755                         editingSupports.add(support);
756                 }
757                 
758                 tvc.setEditingSupport(support);
759                 
760             TreeColumn c = tvc.getColumn();
761             map.put(column, c);
762             c.setData(column);
763             c.setText(column.getLabel());
764             c.setToolTipText(column.getTooltip());
765
766             int cw = column.getWidth();
767
768             // Try to keep previous widths
769             Integer w = prevWidths.get(column.getKey());
770             if (w != null)
771                 c.setWidth(w);
772             else if (cw != Column.DEFAULT_CONTROL_WIDTH)
773                 c.setWidth(cw);
774             else if (columns.length == 1) {
775                 // FIXME : how to handle single column properly?
776                 c.setWidth(1000);
777             }
778             else {
779                 // Go for some kind of default settings then...
780                 if (ColumnKeys.PROPERTY.equals(column.getKey()))
781                     c.setWidth(150);
782                 else
783                     c.setWidth(50);
784             }
785             if (treeColumnLayout != null) {
786                 treeColumnLayout.setColumnData(c, new ColumnWeightData(column.getWeight(), true));
787             }
788
789 //            if (!column.hasGrab() && !FILLER.equals(column.getKey())) {
790 //                c.addListener(SWT.Resize, resizeListener);
791 //                c.setResizable(true);
792 //            } else {
793 //                //c.setResizable(false);
794 //            }
795             columnIndex++;
796         }
797        
798        
799
800         if(callback != null) callback.accept(map);
801     }
802
803     int toSWT(Align alignment) {
804         switch (alignment) {
805             case LEFT: return SWT.LEFT;
806             case CENTER: return SWT.CENTER;
807             case RIGHT: return SWT.RIGHT;
808             default: throw new Error("unhandled alignment: " + alignment);
809         }
810     }
811
812         @Override
813         public <T> void setProcessor(NodeQueryProcessor<T> processor) {
814                 assertNotDisposed();
815                 if (processor == null)
816                         throw new IllegalArgumentException("null processor");
817
818                 processors.put(processor.getIdentifier(), processor);
819         }
820
821         @Override
822         public <T> void setPrimitiveProcessor(PrimitiveQueryProcessor<T> processor) {
823                 assertNotDisposed();
824                 if (processor == null)
825                         throw new IllegalArgumentException("null processor");
826
827                 PrimitiveQueryProcessor<?> oldProcessor = primitiveProcessors.put(
828                                 processor.getIdentifier(), processor);
829
830                 if (oldProcessor instanceof ProcessorLifecycle)
831                         ((ProcessorLifecycle) oldProcessor).detached(this);
832                 if (processor instanceof ProcessorLifecycle)
833                         ((ProcessorLifecycle) processor).attached(this);
834         }
835
836         @Override
837         public <T> void setDataSource(DataSource<T> provider) {
838                 assertNotDisposed();
839                 if (provider == null)
840                         throw new IllegalArgumentException("null provider");
841                 dataSources.put(provider.getProvidedClass(), provider);
842         }
843
844         @SuppressWarnings("unchecked")
845         @Override
846         public <T> DataSource<T> removeDataSource(Class<T> forProvidedClass) {
847                 assertNotDisposed();
848                 if (forProvidedClass == null)
849                         throw new IllegalArgumentException("null class");
850                 return dataSources.remove(forProvidedClass);
851         }
852
853         @Override
854         public void setPersistor(StatePersistor persistor) {
855                 this.persistor = persistor;
856         }
857
858         @Override
859         public SelectionDataResolver getSelectionDataResolver() {
860                 return selectionDataResolver;
861         }
862
863         @Override
864         public void setSelectionDataResolver(SelectionDataResolver r) {
865                 this.selectionDataResolver = r;
866         }
867
868         @Override
869         public SelectionFilter getSelectionFilter() {
870                 return selectionFilter;
871         }
872
873         @Override
874         public void setSelectionFilter(SelectionFilter f) {
875                 this.selectionFilter = f;
876                 // TODO: re-filter current selection?
877         }
878         
879     protected ISelection constructSelection(NodeContext... contexts) {
880         if (contexts ==  null)
881             throw new IllegalArgumentException("null contexts");
882         if (contexts.length == 0)
883             return StructuredSelection.EMPTY;
884         if (selectionFilter == null)
885             return new StructuredSelection(transformSelection(contexts));
886         return new StructuredSelection( transformSelection(filter(selectionFilter, contexts)) );
887     }
888     
889     protected Object[] transformSelection(Object[] objects) {
890         return selectionTransformation.apply(this, objects);
891     }
892     
893     protected static Object[] filter(SelectionFilter filter, NodeContext[] contexts) {
894         int len = contexts.length;
895         Object[] objects = new Object[len];
896         for (int i = 0; i < len; ++i)
897             objects[i] = filter.filter(contexts[i]);
898         return objects;
899     }
900
901         @Override
902         public void setSelectionTransformation(
903                         BiFunction<GraphExplorer, Object[], Object[]> f) {
904                 this.selectionTransformation = f;
905         }
906         
907         public ISelection getWidgetSelection() {
908                 return viewer.getSelection();
909         }
910
911         @Override
912         public <T> void addListener(T listener) {
913                 if (listener instanceof FocusListener) {
914                         focusListeners.add((FocusListener) listener);
915                 } else if (listener instanceof MouseListener) {
916                         mouseListeners.add((MouseListener) listener);
917                 } else if (listener instanceof KeyListener) {
918                         keyListeners.add((KeyListener) listener);
919                 }
920         }
921
922         @Override
923         public <T> void removeListener(T listener) {
924                 if (listener instanceof FocusListener) {
925                         focusListeners.remove(listener);
926                 } else if (listener instanceof MouseListener) {
927                         mouseListeners.remove(listener);
928                 } else if (listener instanceof KeyListener) {
929                         keyListeners.remove(listener);
930                 }
931         }
932
933         public void addSelectionListener(SelectionListener listener) {
934                 viewer.getTree().addSelectionListener(listener);
935         }
936
937         public void removeSelectionListener(SelectionListener listener) {
938                 viewer.getTree().removeSelectionListener(listener);
939         }
940
941     private Set<String> uiContexts;
942     
943     @Override
944     public void setUIContexts(Set<String> contexts) {
945         this.uiContexts = contexts;
946     }
947         
948         @Override
949         public void setRoot(final Object root) {
950         if(uiContexts != null && uiContexts.size() == 1)
951                 setRootContext0(NodeContextBuilder.buildWithData(BuiltinKeys.INPUT, root, BuiltinKeys.UI_CONTEXT, uiContexts.iterator().next()));
952         else
953                 setRootContext0(NodeContextBuilder.buildWithData(BuiltinKeys.INPUT, root));
954         }
955
956         @Override
957         public void setRootContext(final NodeContext context) {
958                 setRootContext0(context);
959         }
960         
961         private void setRoot(NodeContext context) {
962                 if (!visible) {
963                         pendingRoot = context;
964                         Display.getDefault().asyncExec(new Runnable() {
965                                 @Override
966                                 public void run() {
967                                         if (viewer != null && !viewer.getTree().isDisposed())
968                                                 viewer.getTree().redraw();
969                                 }
970                         });
971                         return;
972         }
973                 doSetRoot(context);
974         }
975
976         private void setRootContext0(final NodeContext context) {
977                 Assert.isNotNull(context, "root must not be null");
978                 if (isDisposed() || viewer.getTree().isDisposed())
979                         return;
980                 Display display = viewer.getTree().getDisplay();
981                 if (display.getThread() == Thread.currentThread()) {
982                         setRoot(context);
983                 } else {
984                         display.asyncExec(new Runnable() {
985                                 @Override
986                                 public void run() {
987                                         setRoot(context);
988                                 }
989                         });
990                 }
991         }
992         
993         @Override
994         public void setFocus() {
995                 viewer.getTree().setFocus();
996         }
997         
998         @SuppressWarnings("unchecked")
999         @Override
1000         public <T> T getControl() {
1001                 return (T)viewer.getTree();
1002         }
1003         
1004             
1005     @Override
1006     public boolean isDisposed() {
1007         return disposed;
1008     }
1009
1010     protected void assertNotDisposed() {
1011         if (isDisposed())
1012             throw new IllegalStateException("disposed");
1013     }
1014     
1015         @Override
1016         public boolean isEditable() {
1017                 return editable;
1018         }
1019
1020         @Override
1021         public void setEditable(boolean editable) {
1022                 if (!thread.currentThreadAccess())
1023                         throw new IllegalStateException("not in SWT display thread " + thread.getThread());
1024
1025                 this.editable = editable;
1026                 Display display = viewer.getTree().getDisplay();
1027                 viewer.getTree().setBackground(editable ? null : display.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
1028         }
1029         
1030     private void doDispose() {
1031         if (disposed)
1032                 return;
1033         disposed = true;
1034        // TODO: Since GENodeQueryManager is cached in QueryChache and it refers to this class
1035        //       we have to remove all references here to reduce memory consumption.
1036        //       
1037        //       Proper fix would be to remove references between QueryCache and GENodeQueryManagers.
1038         explorerContext.dispose();
1039         explorerContext = null;
1040         processors.clear();
1041         detachPrimitiveProcessors();
1042         primitiveProcessors.clear();
1043         dataSources.clear();      
1044         pendingItems.clear();
1045         rootContext = null;
1046         mouseListeners.clear();
1047         selectionProvider.clearListeners();
1048         selectionProvider = null;
1049         selectionDataResolver = null;
1050         selectedNodes.clear();
1051         selectedNodes = null;
1052         selectionTransformation = null;
1053         originalFont = null;
1054         localResourceManager.dispose();
1055         localResourceManager = null;
1056         // Must shutdown image loader job before disposing its ResourceManager
1057         imageLoaderJob.dispose();
1058         imageLoaderJob.cancel();
1059         try {
1060             imageLoaderJob.join();
1061             imageLoaderJob = null;
1062         } catch (InterruptedException e) {
1063             ErrorLogger.defaultLogError(e);
1064         }
1065         resourceManager.dispose();
1066         resourceManager = null;
1067         collapsedNodes.clear();
1068         collapsedNodes = null;
1069         if (rootNode != null) {
1070                 rootNode.dispose();
1071                 rootNode = null;        
1072         }                       
1073         contextToNodeMap.clear(); // should be empty at this point.
1074         contextToNodeMap = null;
1075         if (postSelectionProvider != null) {
1076                 postSelectionProvider.dispose();
1077                 postSelectionProvider = null;
1078         }
1079         imageTasks = null;
1080         modificationContext = null;
1081         focusService = null;
1082         contextService = null;
1083         serviceLocator = null;
1084         columns = null;
1085         columnKeyToIndex.clear();
1086         columnKeyToIndex = null;
1087         viewer = null;
1088
1089     }
1090     
1091     @Override
1092     public boolean select(NodeContext context) {
1093
1094         assertNotDisposed();
1095
1096         if (context == null || context.equals(rootContext) || contextToNodeMap.getValuesUnsafe(context).size() == 0) {
1097             viewer.setSelection(new StructuredSelection());
1098             selectionProvider.setAndFireNonEqualSelection(TreeSelection.EMPTY);
1099             return true;
1100         }
1101
1102         viewer.setSelection(new StructuredSelection(contextToNodeMap.getValuesUnsafe(context).get(0)));
1103         
1104         return false;
1105         
1106     }
1107     
1108     @Override
1109     public boolean selectPath(Collection<NodeContext> contexts) {
1110         
1111         if(contexts == null) throw new IllegalArgumentException("Null list is not allowed");
1112         if(contexts.isEmpty()) throw new IllegalArgumentException("Empty list is not allowed");
1113         
1114         return selectPathInternal(contexts.toArray(new NodeContext[contexts.size()]), 0);
1115         
1116     }
1117     
1118     private boolean selectPathInternal(NodeContext[] contexts, int position) {
1119
1120         NodeContext head = contexts[position];
1121
1122         if(position == contexts.length-1) {
1123                 return select(head);
1124                 
1125         }
1126
1127         setExpanded(head, true);
1128         if(!waitVisible(contexts[position+1])) return false;
1129         
1130         return selectPathInternal(contexts, position+1);
1131         
1132     }
1133     
1134     private boolean waitVisible(NodeContext context) {
1135         long start = System.nanoTime();
1136         while(!isVisible(context)) {
1137                 Display.getCurrent().readAndDispatch();
1138                 long duration = System.nanoTime() - start;
1139                 if(duration > 10e9) return false;
1140         }
1141         return true;
1142     }
1143     
1144     @Override
1145     public boolean isVisible(NodeContext context) {
1146         if (contextToNodeMap.getValuesUnsafe(context).size() == 0)
1147                 return false;
1148         
1149         Object elements[] = viewer.getVisibleExpandedElements();
1150         return org.simantics.utils.datastructures.Arrays.contains(elements, contextToNodeMap.getValuesUnsafe(context).get(0));
1151         
1152         
1153     }
1154     
1155     @Override
1156     public TransientExplorerState getTransientState() {
1157         if (!thread.currentThreadAccess())
1158             throw new AssertionError(getClass().getSimpleName() + ".getActiveColumn called from non SWT-thread: " + Thread.currentThread());
1159         return transientState;
1160     }
1161     
1162     @Override
1163     public <T> T query(NodeContext context, CacheKey<T> key) {
1164         return this.explorerContext.cache.get(context, key);
1165     }
1166     
1167     /**
1168      * For setting a more local service locator for the explorer than the global
1169      * workbench service locator. Sometimes required to give this implementation
1170      * access to local workbench services like IFocusService.
1171      * 
1172      * <p>
1173      * Must be invoked during right after construction.
1174      * 
1175      * @param serviceLocator
1176      *            a specific service locator or <code>null</code> to use the
1177      *            workbench global service locator
1178      */
1179     public void setServiceLocator(IServiceLocator serviceLocator) {
1180         if (serviceLocator == null && PlatformUI.isWorkbenchRunning())
1181             serviceLocator = PlatformUI.getWorkbench();
1182         this.serviceLocator = serviceLocator;
1183         if (serviceLocator != null) {
1184             this.contextService = (IContextService) serviceLocator.getService(IContextService.class);
1185             this.focusService = (IFocusService) serviceLocator.getService(IFocusService.class);
1186         }
1187     }
1188     
1189     private void detachPrimitiveProcessors() {
1190         for (PrimitiveQueryProcessor<?> p : primitiveProcessors.values()) {
1191             if (p instanceof ProcessorLifecycle) {
1192                 ((ProcessorLifecycle) p).detached(this);
1193             }
1194         }
1195     }
1196
1197     private void clearPrimitiveProcessors() {
1198         for (PrimitiveQueryProcessor<?> p : primitiveProcessors.values()) {
1199             if (p instanceof ProcessorLifecycle) {
1200                 ((ProcessorLifecycle) p).clear();
1201             }
1202         }
1203     }
1204     
1205     @Override
1206     public void setExpanded(NodeContext context, boolean expanded) {
1207         viewer.setExpandedState(context, expanded);
1208         
1209     }
1210     
1211     @Override
1212     public void setAutoExpandLevel(int level) {
1213         this.autoExpandLevel = level;
1214         viewer.setAutoExpandLevel(level);
1215     }
1216     
1217     int maxChildren = GraphExplorerImpl.DEFAULT_MAX_CHILDREN;
1218     
1219     @Override
1220     public int getMaxChildren() {
1221         return maxChildren;
1222     }
1223     
1224     @Override
1225     public void setMaxChildren(int maxChildren) {
1226         this.maxChildren = maxChildren;
1227         
1228     }
1229     
1230     @Override
1231     public int getMaxChildren(NodeQueryManager manager, NodeContext context) {
1232         Integer result = manager.query(context, BuiltinKeys.SHOW_MAX_CHILDREN);
1233         //System.out.println("getMaxChildren(" + manager + ", " + context + "): " + result);
1234         if (result != null) {
1235             if (result < 0)
1236                 throw new AssertionError("BuiltinKeys.SHOW_MAX_CHILDREN query must never return < 0, got " + result);
1237             return result;
1238         }
1239         return maxChildren;
1240     }
1241     
1242     @Override
1243     public <T> NodeQueryProcessor<T> getProcessor(QueryKey<T> key) {
1244         return explorerContext.getProcessor(key);
1245     }
1246
1247     @Override
1248     public <T> PrimitiveQueryProcessor<T> getPrimitiveProcessor(PrimitiveQueryKey<T> key) {
1249         return explorerContext.getPrimitiveProcessor(key);
1250     }
1251     
1252     private HashSet<UpdateItem>                            pendingItems        = new HashSet<UpdateItem>();
1253     private boolean updating = false;
1254     private int updateCounter = 0;
1255     final ScheduledExecutorService               uiUpdateScheduler    = ThreadUtils.getNonBlockingWorkExecutor();
1256     
1257     private class UpdateItem {
1258         TreeNode element;
1259         int columnIndex;
1260         
1261         public UpdateItem(TreeNode element) {
1262                 this(element,-1);
1263         }
1264         
1265         public UpdateItem(TreeNode element, int columnIndex) {
1266                 this.element = element;
1267                 this.columnIndex = columnIndex;
1268                 if (element != null && element.isDisposed()) {
1269                         throw new IllegalArgumentException("Node is disposed. " + element);
1270                 }
1271         }
1272         
1273         public void update(TreeViewer viewer) {
1274                 if (element != null) {
1275
1276                                 if (element.isDisposed()) {
1277                                 return;
1278                                 }
1279                         if (((TreeNode)element).updateChildren()) {
1280                                 viewer.refresh(element,true);
1281                         } else {
1282                                 if (columnIndex >= 0) {
1283                                         viewer.update(element, new String[]{columns[columnIndex].getKey()});
1284                                 } else {
1285                                         viewer.refresh(element,true);
1286                                 }
1287                         }
1288                         
1289                         if (!element.isDisposed() && autoExpandLevel > 1 && !collapsedNodes.contains(element) && ((TreeNode)element).distanceToRoot() <= autoExpandLevel) {
1290                                 expand = true;
1291                                 viewer.setExpandedState(element, true);
1292                                 expand = false;
1293                         }
1294                         } else {
1295                                 if (rootNode.updateChildren())
1296                                         viewer.refresh(rootNode,true);
1297                         }
1298         }
1299         
1300         @Override
1301         public boolean equals(Object obj) {
1302                 if (obj == null)
1303                         return false;
1304                 if (obj.getClass() != getClass())
1305                         return false;
1306                 UpdateItem other = (UpdateItem)obj;
1307                 if (columnIndex != other.columnIndex)
1308                         return false;
1309                 if (element != null)
1310                         return element.equals(other.element);
1311                 return other.element == null;
1312         }
1313         
1314         @Override
1315         public int hashCode() {
1316                 if (element != null)
1317                         return element.hashCode() + columnIndex;
1318                 return 0;
1319         }
1320     }
1321     
1322     private void update(final TreeNode element, final int columnIndex) {
1323         if (DEBUG)System.out.println("update " + element + " " + columnIndex);
1324         if (viewer.getTree().isDisposed())
1325                 return;
1326         synchronized (pendingItems) {
1327                         pendingItems.add(new UpdateItem(element, columnIndex));
1328                         if (updating) return;
1329                         updateCounter++;
1330                         scheduleUpdater();
1331                 }
1332     }
1333
1334     private void update(final TreeNode element) {
1335         if (DEBUG)System.out.println("update " + element);
1336         if (viewer.getTree().isDisposed())
1337                 return;
1338         if (element != null && element.isDisposed())
1339                 return;
1340         synchronized (pendingItems) {
1341                 
1342                         pendingItems.add(new UpdateItem(element));
1343                         if (updating) return;
1344                         updateCounter++;
1345                         scheduleUpdater();
1346                 }
1347     }
1348     
1349     boolean scheduleUpdater() {
1350
1351         if (viewer.getTree().isDisposed())
1352             return false;
1353
1354         if (!pendingItems.isEmpty()) {
1355             
1356             int activity = explorerContext.activityInt;
1357             long delay = 30;
1358             if (activity < 100) {
1359                 //System.out.println("Scheduling update immediately.");
1360             } else if (activity < 1000) {
1361                 //System.out.println("Scheduling update after 500ms.");
1362                 delay = 500;
1363             } else {
1364                 //System.out.println("Scheduling update after 3000ms.");
1365                 delay = 3000;
1366             }
1367
1368             updateCounter = 0;
1369             
1370             //System.out.println("Scheduling UI update after " + delay + " ms.");
1371             uiUpdateScheduler.schedule(new Runnable() {
1372                 @Override
1373                 public void run() {
1374                         
1375                     if (viewer == null || viewer.getTree().isDisposed())
1376                         return;
1377                     
1378                     if (updateCounter > 0) {
1379                         updateCounter = 0;
1380                         uiUpdateScheduler.schedule(this, 50, TimeUnit.MILLISECONDS);
1381                     } else {
1382                         viewer.getTree().getDisplay().asyncExec(new UpdateRunner(GraphExplorerImpl2.this, GraphExplorerImpl2.this.explorerContext));
1383                     }
1384                     
1385                 }
1386             }, delay, TimeUnit.MILLISECONDS);
1387
1388             updating = true;
1389             return true;
1390         }
1391
1392         return false;
1393     }
1394     
1395     @Override
1396     public String startEditing(NodeContext context, String columnKey) {
1397         assertNotDisposed();
1398         if (!thread.currentThreadAccess())
1399             throw new IllegalStateException("not in SWT display thread " + thread.getThread());
1400
1401         if(columnKey.startsWith("#")) {
1402                 columnKey = columnKey.substring(1);
1403         }
1404
1405         Integer columnIndex = columnKeyToIndex.get(columnKey);
1406         if (columnIndex == null)
1407             return "Rename not supported for selection";
1408
1409         viewer.editElement(context, columnIndex);
1410         if(viewer.isCellEditorActive()) return null;
1411         return "Rename not supported for selection";
1412     }
1413
1414     @Override
1415     public String startEditing(String columnKey) {
1416         ISelection selection = postSelectionProvider.getSelection();
1417         if(selection == null) return "Rename not supported for selection";
1418         NodeContext context = ISelectionUtils.filterSingleSelection(selection, NodeContext.class);
1419         if(context == null) return "Rename not supported for selection";
1420
1421         return startEditing(context, columnKey);
1422
1423     }
1424     
1425     public void setSelection(final ISelection selection, boolean forceControlUpdate) {
1426         assertNotDisposed();
1427         boolean equalsOld = selectionProvider.selectionEquals(selection);
1428         if (equalsOld && !forceControlUpdate) {
1429             // Just set the selection object instance, fire no events nor update
1430             // the viewer selection.
1431             selectionProvider.setSelection(selection);
1432         } else {
1433                 Collection<NodeContext> coll =  AdaptionUtils.adaptToCollection(selection, NodeContext.class);
1434                 Collection<TreeNode> nodes = new ArrayList<TreeNode>();
1435                 for (NodeContext c : coll) {
1436                         List<TreeNode> match = contextToNodeMap.getValuesUnsafe(c);
1437                         if(match.size() > 0)
1438                                 nodes.add(match.get(0));
1439                 }
1440                 final ISelection sel = new StructuredSelection(nodes.toArray());
1441                 if (coll.size() == 0)
1442                         return;
1443             // Schedule viewer and selection update if necessary.
1444             if (viewer.getTree().isDisposed())
1445                 return;
1446             Display d = viewer.getTree().getDisplay();
1447             if (d.getThread() == Thread.currentThread()) {
1448                viewer.setSelection(sel);
1449             } else {
1450                 d.asyncExec(new Runnable() {
1451                     @Override
1452                     public void run() {
1453                         if (viewer.getTree().isDisposed())
1454                             return;
1455                         viewer.setSelection(sel);
1456                     }
1457                 });
1458             }
1459         }
1460     }
1461     
1462     @Override
1463     public void setModificationContext(ModificationContext modificationContext) {
1464         this.modificationContext = modificationContext;
1465         
1466     }
1467     
1468     final ExecutorService                        queryUpdateScheduler = Threads.getExecutor();
1469     
1470     private static class GeViewerContext extends AbstractDisposable implements IGraphExplorerContext {
1471         // This is for query debugging only.
1472         
1473         private GraphExplorerImpl2 ge;
1474         int                  queryIndent   = 0;
1475
1476         GECache2             cache         = new GECache2();
1477         AtomicBoolean        propagating   = new AtomicBoolean(false);
1478         Object               propagateList = new Object();
1479         Object               propagate     = new Object();
1480         List<Runnable>       scheduleList  = new ArrayList<Runnable>();
1481         final Deque<Integer> activity      = new LinkedList<Integer>();
1482         int                  activityInt   = 0;
1483         
1484         AtomicReference<Runnable> currentQueryUpdater = new AtomicReference<Runnable>();
1485
1486         /**
1487          * Keeps track of nodes that have already been auto-expanded. After
1488          * being inserted into this set, nodes will not be forced to stay in an
1489          * expanded state after that. This makes it possible for the user to
1490          * close auto-expanded nodes.
1491          */
1492         Map<NodeContext, Boolean>     autoExpanded  = new WeakHashMap<NodeContext, Boolean>();
1493
1494         public GeViewerContext(GraphExplorerImpl2 ge) {
1495                 this.ge = ge;
1496         }
1497         
1498         @Override
1499         protected void doDispose() {
1500                 //saveState();
1501             autoExpanded.clear();
1502         }
1503
1504         @Override
1505         public IGECache getCache() {
1506             return cache;
1507         }
1508
1509         @Override
1510         public int queryIndent() {
1511             return queryIndent;
1512         }
1513
1514         @Override
1515         public int queryIndent(int offset) {
1516             queryIndent += offset;
1517             return queryIndent;
1518         }
1519
1520         @Override
1521         @SuppressWarnings("unchecked")
1522         public <T> NodeQueryProcessor<T> getProcessor(Object o) {
1523                 if (ge == null)
1524                         return null;
1525             return ge.processors.get(o);
1526         }
1527
1528         @Override
1529         @SuppressWarnings("unchecked")
1530         public <T> PrimitiveQueryProcessor<T> getPrimitiveProcessor(Object o) {
1531             return ge.primitiveProcessors.get(o);
1532         }
1533
1534         @SuppressWarnings("unchecked")
1535         @Override
1536         public <T> DataSource<T> getDataSource(Class<T> clazz) {
1537             return ge.dataSources.get(clazz);
1538         }
1539
1540         @Override
1541         public void update(UIElementReference ref) {
1542                 if (ref instanceof ViewerCellReference) {
1543                     ViewerCellReference tiref = (ViewerCellReference) ref;
1544                     Object element = tiref.getElement();
1545                     int columnIndex = tiref.getColumn();
1546                     // NOTE: must be called regardless of the the item value.
1547                     // A null item is currently used to indicate a tree root update.
1548                     ge.update((TreeNode)element,columnIndex);
1549                 } else if (ref instanceof ViewerRowReference) {
1550                         ViewerRowReference rref = (ViewerRowReference)ref;
1551                         Object element = rref.getElement();
1552                         ge.update((TreeNode)element);
1553                 } else {
1554                         throw new IllegalArgumentException("Ui Reference is unknkown " + ref);
1555                 }
1556         }
1557
1558         @Override
1559         public Object getPropagateLock() {
1560             return propagate;
1561         }
1562
1563         @Override
1564         public Object getPropagateListLock() {
1565             return propagateList;
1566         }
1567
1568         @Override
1569         public boolean isPropagating() {
1570             return propagating.get();
1571         }
1572
1573         @Override
1574         public void setPropagating(boolean b) {
1575             this.propagating.set(b);
1576         }
1577
1578         @Override
1579         public List<Runnable> getScheduleList() {
1580             return scheduleList;
1581         }
1582
1583         @Override
1584         public void setScheduleList(List<Runnable> list) {
1585             this.scheduleList = list;
1586         }
1587
1588         @Override
1589         public Deque<Integer> getActivity() {
1590             return activity;
1591         }
1592
1593         @Override
1594         public void setActivityInt(int i) {
1595             this.activityInt = i;
1596         }
1597
1598         @Override
1599         public int getActivityInt() {
1600             return activityInt;
1601         }
1602
1603         @Override
1604         public void scheduleQueryUpdate(Runnable r) {
1605                 if (ge == null)
1606                         return;
1607             if (ge.isDisposed())
1608                 return;
1609             if (currentQueryUpdater.compareAndSet(null, r)) {
1610                 ge.queryUpdateScheduler.execute(QUERY_UPDATE_SCHEDULER);
1611             }
1612         }
1613
1614         Runnable QUERY_UPDATE_SCHEDULER = new Runnable() {
1615             @Override
1616             public void run() {
1617                 Runnable r = currentQueryUpdater.getAndSet(null);
1618                 if (r != null) {
1619                     r.run();
1620                 }
1621             }
1622         };
1623         
1624         @Override
1625         public void dispose() {
1626                 cache.dispose();
1627                 cache = new DummyCache();
1628                 scheduleList.clear();
1629                 autoExpanded.clear();
1630                 autoExpanded = null;
1631                 ge = null;
1632             
1633         }
1634
1635     }
1636     
1637     
1638    
1639     
1640     private static class GeViewerContentProvider implements ITreeContentProvider {
1641         @Override
1642         public Object[] getElements(Object inputElement) {
1643                 return getChildren(inputElement);
1644         }
1645         
1646         @Override
1647         public Object[] getChildren(Object element) {
1648                 TreeNode node = (TreeNode)element;
1649                 return node.getChildren().toArray();
1650                 
1651         }
1652         
1653         @Override
1654         public Object getParent(Object element) {
1655                 TreeNode node = (TreeNode)element;
1656                 return node.getParent();
1657         }
1658         
1659         @Override
1660         public boolean hasChildren(Object element) {
1661                 return getChildren(element).length > 0;
1662         }
1663         
1664         @Override
1665         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
1666                 
1667         }
1668         
1669         @Override
1670         public void dispose() {
1671                 
1672         }
1673     }
1674     
1675     private class GeViewerLabelProvider extends CellLabelProvider {
1676         private TreeNode node;
1677         
1678         private Labeler labeler;
1679         private Imager imager;
1680         Collection<LabelDecorator> labelDecorators;
1681         Collection<ImageDecorator> imageDecorators;
1682          
1683         Map<String, String> labels;
1684         Map<String, String> runtimeLabels;
1685         @Override
1686         public void update(ViewerCell cell) {
1687                 TreeNode node = (TreeNode)cell.getElement();
1688                 NodeContext ctx = node.getContext();
1689                 int columnIndex = cell.getColumnIndex();
1690                 String columnKey = columns[columnIndex].getKey();
1691                 
1692                 // using columnIndex 0 to refresh data.
1693                 // Note that this does not work if ViewerCellReferences are used. (At the moment there is no code that would use them).
1694                 if (node != this.node || columnIndex == 0) { 
1695                         this.node = node;
1696                         GENodeQueryManager manager = node.getManager();
1697                         labeler = manager.query(ctx, BuiltinKeys.SELECTED_LABELER);
1698                         imager = manager.query(ctx, BuiltinKeys.SELECTED_IMAGER);
1699                         labelDecorators = manager.query(ctx, BuiltinKeys.LABEL_DECORATORS);
1700                         imageDecorators = manager.query(ctx, BuiltinKeys.IMAGE_DECORATORS);
1701                         
1702                         if (labeler != null) {
1703                         labels = labeler.getLabels();
1704                                 runtimeLabels = labeler.getRuntimeLabels();
1705                 } else {
1706                         labels = null;
1707                         runtimeLabels = null;
1708                 }
1709                 }
1710
1711                 //if (DEBUG) System.out.println("GeViewerLabelProvider.update " + context + "  " + columnIndex);
1712                 
1713             setText(cell,  columnKey);
1714             setImage(cell, columnKey);
1715         }
1716
1717                 void setImage(ViewerCell cell, String columnKey) {
1718                         if (imager != null) {
1719                                 Object descOrImage = null;
1720                                 boolean hasUncachedImages = false;
1721
1722                                 ImageDescriptor desc = imager.getImage(columnKey);
1723                                 if (desc != null) {
1724                                         int index = 0;
1725                                         // Attempt to decorate the label
1726                                         if (!imageDecorators.isEmpty()) {
1727                                                 for (ImageDecorator id : imageDecorators) {
1728                                                         ImageDescriptor ds = id.decorateImage(desc, columnKey, index);
1729                                                         if (ds != null)
1730                                                                 desc = ds;
1731                                                 }
1732                                         }
1733
1734                                         // Try resolving only cached images here and now
1735                                         Object img = localResourceManager.find(desc);
1736                                         if (img == null)
1737                                                 img = resourceManager.find(desc);
1738
1739                                         descOrImage = img != null ? img : desc;
1740                                         hasUncachedImages |= img == null;
1741                                 }
1742
1743                                 if (!hasUncachedImages) {
1744                                         cell.setImage((Image) descOrImage);
1745                                 } else {
1746                                         // Schedule loading to another thread to refrain from
1747                                         // blocking
1748                                         // the UI with database operations.
1749                                         queueImageTask(node, new ImageTask(node, descOrImage));
1750                                 }
1751                         } else {
1752                                 cell.setImage(null);
1753                         }
1754                 }
1755
1756                 private void queueImageTask(TreeNode node, ImageTask task) {
1757                         synchronized (imageTasks) {
1758                                 imageTasks.put(node, task);
1759                         }
1760                         imageLoaderJob.scheduleIfNecessary(100);
1761                 }
1762
1763                 void setText(ViewerCell cell, String key) {
1764                         if (labeler != null) {
1765                                 String s = null;
1766                                 if (runtimeLabels != null)
1767                                         s = runtimeLabels.get(key);
1768                                 if (s == null)
1769                                         s = labels.get(key);
1770                                 //if (DEBUG) System.out.println(cell.getElement() + " " + cell.getColumnIndex() + " label:" + s + " key:" + key + " " + labels.size() + " " + (runtimeLabels == null ? "-1" : runtimeLabels.size()));
1771                                 if (s != null) {
1772                                         FontDescriptor font = originalFont;
1773                                         ColorDescriptor bg = originalBackground;
1774                                         ColorDescriptor fg = originalForeground;
1775                                         
1776                                         // Attempt to decorate the label
1777                                         if (!labelDecorators.isEmpty()) {
1778                                                 int index = 0;
1779                                                 for (LabelDecorator ld : labelDecorators) {
1780                                                         String ds = ld.decorateLabel(s, key, index);
1781                                                         if (ds != null)
1782                                                                 s = ds;
1783
1784                                                         FontDescriptor dfont = ld.decorateFont(font, key, index);
1785                                                         if (dfont != null)
1786                                                                 font = dfont;
1787
1788                                                         ColorDescriptor dbg = ld.decorateBackground(bg, key, index);
1789                                                         if (dbg != null)
1790                                                                 bg = dbg;
1791
1792                                                         ColorDescriptor dfg = ld.decorateForeground(fg, key, index);
1793                                                         if (dfg != null)
1794                                                                 fg = dfg;
1795                                                 }
1796                                         }
1797
1798                                         if (font != originalFont) {
1799                                                 // System.out.println("set font: " + index + ": " +
1800                                                 // font);
1801                                                 cell.setFont((Font) localResourceManager.get(font));
1802                                         } else {
1803                                                 cell.setFont((Font) (originalFont != null ? localResourceManager.get(originalFont) : null));
1804                                         }
1805                                         if (bg != originalBackground)
1806                                                 cell.setBackground((Color) localResourceManager.get(bg));
1807                                         else
1808                                                 cell.setBackground((Color) (originalBackground != null ? localResourceManager.get(originalBackground) : null));
1809                                         if (fg != originalForeground)
1810                                                 cell.setForeground((Color) localResourceManager.get(fg));
1811                                         else
1812                                                 cell.setForeground((Color) (originalForeground != null ? localResourceManager.get(originalForeground) : null));
1813
1814                                         cell.setText(s);
1815                                 }
1816                         } else {
1817                                 cell.setText(Labeler.NO_LABEL);
1818                         }
1819                         
1820                 }
1821     }
1822     
1823     
1824     
1825     private class GeEditingSupport extends EditingSupport {
1826         private Object lastElement;
1827         
1828         private Modifier lastModifier;
1829         
1830         private int columnIndex;
1831         public GeEditingSupport(ColumnViewer viewer, int columnIndex) {
1832                         super(viewer);
1833                         this.columnIndex = columnIndex;
1834                 }
1835
1836                 @Override
1837         protected boolean canEdit(Object element) {
1838                          if (filterSelectionEdit && !selectedNodes.contains(element)) {
1839                                  // When item is clicked, canEdit is called before the selection is updated.
1840                                  // This allows filtering edit attempts when the item is selected. 
1841                                  return false;
1842                          }
1843                         lastElement = null; // clear cached element + modifier.
1844                         Modifier modifier = getModifier((TreeNode)element);
1845                         if (modifier == null)
1846                                 return false;
1847                 return true;
1848         }
1849         
1850         @Override
1851         protected CellEditor getCellEditor(Object element) {
1852                 TreeNode node = (TreeNode) element;
1853                 Modifier modifier = getModifier((TreeNode)element);
1854                 NodeContext context = node.getContext();
1855                 if (modifier instanceof DialogModifier) {
1856                 return performDialogEditing(context, (DialogModifier) modifier);
1857             } else if (modifier instanceof CustomModifier) {
1858                 return startCustomEditing(node, (CustomModifier) modifier);
1859             } else if (modifier instanceof EnumerationModifier) {
1860                 return startEnumerationEditing((EnumerationModifier) modifier);
1861             } else {
1862                 return startTextEditing(modifier);
1863             }
1864                 
1865         }
1866         
1867         @Override
1868         protected Object getValue(Object element) {
1869                 Modifier modifier = getModifier((TreeNode)element);
1870                 return modifier.getValue();
1871         }
1872         @Override
1873         protected void setValue(Object element, Object value) {
1874                 Modifier modifier = getModifier((TreeNode)element);
1875                 // CustomModifiers have internal set value mechanism.
1876                 if (!(modifier instanceof CustomModifier))
1877                         modifier.modify((String)value);
1878                 
1879         }
1880         
1881         CellEditor startTextEditing( Modifier modifier) {
1882                 TextCellEditor editor = new ValidatedTextEditor(viewer.getTree());//new TextCellEditor(viewer.getTree());
1883                 editor.setValidator(new ModifierValidator(modifier));
1884                 return editor;
1885         }
1886         
1887         CellEditor startEnumerationEditing(EnumerationModifier modifier) {
1888                 if (SimanticsUI.isLinuxGTK()) {
1889                         // ComboBoxCellEditor2 does not work when GEImpl2 is embedded into dialog (It does work in SelectionView)
1890                         // CBCE2 does not work because it receives a focus lost event when the combo/popup is opened. 
1891                         return new EnumModifierEditor(viewer.getTree(),modifier);
1892                 } else {
1893                         return new EnumModifierEditor2(viewer.getTree(),modifier);
1894                 }
1895         }
1896         
1897         CellEditor performDialogEditing(final NodeContext context, final  DialogModifier modifier) {
1898                 DialogCellEditor editor = new DialogCellEditor(viewer.getTree()) {
1899                                 String res = null;
1900                                 @Override
1901                                 protected Object openDialogBox(Control cellEditorWindow) {
1902
1903                                     final Semaphore sem = new Semaphore(1);
1904                                         Consumer<String> callback = result -> {
1905                                             res = result;
1906                                             sem.release();
1907                                 };
1908                                         String status = modifier.query(cellEditorWindow, null, columnIndex, context, callback);
1909                                         if (status != null)
1910                                                 return null;
1911                                         try {
1912                                                 sem.acquire();
1913                                         } catch (InterruptedException e) {
1914                                                 e.printStackTrace();
1915                                         }
1916                                         return res;
1917                                 }
1918                                 
1919                                 
1920                         };
1921                         editor.setValidator(new ModifierValidator(modifier));
1922                         return editor;
1923         }
1924         
1925         CellEditor startCustomEditing(TreeNode node, CustomModifier modifier) {
1926                 CustomModifierEditor editor = new CustomModifierEditor(viewer.getTree(), modifier, node, columnIndex);
1927                 return editor;
1928         }
1929         
1930                 private Modifier getModifier(TreeNode element) {
1931                         if (element == lastElement)
1932                                 return lastModifier;
1933                         lastModifier =  GraphExplorerImpl2.this.getModifier(element, columnIndex);
1934                         lastElement = element;
1935                         return lastModifier;
1936                 }
1937         
1938         
1939     }
1940     
1941     private Modifier getModifier(TreeNode element, int columnIndex) {
1942                 GENodeQueryManager manager = element.getManager();
1943                 final NodeContext context = element.getContext();
1944             Labeler labeler = manager.query(context, BuiltinKeys.SELECTED_LABELER);
1945             if (labeler == null)
1946                  return null;
1947             Column column = columns[columnIndex];
1948
1949         return labeler.getModifier(modificationContext, column.getKey());
1950
1951         }
1952
1953     static class ImageTask {
1954         TreeNode node;
1955         Object descsOrImage;
1956         public ImageTask(TreeNode node, Object descsOrImage) {
1957             this.node = node;
1958             this.descsOrImage = descsOrImage;
1959         }
1960     }
1961
1962     /**
1963      * The job that is used for off-loading image loading tasks (see
1964      * {@link ImageTask} to a worker thread from the main UI thread.
1965      */
1966     ImageLoaderJob           imageLoaderJob;
1967     
1968    // Map<NodeContext, ImageTask> imageTasks     = new THashMap<NodeContext, ImageTask>();
1969     Map<TreeNode, ImageTask> imageTasks     = new THashMap<TreeNode, ImageTask>();
1970     
1971     /**
1972      * Invoked in a job worker thread.
1973      * 
1974      * @param monitor
1975      */
1976     @Override
1977     protected IStatus setPendingImages(IProgressMonitor monitor) {
1978         ImageTask[] tasks = null;
1979         synchronized (imageTasks) {
1980             tasks = imageTasks.values().toArray(new ImageTask[imageTasks.size()]);
1981             imageTasks.clear();
1982         }
1983
1984         MultiStatus status = null;
1985
1986         // Load missing images
1987         for (ImageTask task : tasks) {
1988             Object desc = task.descsOrImage;
1989                  if (desc instanceof ImageDescriptor) {
1990                         try {
1991                             desc = resourceManager.get((ImageDescriptor) desc);
1992                             task.descsOrImage = desc;
1993                         } catch (DeviceResourceException e) {
1994                             if (status == null)
1995                                 status = new MultiStatus(Activator.PLUGIN_ID, 0, "Problems loading images:", null);
1996                             status.add(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Image descriptor loading failed: " + desc, e));
1997                         }
1998                     }
1999             
2000         }
2001
2002         // Perform final UI updates in the UI thread.
2003         final ImageTask[] _tasks = tasks;
2004         thread.asyncExec(new Runnable() {
2005             @Override
2006             public void run() {
2007                 setImages(_tasks);
2008             }
2009         });
2010
2011         return status != null ? status : Status.OK_STATUS;
2012     }
2013     
2014
2015     void setImages(ImageTask[] tasks) {
2016         for (ImageTask task : tasks)
2017             if (task != null)
2018                 setImage(task);
2019     }
2020     
2021     void setImage(ImageTask task) {
2022         if (!task.node.isDisposed())
2023                 update(task.node, 0);
2024     }
2025     
2026         private static class GraphExplorerPostSelectionProvider implements IPostSelectionProvider {
2027                 
2028                 private GraphExplorerImpl2 ge;
2029                 
2030                 GraphExplorerPostSelectionProvider(GraphExplorerImpl2 ge) {
2031                         this.ge = ge;
2032                 }
2033                 
2034                 void dispose() {
2035                         ge = null;
2036                 }
2037                 
2038             @Override
2039             public void setSelection(final ISelection selection) {
2040                 if(ge == null) return;
2041                 ge.setSelection(selection, false);
2042                 
2043             }
2044             
2045
2046             @Override
2047             public void removeSelectionChangedListener(ISelectionChangedListener listener) {
2048                 if(ge == null) return;
2049                 if(ge.isDisposed()) {
2050                     if (DEBUG_SELECTION_LISTENERS)
2051                         System.out.println("GraphExplorerImpl is disposed in removeSelectionChangedListener: " + listener);
2052                     return;
2053                 }
2054                 ge.selectionProvider.removeSelectionChangedListener(listener);
2055             }
2056             
2057             @Override
2058             public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
2059                 if(ge == null) return;
2060                 if (!ge.thread.currentThreadAccess())
2061                     throw new AssertionError(getClass().getSimpleName() + ".addPostSelectionChangedListener called from non SWT-thread: " + Thread.currentThread());
2062                 if(ge.isDisposed()) {
2063                     System.out.println("Client BUG: GraphExplorerImpl is disposed in addPostSelectionChangedListener: " + listener);
2064                     return;
2065                 }
2066                 ge.selectionProvider.addPostSelectionChangedListener(listener);
2067             }
2068
2069             @Override
2070             public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
2071                 if(ge == null) return;
2072                 if(ge.isDisposed()) {
2073                     if (DEBUG_SELECTION_LISTENERS)
2074                         System.out.println("GraphExplorerImpl is disposed in removePostSelectionChangedListener: " + listener);
2075                     return;
2076                 }
2077                 ge.selectionProvider.removePostSelectionChangedListener(listener);
2078             }
2079             
2080
2081             @Override
2082             public void addSelectionChangedListener(ISelectionChangedListener listener) {
2083                 if(ge == null) return;
2084                 if (!ge.thread.currentThreadAccess())
2085                     throw new AssertionError(getClass().getSimpleName() + ".addSelectionChangedListener called from non SWT-thread: " + Thread.currentThread());
2086                 if (ge.viewer.getTree().isDisposed() || ge.selectionProvider == null) {
2087                     System.out.println("Client BUG: GraphExplorerImpl is disposed in addSelectionChangedListener: " + listener);
2088                     return;
2089                 }
2090
2091                 ge.selectionProvider.addSelectionChangedListener(listener);
2092             }
2093
2094             
2095             @Override
2096             public ISelection getSelection() {
2097                 if(ge == null) return StructuredSelection.EMPTY;
2098                 if (!ge.thread.currentThreadAccess())
2099                     throw new AssertionError(getClass().getSimpleName() + ".getSelection called from non SWT-thread: " + Thread.currentThread());
2100                 if (ge.viewer.getTree().isDisposed() || ge.selectionProvider == null)
2101                     return StructuredSelection.EMPTY;
2102                 return ge.selectionProvider.getSelection();
2103             }
2104             
2105         }
2106         
2107         static class ModifierValidator implements ICellEditorValidator {
2108                 private Modifier modifier;
2109                 public ModifierValidator(Modifier modifier) {
2110                         this.modifier = modifier;
2111                 }
2112                 
2113                 @Override
2114                 public String isValid(Object value) {
2115                         return modifier.isValid((String)value);
2116                 }
2117         }
2118         
2119         static class UpdateRunner implements Runnable {
2120
2121             final GraphExplorerImpl2 ge;
2122
2123             UpdateRunner(GraphExplorerImpl2 ge, IGraphExplorerContext geContext) {
2124                 this.ge = ge;
2125             }
2126
2127             public void run() {
2128                 try {
2129                         doRun();
2130                 } catch (Throwable t) {
2131                         t.printStackTrace();
2132                 }
2133             }
2134
2135             public void doRun() {
2136                 
2137                 if (ge.isDisposed())
2138                     return;
2139
2140                 HashSet<UpdateItem> items;
2141
2142                 ScrollBar verticalBar = ge.viewer.getTree().getVerticalBar();
2143               
2144                 
2145                 synchronized (ge.pendingItems) {
2146                    items = ge.pendingItems;
2147                    ge.pendingItems = new HashSet<UpdateItem>();
2148                 }
2149                 if (DEBUG) System.out.println("UpdateRunner.doRun() " + items.size());
2150
2151                 ge.viewer.getTree().setRedraw(false);
2152             for (UpdateItem item : items) {
2153                 item.update(ge.viewer);
2154             }
2155             
2156             // check if vertical scroll bar has become visible and refresh layout.
2157             boolean currentlyVerticalBarVisible = verticalBar.isVisible();
2158             if (ge.verticalBarVisible != currentlyVerticalBarVisible) {
2159                 ge.verticalBarVisible = currentlyVerticalBarVisible;
2160                 ge.viewer.getTree().getParent().layout();
2161             }
2162             
2163             ge.viewer.getTree().setRedraw(true);
2164             
2165                 synchronized (ge.pendingItems) {
2166                     if (!ge.scheduleUpdater()) {
2167                         ge.updating = false;
2168                     }
2169                 }
2170                 if (DEBUG) {
2171                         if (!ge.updating) {
2172                                  ge.printTree(ge.rootNode, 0);
2173                         }
2174                 }
2175             }
2176
2177         }
2178         
2179         private class ValidatedTextEditor extends TextCellEditor {
2180                 
2181
2182                 public ValidatedTextEditor(Composite parent) {
2183                         super(parent);
2184                 }
2185
2186                 protected void editOccured(org.eclipse.swt.events.ModifyEvent e) {
2187                          String value = text.getText();
2188                         if (value == null) {
2189                                         value = "";//$NON-NLS-1$
2190                                 }
2191                         Object typedValue = value;
2192                         boolean oldValidState = isValueValid();
2193                         boolean newValidState = isCorrect(typedValue);
2194                         if (!newValidState) {
2195                            text.setBackground(invalidModificationColor);
2196                            text.setToolTipText(getErrorMessage());
2197                         } else {
2198                                 text.setBackground(null);
2199                                 text.setToolTipText(null);
2200                         }
2201                         valueChanged(oldValidState, newValidState);
2202                 };
2203         }
2204         
2205         private class EnumModifierEditor2 extends ComboBoxCellEditor2 {
2206                 
2207                 List<String> values;
2208                 public EnumModifierEditor2(Composite parent, EnumerationModifier modifier) {
2209                         super(parent,modifier.getValues().toArray(new String[modifier.getValues().size()]),SWT.READ_ONLY);
2210                         values = modifier.getValues();
2211                         setValidator(new ModifierValidator(modifier));
2212                 }
2213                 @Override
2214                 protected void doSetValue(Object value) {
2215                         super.doSetValue((Integer)values.indexOf(value));
2216                 }
2217                 
2218                 @Override
2219                 protected Object doGetValue() {
2220                         return values.get((Integer)super.doGetValue());
2221                 }
2222         };
2223         
2224         private class EnumModifierEditor extends ComboBoxCellEditor {
2225                 
2226                 List<String> values;
2227                 public EnumModifierEditor(Composite parent, EnumerationModifier modifier) {
2228                         super(parent,modifier.getValues().toArray(new String[modifier.getValues().size()]),SWT.READ_ONLY);
2229                         values = modifier.getValues();
2230                         setValidator(new ModifierValidator(modifier));
2231                 }
2232                 @Override
2233                 protected void doSetValue(Object value) {
2234                         super.doSetValue((Integer)values.indexOf(value));
2235                 }
2236                 
2237                 @Override
2238                 protected Object doGetValue() {
2239                         return values.get((Integer)super.doGetValue());
2240                 }
2241         };
2242         
2243         
2244         private class CustomModifierEditor extends CellEditor implements ICellEditorValidator, DisposeListener {
2245                 private CustomModifier modifier;
2246                 private TreeNode node;
2247                 private NodeContext context;
2248                 private int columnIndex;
2249                 private Composite control;
2250                 private Control origControl;
2251                 
2252                 public CustomModifierEditor(Composite parent, CustomModifier modifier, TreeNode node, int columnIndex) {
2253                         this.modifier = modifier;
2254                         this.node = node;
2255                         this.context = node.getContext();
2256                         this.columnIndex = columnIndex;
2257                         setValidator(this);
2258                         create(parent);
2259                 }
2260                 
2261                 @Override
2262                 protected Control createControl(Composite parent) {
2263                         control = new Composite(parent, SWT.NONE);
2264                         control.setLayout(new FillLayout());
2265                         origControl = (Control) modifier.createControl(control, null, columnIndex, context);
2266                         return control;
2267                 }
2268                 
2269                 
2270                 
2271                 @Override
2272                 protected Object doGetValue() {
2273                         return modifier.getValue();
2274                 }
2275                 
2276                 @Override
2277                 protected void doSetValue(Object value) {
2278                         //CustomModifier handles value setting internally.
2279                 }
2280                 
2281                 
2282                 private void reCreate() {
2283                         modifier = (CustomModifier)getModifier(node, columnIndex);
2284                         if (control != null && !control.isDisposed()) {
2285                                 if (!origControl.isDisposed())
2286                                         origControl.dispose();
2287                                 origControl = (Control)modifier.createControl(control, null, columnIndex, context);
2288                                 origControl.addDisposeListener(this);
2289                         }
2290                 }
2291                 protected void doSetFocus() {
2292                         if (control != null && !control.isDisposed())
2293                                 control.setFocus();
2294                 };
2295                 
2296                 @Override
2297                 public void widgetDisposed(DisposeEvent e) {
2298                         if (e.widget == origControl) {
2299                                 reCreate();
2300                         }
2301                         
2302                 }
2303                 
2304                 @Override
2305                 public String isValid(Object value) {
2306                         return modifier.isValid((String)value);
2307                 }
2308
2309         }
2310         
2311         private class TreeNode implements IAdaptable {
2312                 private NodeContext context;
2313                 
2314                 private TreeNode parent;
2315                 private List<TreeNode> children = new ArrayList<TreeNode>();
2316                 private GENodeQueryManager manager;
2317                 
2318                 private TreeNode(NodeContext context) {
2319                         if (context == null)
2320                                 throw new NullPointerException();
2321                         this.context = context;
2322                         contextToNodeMap.add(context, this);
2323                         manager = new GENodeQueryManager(explorerContext, null, null, ViewerRowReference.create(this));
2324                 }
2325                 
2326                 public List<TreeNode> getChildren() {
2327                         synchronized (children) {
2328                                 return children;
2329                         }
2330                 }
2331                 
2332                 public TreeNode getParent() {
2333                         return parent;
2334                 }
2335                 
2336                 public NodeContext getContext() {
2337                         return context;
2338                 }
2339                 
2340                 public GENodeQueryManager getManager() {
2341                         return manager;
2342                 }
2343                 
2344                 public TreeNode addChild(NodeContext context) {
2345                         TreeNode child = new TreeNode(context);
2346                         child.parent = this;
2347                         children.add(child);
2348                         if (DEBUG) System.out.println("Add " + this  + " -> " + child);
2349                         return child;
2350                 }
2351                 
2352                 public TreeNode addChild(int index, NodeContext context) {
2353                         
2354                         TreeNode child = new TreeNode(context);
2355                         child.parent = this;
2356                         children.add(index,child);
2357                         if (DEBUG) System.out.println("Add " + this  + " -> " + child + " at " + index);
2358                         return child;
2359                 }
2360                 
2361                 public TreeNode setChild(int index, NodeContext context) {
2362                         
2363                         TreeNode child = new TreeNode(context);
2364                         child.parent = this;
2365                         children.set(index,child);
2366                         if (DEBUG) System.out.println("Set " + this  + " -> " + child + " at " + index);
2367                         return child;
2368                 }
2369                 
2370                 public int distanceToRoot() {
2371                         int i = 0;
2372                         TreeNode n = getParent();
2373                         while (n != null) {
2374                                 n = n.getParent();
2375                                 i++;
2376                         }
2377                         return i;
2378                                 
2379                 }
2380                 
2381                 public void dispose() {
2382                         if (parent != null)
2383                                 parent.children.remove(this);
2384                         dispose2();
2385                 }
2386                 
2387                 public void dispose2() {
2388                         if (DEBUG)      System.out.println("dispose " + this);
2389                         parent = null;
2390                         for (TreeNode n : children) {
2391                                 n.dispose2();
2392                         }
2393                         clearCache();
2394                         children.clear();
2395                         contextToNodeMap.remove(context, this);
2396                         context = null;
2397                         manager.dispose();
2398                         manager = null; 
2399                 }
2400                 
2401                 private void clearCache() {
2402                         if (explorerContext != null) {
2403                                 GECache2 cache = explorerContext.cache;
2404                                 
2405                                 if (cache != null) {
2406                                         cache.dispose(context);
2407                                 }
2408                         }
2409                 }
2410                 
2411                 public boolean updateChildren() {
2412                         if (context == null)
2413                                 throw new IllegalStateException("Node is disposed.");
2414                         
2415                 NodeContext[] childContexts = manager.query(context, BuiltinKeys.FINAL_CHILDREN);
2416                 
2417                 if (DEBUG) System.out.println("updateChildren " + childContexts.length + " " + this);
2418                 
2419                 
2420                 boolean modified = false;
2421                 synchronized (children) {
2422                         
2423                         int oldCount = children.size();
2424                         BijectionMap<Integer, Integer> indexes = new BijectionMap<Integer, Integer>();
2425                         Set<Integer> mapped = new HashSet<Integer>();
2426                         boolean reorder = false;
2427                         // locate matching pairs form old and new children
2428                         for (int i = 0; i < oldCount; i++) {
2429                                 NodeContext oldCtx = children.get(i).context;
2430                                 for (int j = 0; j <childContexts.length; j++) {
2431                                         if (mapped.contains(j))
2432                                                 continue;
2433                                         if (oldCtx.equals(childContexts[j])) {
2434                                                 indexes.map(i, j);
2435                                                 mapped.add(j);
2436                                                 if (i != j)
2437                                                         reorder = true;
2438                                                 break;
2439                                         }
2440                                 }
2441                         }
2442                         // update children if required
2443                         if (childContexts.length != oldCount || reorder || childContexts.length != indexes.size()) {
2444                                 modified = true;
2445                                 List<TreeNode> oldChildren = new ArrayList<TreeNode>(oldCount);
2446                                 oldChildren.addAll(children);
2447                                 if (childContexts.length >= oldCount) {
2448                                 for (int i = 0; i < oldCount; i++) {
2449                                         Integer oldIndex = indexes.getLeft(i);
2450                                         if (oldIndex == null) {
2451                                                 setChild(i, childContexts[i]);
2452                                         } else {
2453                                                 TreeNode n = oldChildren.get(oldIndex);
2454                                                 children.set(i, n);
2455                                         }
2456                                         
2457                                 }
2458                                 for (int i = oldCount; i < childContexts.length; i++) {
2459                                         addChild(childContexts[i]);
2460                                 }
2461                         } else {
2462                                 for (int i = 0; i < childContexts.length; i++) {
2463                                         Integer oldIndex = indexes.getLeft(i);
2464                                         if (oldIndex == null) {
2465                                                 setChild(i, childContexts[i]);
2466                                         } else {
2467                                                 TreeNode n = oldChildren.get(oldIndex);
2468                                                 children.set(i, n);
2469                                         }
2470                                 }
2471                                 for (int i = oldCount -1; i >= childContexts.length; i--) {
2472                                         children.remove(i);
2473                                 }
2474                         }
2475                                 for (int i = 0; i < oldChildren.size(); i++) {
2476                                         if (!indexes.containsLeft(i)) {
2477                                                 oldChildren.get(i).dispose2();