1 /*******************************************************************************
\r
2 * Copyright (c) 2007, 2012 Association for Decentralized Information Management
\r
3 * in Industry THTH ry.
\r
4 * All rights reserved. This program and the accompanying materials
\r
5 * are made available under the terms of the Eclipse Public License v1.0
\r
6 * which accompanies this distribution, and is available at
\r
7 * http://www.eclipse.org/legal/epl-v10.html
\r
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.browsing.ui.swt;
\r
14 import java.util.ArrayList;
\r
15 import java.util.Arrays;
\r
16 import java.util.Collection;
\r
17 import java.util.Collections;
\r
18 import java.util.Deque;
\r
19 import java.util.HashMap;
\r
20 import java.util.HashSet;
\r
21 import java.util.Iterator;
\r
22 import java.util.LinkedList;
\r
23 import java.util.List;
\r
24 import java.util.Map;
\r
25 import java.util.Set;
\r
26 import java.util.WeakHashMap;
\r
27 import java.util.concurrent.CopyOnWriteArrayList;
\r
28 import java.util.concurrent.ExecutorService;
\r
29 import java.util.concurrent.Future;
\r
30 import java.util.concurrent.ScheduledExecutorService;
\r
31 import java.util.concurrent.TimeUnit;
\r
32 import java.util.concurrent.atomic.AtomicBoolean;
\r
33 import java.util.concurrent.atomic.AtomicReference;
\r
34 import java.util.function.Consumer;
\r
36 import org.eclipse.core.runtime.Assert;
\r
37 import org.eclipse.core.runtime.AssertionFailedException;
\r
38 import org.eclipse.core.runtime.IProgressMonitor;
\r
39 import org.eclipse.core.runtime.IStatus;
\r
40 import org.eclipse.core.runtime.MultiStatus;
\r
41 import org.eclipse.core.runtime.Platform;
\r
42 import org.eclipse.core.runtime.Status;
\r
43 import org.eclipse.core.runtime.jobs.Job;
\r
44 import org.eclipse.jface.action.IStatusLineManager;
\r
45 import org.eclipse.jface.resource.ColorDescriptor;
\r
46 import org.eclipse.jface.resource.DeviceResourceException;
\r
47 import org.eclipse.jface.resource.DeviceResourceManager;
\r
48 import org.eclipse.jface.resource.FontDescriptor;
\r
49 import org.eclipse.jface.resource.ImageDescriptor;
\r
50 import org.eclipse.jface.resource.JFaceResources;
\r
51 import org.eclipse.jface.resource.LocalResourceManager;
\r
52 import org.eclipse.jface.resource.ResourceManager;
\r
53 import org.eclipse.jface.viewers.IPostSelectionProvider;
\r
54 import org.eclipse.jface.viewers.ISelection;
\r
55 import org.eclipse.jface.viewers.ISelectionChangedListener;
\r
56 import org.eclipse.jface.viewers.ISelectionProvider;
\r
57 import org.eclipse.jface.viewers.IStructuredSelection;
\r
58 import org.eclipse.jface.viewers.SelectionChangedEvent;
\r
59 import org.eclipse.jface.viewers.StructuredSelection;
\r
60 import org.eclipse.jface.viewers.TreeSelection;
\r
61 import org.eclipse.swt.SWT;
\r
62 import org.eclipse.swt.SWTException;
\r
63 import org.eclipse.swt.custom.CCombo;
\r
64 import org.eclipse.swt.custom.TreeEditor;
\r
65 import org.eclipse.swt.events.FocusEvent;
\r
66 import org.eclipse.swt.events.FocusListener;
\r
67 import org.eclipse.swt.events.KeyEvent;
\r
68 import org.eclipse.swt.events.KeyListener;
\r
69 import org.eclipse.swt.events.MouseEvent;
\r
70 import org.eclipse.swt.events.MouseListener;
\r
71 import org.eclipse.swt.events.SelectionEvent;
\r
72 import org.eclipse.swt.events.SelectionListener;
\r
73 import org.eclipse.swt.graphics.Color;
\r
74 import org.eclipse.swt.graphics.Font;
\r
75 import org.eclipse.swt.graphics.GC;
\r
76 import org.eclipse.swt.graphics.Image;
\r
77 import org.eclipse.swt.graphics.Point;
\r
78 import org.eclipse.swt.graphics.RGB;
\r
79 import org.eclipse.swt.graphics.Rectangle;
\r
80 import org.eclipse.swt.widgets.Composite;
\r
81 import org.eclipse.swt.widgets.Control;
\r
82 import org.eclipse.swt.widgets.Display;
\r
83 import org.eclipse.swt.widgets.Event;
\r
84 import org.eclipse.swt.widgets.Listener;
\r
85 import org.eclipse.swt.widgets.ScrollBar;
\r
86 import org.eclipse.swt.widgets.Shell;
\r
87 import org.eclipse.swt.widgets.Text;
\r
88 import org.eclipse.swt.widgets.Tree;
\r
89 import org.eclipse.swt.widgets.TreeColumn;
\r
90 import org.eclipse.swt.widgets.TreeItem;
\r
91 import org.eclipse.ui.IWorkbenchPart;
\r
92 import org.eclipse.ui.IWorkbenchSite;
\r
93 import org.eclipse.ui.PlatformUI;
\r
94 import org.eclipse.ui.contexts.IContextActivation;
\r
95 import org.eclipse.ui.contexts.IContextService;
\r
96 import org.eclipse.ui.services.IServiceLocator;
\r
97 import org.eclipse.ui.swt.IFocusService;
\r
98 import org.simantics.browsing.ui.BuiltinKeys;
\r
99 import org.simantics.browsing.ui.CheckedState;
\r
100 import org.simantics.browsing.ui.Column;
\r
101 import org.simantics.browsing.ui.Column.Align;
\r
102 import org.simantics.browsing.ui.DataSource;
\r
103 import org.simantics.browsing.ui.ExplorerState;
\r
104 import org.simantics.browsing.ui.GraphExplorer;
\r
105 import org.simantics.browsing.ui.NodeContext;
\r
106 import org.simantics.browsing.ui.NodeContext.CacheKey;
\r
107 import org.simantics.browsing.ui.NodeContext.PrimitiveQueryKey;
\r
108 import org.simantics.browsing.ui.NodeContext.QueryKey;
\r
109 import org.simantics.browsing.ui.NodeContextPath;
\r
110 import org.simantics.browsing.ui.NodeQueryManager;
\r
111 import org.simantics.browsing.ui.NodeQueryProcessor;
\r
112 import org.simantics.browsing.ui.PrimitiveQueryProcessor;
\r
113 import org.simantics.browsing.ui.SelectionDataResolver;
\r
114 import org.simantics.browsing.ui.SelectionFilter;
\r
115 import org.simantics.browsing.ui.StatePersistor;
\r
116 import org.simantics.browsing.ui.common.ColumnKeys;
\r
117 import org.simantics.browsing.ui.common.ErrorLogger;
\r
118 import org.simantics.browsing.ui.common.NodeContextBuilder;
\r
119 import org.simantics.browsing.ui.common.NodeContextUtil;
\r
120 import org.simantics.browsing.ui.common.internal.GECache;
\r
121 import org.simantics.browsing.ui.common.internal.GENodeQueryManager;
\r
122 import org.simantics.browsing.ui.common.internal.IGECache;
\r
123 import org.simantics.browsing.ui.common.internal.IGraphExplorerContext;
\r
124 import org.simantics.browsing.ui.common.internal.UIElementReference;
\r
125 import org.simantics.browsing.ui.common.processors.DefaultCheckedStateProcessor;
\r
126 import org.simantics.browsing.ui.common.processors.DefaultComparableChildrenProcessor;
\r
127 import org.simantics.browsing.ui.common.processors.DefaultFinalChildrenProcessor;
\r
128 import org.simantics.browsing.ui.common.processors.DefaultImageDecoratorProcessor;
\r
129 import org.simantics.browsing.ui.common.processors.DefaultImagerFactoriesProcessor;
\r
130 import org.simantics.browsing.ui.common.processors.DefaultImagerProcessor;
\r
131 import org.simantics.browsing.ui.common.processors.DefaultLabelDecoratorProcessor;
\r
132 import org.simantics.browsing.ui.common.processors.DefaultLabelerFactoriesProcessor;
\r
133 import org.simantics.browsing.ui.common.processors.DefaultLabelerProcessor;
\r
134 import org.simantics.browsing.ui.common.processors.DefaultPrunedChildrenProcessor;
\r
135 import org.simantics.browsing.ui.common.processors.DefaultSelectedImageDecoratorFactoriesProcessor;
\r
136 import org.simantics.browsing.ui.common.processors.DefaultSelectedLabelDecoratorFactoriesProcessor;
\r
137 import org.simantics.browsing.ui.common.processors.DefaultSelectedLabelerProcessor;
\r
138 import org.simantics.browsing.ui.common.processors.DefaultSelectedViewpointFactoryProcessor;
\r
139 import org.simantics.browsing.ui.common.processors.DefaultSelectedViewpointProcessor;
\r
140 import org.simantics.browsing.ui.common.processors.DefaultViewpointContributionProcessor;
\r
141 import org.simantics.browsing.ui.common.processors.DefaultViewpointContributionsProcessor;
\r
142 import org.simantics.browsing.ui.common.processors.DefaultViewpointProcessor;
\r
143 import org.simantics.browsing.ui.common.processors.IsExpandedProcessor;
\r
144 import org.simantics.browsing.ui.common.processors.NoSelectionRequestProcessor;
\r
145 import org.simantics.browsing.ui.common.processors.ProcessorLifecycle;
\r
146 import org.simantics.browsing.ui.content.ImageDecorator;
\r
147 import org.simantics.browsing.ui.content.Imager;
\r
148 import org.simantics.browsing.ui.content.LabelDecorator;
\r
149 import org.simantics.browsing.ui.content.Labeler;
\r
150 import org.simantics.browsing.ui.content.Labeler.CustomModifier;
\r
151 import org.simantics.browsing.ui.content.Labeler.DeniedModifier;
\r
152 import org.simantics.browsing.ui.content.Labeler.DialogModifier;
\r
153 import org.simantics.browsing.ui.content.Labeler.EnumerationModifier;
\r
154 import org.simantics.browsing.ui.content.Labeler.FilteringModifier;
\r
155 import org.simantics.browsing.ui.content.Labeler.LabelerListener;
\r
156 import org.simantics.browsing.ui.content.Labeler.Modifier;
\r
157 import org.simantics.browsing.ui.content.PrunedChildrenResult;
\r
158 import org.simantics.browsing.ui.model.nodetypes.EntityNodeType;
\r
159 import org.simantics.browsing.ui.model.nodetypes.NodeType;
\r
160 import org.simantics.browsing.ui.swt.internal.Threads;
\r
161 import org.simantics.db.layer0.SelectionHints;
\r
162 import org.simantics.utils.ObjectUtils;
\r
163 import org.simantics.utils.datastructures.BijectionMap;
\r
164 import org.simantics.utils.datastructures.BinaryFunction;
\r
165 import org.simantics.utils.datastructures.disposable.AbstractDisposable;
\r
166 import org.simantics.utils.datastructures.hints.IHintContext;
\r
167 import org.simantics.utils.threads.IThreadWorkQueue;
\r
168 import org.simantics.utils.threads.SWTThread;
\r
169 import org.simantics.utils.threads.ThreadUtils;
\r
170 import org.simantics.utils.ui.ISelectionUtils;
\r
171 import org.simantics.utils.ui.jface.BasePostSelectionProvider;
\r
172 import org.simantics.utils.ui.widgets.VetoingEventHandler;
\r
173 import org.simantics.utils.ui.workbench.WorkbenchUtils;
\r
175 import gnu.trove.map.hash.THashMap;
\r
176 import gnu.trove.procedure.TObjectProcedure;
\r
177 import gnu.trove.set.hash.THashSet;
\r
180 * @see #getMaxChildren()
\r
181 * @see #setMaxChildren(int)
\r
182 * @see #getMaxChildren(NodeQueryManager, NodeContext)
\r
184 class GraphExplorerImpl extends GraphExplorerImplBase implements Listener, GraphExplorer /*, IPostSelectionProvider*/ {
\r
186 private static class GraphExplorerPostSelectionProvider implements IPostSelectionProvider {
\r
188 private GraphExplorerImpl ge;
\r
190 GraphExplorerPostSelectionProvider(GraphExplorerImpl ge) {
\r
199 public void setSelection(final ISelection selection) {
\r
200 if(ge == null) return;
\r
201 ge.setSelection(selection, false);
\r
206 public void removeSelectionChangedListener(ISelectionChangedListener listener) {
\r
207 if(ge == null) return;
\r
208 if(ge.isDisposed()) {
\r
209 if (DEBUG_SELECTION_LISTENERS)
\r
210 System.out.println("GraphExplorerImpl is disposed in removeSelectionChangedListener: " + listener);
\r
213 //assertNotDisposed();
\r
214 //System.out.println("Remove selection changed listener: " + listener);
\r
215 ge.selectionProvider.removeSelectionChangedListener(listener);
\r
219 public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
\r
220 if(ge == null) return;
\r
221 if (!ge.thread.currentThreadAccess())
\r
222 throw new AssertionError(getClass().getSimpleName() + ".addPostSelectionChangedListener called from non SWT-thread: " + Thread.currentThread());
\r
223 if(ge.isDisposed()) {
\r
224 System.out.println("Client BUG: GraphExplorerImpl is disposed in addPostSelectionChangedListener: " + listener);
\r
227 //System.out.println("Add POST selection changed listener: " + listener);
\r
228 ge.selectionProvider.addPostSelectionChangedListener(listener);
\r
232 public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
\r
233 if(ge == null) return;
\r
234 if(ge.isDisposed()) {
\r
235 if (DEBUG_SELECTION_LISTENERS)
\r
236 System.out.println("GraphExplorerImpl is disposed in removePostSelectionChangedListener: " + listener);
\r
239 // assertNotDisposed();
\r
240 //System.out.println("Remove POST selection changed listener: " + listener);
\r
241 ge.selectionProvider.removePostSelectionChangedListener(listener);
\r
246 public void addSelectionChangedListener(ISelectionChangedListener listener) {
\r
247 if(ge == null) return;
\r
248 if (!ge.thread.currentThreadAccess())
\r
249 throw new AssertionError(getClass().getSimpleName() + ".addSelectionChangedListener called from non SWT-thread: " + Thread.currentThread());
\r
250 //System.out.println("Add selection changed listener: " + listener);
\r
251 if (ge.tree.isDisposed() || ge.selectionProvider == null) {
\r
252 System.out.println("Client BUG: GraphExplorerImpl is disposed in addSelectionChangedListener: " + listener);
\r
256 ge.selectionProvider.addSelectionChangedListener(listener);
\r
261 public ISelection getSelection() {
\r
262 if(ge == null) return StructuredSelection.EMPTY;
\r
263 if (!ge.thread.currentThreadAccess())
\r
264 throw new AssertionError(getClass().getSimpleName() + ".getSelection called from non SWT-thread: " + Thread.currentThread());
\r
265 if (ge.tree.isDisposed() || ge.selectionProvider == null)
\r
266 return StructuredSelection.EMPTY;
\r
267 return ge.selectionProvider.getSelection();
\r
273 * If this explorer is running with an Eclipse workbench open, this
\r
274 * Workbench UI context will be activated whenever inline editing is started
\r
275 * through {@link #startEditing(TreeItem, int)} and deactivated when inline
\r
276 * editing finishes.
\r
278 * This context information can be used to for UI handler activity testing.
\r
280 private static final String INLINE_EDITING_UI_CONTEXT = "org.simantics.browsing.ui.inlineEditing";
\r
282 private static final String KEY_DRAG_COLUMN = "dragColumn";
\r
284 private static final boolean DEBUG_SELECTION_LISTENERS = false;
\r
286 private static final int DEFAULT_CONSECUTIVE_LABEL_REFRESH_DELAY = 200;
\r
288 public static final int DEFAULT_MAX_CHILDREN = 1000;
\r
290 private static final long POST_SELECTION_DELAY = 300;
\r
293 * The time in milliseconds that must elapse between consecutive
\r
294 * {@link Tree} {@link SelectionListener#widgetSelected(SelectionEvent)}
\r
295 * invocations in order for this class to construct a new selection.
\r
298 * This is done because selection construction can be very expensive as the
\r
299 * selected set grows larger when the user is pressing shift+arrow keys.
\r
300 * GraphExplorerImpl will naturally listen to all changes in the tree
\r
301 * selection, but as an optimization will not construct new
\r
302 * StructuredSelection instances for every selection change event. A new
\r
303 * selection will be constructed and set only if the selection hasn't
\r
304 * changed for the amount of milliseconds specified by this constant.
\r
306 private static final long SELECTION_CHANGE_QUIET_TIME = 150;
\r
308 private final IThreadWorkQueue thread;
\r
311 * Local method for checking from whether resources are loaded in
\r
314 private final LocalResourceManager localResourceManager;
\r
317 * Local device resource manager that is safe to use in
\r
318 * {@link ImageLoaderJob} for creating images in a non-UI thread.
\r
320 private final ResourceManager resourceManager;
\r
323 * Package visibility.
\r
324 * TODO: Get rid of these.
\r
328 @SuppressWarnings({ "rawtypes" })
\r
329 final HashMap<CacheKey<?>, NodeQueryProcessor> processors = new HashMap<CacheKey<?>, NodeQueryProcessor>();
\r
330 @SuppressWarnings({ "rawtypes" })
\r
331 final HashMap<Object, PrimitiveQueryProcessor> primitiveProcessors = new HashMap<Object, PrimitiveQueryProcessor>();
\r
332 @SuppressWarnings({ "rawtypes" })
\r
333 final HashMap<Class, DataSource> dataSources = new HashMap<Class, DataSource>();
\r
335 class GraphExplorerContext extends AbstractDisposable implements IGraphExplorerContext {
\r
336 // This is for query debugging only.
\r
337 int queryIndent = 0;
\r
339 GECache cache = new GECache();
\r
340 AtomicBoolean propagating = new AtomicBoolean(false);
\r
341 Object propagateList = new Object();
\r
342 Object propagate = new Object();
\r
343 List<Runnable> scheduleList = new ArrayList<Runnable>();
\r
344 final Deque<Integer> activity = new LinkedList<Integer>();
\r
345 int activityInt = 0;
\r
348 * Stores the currently running query update runnable. If
\r
349 * <code>null</code> there's nothing scheduled yet in which case
\r
350 * scheduling can commence. Otherwise the update should be skipped.
\r
352 AtomicReference<Runnable> currentQueryUpdater = new AtomicReference<Runnable>();
\r
355 * Keeps track of nodes that have already been auto-expanded. After
\r
356 * being inserted into this set, nodes will not be forced to stay in an
\r
357 * expanded state after that. This makes it possible for the user to
\r
358 * close auto-expanded nodes.
\r
360 Map<NodeContext, Boolean> autoExpanded = new WeakHashMap<NodeContext, Boolean>();
\r
364 protected void doDispose() {
\r
366 autoExpanded.clear();
\r
370 public IGECache getCache() {
\r
375 public int queryIndent() {
\r
376 return queryIndent;
\r
380 public int queryIndent(int offset) {
\r
381 queryIndent += offset;
\r
382 return queryIndent;
\r
386 @SuppressWarnings("unchecked")
\r
387 public <T> NodeQueryProcessor<T> getProcessor(Object o) {
\r
388 return processors.get(o);
\r
392 @SuppressWarnings("unchecked")
\r
393 public <T> PrimitiveQueryProcessor<T> getPrimitiveProcessor(Object o) {
\r
394 return primitiveProcessors.get(o);
\r
397 @SuppressWarnings("unchecked")
\r
399 public <T> DataSource<T> getDataSource(Class<T> clazz) {
\r
400 return dataSources.get(clazz);
\r
404 public void update(UIElementReference ref) {
\r
405 //System.out.println("GE.update " + ref);
\r
406 TreeItemReference tiref = (TreeItemReference) ref;
\r
407 TreeItem item = tiref.getItem();
\r
408 // NOTE: must be called regardless of the the item value.
\r
409 // A null item is currently used to indicate a tree root update.
\r
410 GraphExplorerImpl.this.update(item);
\r
414 public Object getPropagateLock() {
\r
419 public Object getPropagateListLock() {
\r
420 return propagateList;
\r
424 public boolean isPropagating() {
\r
425 return propagating.get();
\r
429 public void setPropagating(boolean b) {
\r
430 this.propagating.set(b);
\r
434 public List<Runnable> getScheduleList() {
\r
435 return scheduleList;
\r
439 public void setScheduleList(List<Runnable> list) {
\r
440 this.scheduleList = list;
\r
444 public Deque<Integer> getActivity() {
\r
449 public void setActivityInt(int i) {
\r
450 this.activityInt = i;
\r
454 public int getActivityInt() {
\r
455 return activityInt;
\r
459 public void scheduleQueryUpdate(Runnable r) {
\r
460 if (GraphExplorerImpl.this.isDisposed() || queryUpdateScheduler.isShutdown())
\r
462 //System.out.println("Scheduling query update for runnable " + r);
\r
463 if (currentQueryUpdater.compareAndSet(null, r)) {
\r
464 //System.out.println("Scheduling query update for runnable " + r);
\r
465 queryUpdateScheduler.execute(QUERY_UPDATE_SCHEDULER);
\r
469 Runnable QUERY_UPDATE_SCHEDULER = new Runnable() {
\r
471 public void run() {
\r
472 Runnable r = currentQueryUpdater.getAndSet(null);
\r
474 //System.out.println("Running query update runnable " + r);
\r
481 GraphExplorerContext explorerContext = new GraphExplorerContext();
\r
483 HashSet<TreeItem> pendingItems = new HashSet<TreeItem>();
\r
484 boolean updating = false;
\r
485 boolean pendingRoot = false;
\r
487 @SuppressWarnings("deprecation")
\r
488 ModificationContext modificationContext = null;
\r
490 NodeContext rootContext;
\r
492 StatePersistor persistor = null;
\r
494 boolean editable = true;
\r
497 * This is a reverse mapping from {@link NodeContext} tree objects back to
\r
498 * their owner TreeItems.
\r
501 * Access this map only in the SWT thread to keep it thread-safe.
\r
504 BijectionMap<NodeContext, TreeItem> contextToItem = new BijectionMap<NodeContext, TreeItem>();
\r
507 * Columns of the UI viewer. Use {@link #setColumns(Column[])} to
\r
510 Column[] columns = new Column[0];
\r
511 Map<String, Integer> columnKeyToIndex = new HashMap<String, Integer>();
\r
512 boolean refreshingColumnSizes = false;
\r
513 boolean columnsAreVisible = true;
\r
516 * An array reused for invoking {@link TreeItem#setImage(Image[])} instead
\r
517 * of constantly allocating new arrays for setting each TreeItems images.
\r
518 * This works because {@link TreeItem#setImage(Image[])} does not take hold
\r
519 * of the array itself, only the contents of the array.
\r
521 * @see #setImage(NodeContext, TreeItem, Imager, Collection, int)
\r
523 Image[] columnImageArray = { null };
\r
526 * Used for collecting Image or ImageDescriptor instances for a single
\r
527 * TreeItem when initially setting images for a TreeItem.
\r
529 * @see #setImage(NodeContext, TreeItem, Imager, Collection, int)
\r
531 Object[] columnDescOrImageArray = { null };
\r
533 final ExecutorService queryUpdateScheduler = Threads.getExecutor();
\r
534 final ScheduledExecutorService uiUpdateScheduler = ThreadUtils.getNonBlockingWorkExecutor();
\r
536 /** Set to true when the Tree widget is disposed. */
\r
537 private boolean disposed = false;
\r
538 private final CopyOnWriteArrayList<FocusListener> focusListeners = new CopyOnWriteArrayList<FocusListener>();
\r
539 private final CopyOnWriteArrayList<MouseListener> mouseListeners = new CopyOnWriteArrayList<MouseListener>();
\r
540 private final CopyOnWriteArrayList<KeyListener> keyListeners = new CopyOnWriteArrayList<KeyListener>();
\r
542 /** Selection provider */
\r
543 private GraphExplorerPostSelectionProvider postSelectionProvider = new GraphExplorerPostSelectionProvider(this);
\r
544 protected BasePostSelectionProvider selectionProvider = new BasePostSelectionProvider();
\r
545 protected SelectionDataResolver selectionDataResolver;
\r
546 protected SelectionFilter selectionFilter;
\r
547 protected BinaryFunction<Object[], GraphExplorer, Object[]> selectionTransformation = new BinaryFunction<Object[], GraphExplorer, Object[]>() {
\r
550 public Object[] call(GraphExplorer explorer, Object[] objects) {
\r
551 Object[] result = new Object[objects.length];
\r
552 for (int i = 0; i < objects.length; i++) {
\r
553 IHintContext context = new AdaptableHintContext(SelectionHints.KEY_MAIN);
\r
554 context.setHint(SelectionHints.KEY_MAIN, objects[i]);
\r
555 result[i] = context;
\r
561 protected FontDescriptor originalFont;
\r
562 protected ColorDescriptor originalForeground;
\r
563 protected ColorDescriptor originalBackground;
\r
566 * The set of currently selected TreeItem instances. This set is needed
\r
567 * because we need to know in {@link #setData(Event)} whether the updated
\r
568 * item was a part of the current selection in which case the selection must
\r
571 private final Map<TreeItem, NodeContext> selectedItems = new HashMap<TreeItem, NodeContext>();
\r
574 * TODO: specify what this is for
\r
576 private final Set<NodeContext> selectionRefreshContexts = new HashSet<NodeContext>();
\r
579 * If this field is non-null, it means that if {@link #setData(Event)}
\r
580 * encounters a NodeContext equal to this one, it must make the TreeItem
\r
581 * assigned to that NodeContext the topmost item of the tree using
\r
582 * {@link Tree#setTopItem(TreeItem)}. After this the field value is
\r
586 * This is related to {@link #initializeState()}, i.e. explorer state
\r
589 // private NodeContext[] topNodePath = NodeContext.NONE;
\r
590 // private int[] topNodePath = {};
\r
591 // private int currentTopNodePathIndex = -1;
\r
594 * See {@link #setAutoExpandLevel(int)}
\r
596 private int autoExpandLevel = 0;
\r
599 * <code>null</code> if not explicitly set through
\r
600 * {@link #setServiceLocator(IServiceLocator)}.
\r
602 private IServiceLocator serviceLocator;
\r
605 * The global workbench context service, if the workbench is available.
\r
606 * Retrieved in the constructor.
\r
608 private IContextService contextService = null;
\r
611 * The global workbench IFocusService, if the workbench is available.
\r
612 * Retrieved in the constructor.
\r
614 private IFocusService focusService = null;
\r
617 * A Workbench UI context activation that is activated when starting inline
\r
618 * editing through {@link #startEditing(TreeItem, int)}.
\r
620 * @see #activateEditingContext()
\r
621 * @see #deactivateEditingContext()
\r
623 private IContextActivation editingContext = null;
\r
625 static class ImageTask {
\r
628 Object[] descsOrImages;
\r
629 public ImageTask(NodeContext node, TreeItem item, Object[] descsOrImages) {
\r
632 this.descsOrImages = descsOrImages;
\r
637 * The job that is used for off-loading image loading tasks (see
\r
638 * {@link ImageTask} to a worker thread from the main UI thread.
\r
640 * @see #setPendingImages(IProgressMonitor)
\r
642 ImageLoaderJob imageLoaderJob;
\r
645 * The set of currently gathered up image loading tasks for
\r
646 * {@link #imageLoaderJob} to execute.
\r
648 * @see #setPendingImages(IProgressMonitor)
\r
650 Map<TreeItem, ImageTask> imageTasks = new THashMap<TreeItem, ImageTask>();
\r
653 * A state flag indicating whether the vertical scroll bar was visible for
\r
654 * {@link #tree} the last time it was checked. Since there is no listener
\r
655 * that can provide this information, we check it in {@link #setData(Event)}
\r
656 * every time any data for a TreeItem is updated. If the visibility changes,
\r
657 * we will force re-layouting of the tree's parent composite.
\r
659 * @see #setData(Event)
\r
661 private boolean verticalBarVisible = false;
\r
663 static class TransientStateImpl implements TransientExplorerState {
\r
665 private Integer activeColumn = null;
\r
668 public synchronized Integer getActiveColumn() {
\r
669 return activeColumn;
\r
672 public synchronized void setActiveColumn(Integer column) {
\r
673 activeColumn = column;
\r
678 private TransientStateImpl transientState = new TransientStateImpl();
\r
680 boolean scheduleUpdater() {
\r
682 if (tree.isDisposed())
\r
685 if (pendingRoot == true || !pendingItems.isEmpty()) {
\r
686 assert(!tree.isDisposed());
\r
688 int activity = explorerContext.activityInt;
\r
690 if (activity < 100) {
\r
691 // System.out.println("Scheduling update immediately.");
\r
692 } else if (activity < 1000) {
\r
693 // System.out.println("Scheduling update after 500ms.");
\r
696 // System.out.println("Scheduling update after 3000ms.");
\r
702 //System.out.println("Scheduling UI update after " + delay + " ms.");
\r
703 uiUpdateScheduler.schedule(new Runnable() {
\r
705 public void run() {
\r
707 if (tree.isDisposed())
\r
710 if (updateCounter > 0) {
\r
712 uiUpdateScheduler.schedule(this, 50, TimeUnit.MILLISECONDS);
\r
714 tree.getDisplay().asyncExec(new UpdateRunner(GraphExplorerImpl.this, GraphExplorerImpl.this.explorerContext));
\r
718 }, delay, TimeUnit.MILLISECONDS);
\r
727 int updateCounter = 0;
\r
729 void update(TreeItem item) {
\r
731 synchronized(pendingItems) {
\r
733 // System.out.println("update " + item);
\r
737 if(item == null) pendingRoot = true;
\r
738 else pendingItems.add(item);
\r
740 if(updating == true) return;
\r
748 private int maxChildren = DEFAULT_MAX_CHILDREN;
\r
751 public int getMaxChildren() {
\r
752 return maxChildren;
\r
756 public int getMaxChildren(NodeQueryManager manager, NodeContext context) {
\r
757 Integer result = manager.query(context, BuiltinKeys.SHOW_MAX_CHILDREN);
\r
758 //System.out.println("getMaxChildren(" + manager + ", " + context + "): " + result);
\r
759 if (result != null) {
\r
761 throw new AssertionError("BuiltinKeys.SHOW_MAX_CHILDREN query must never return < 0, got " + result);
\r
764 return maxChildren;
\r
768 public void setMaxChildren(int maxChildren) {
\r
769 this.maxChildren = maxChildren;
\r
773 public void setModificationContext(@SuppressWarnings("deprecation") ModificationContext modificationContext) {
\r
774 this.modificationContext = modificationContext;
\r
778 * @param parent the parent SWT composite
\r
780 public GraphExplorerImpl(Composite parent) {
\r
781 this(parent, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
\r
785 * Stores the node context and the modifier that is currently being
\r
786 * modified. These are used internally to prevent duplicate edits from being
\r
787 * initiated which should always be a sensible thing to do.
\r
789 private Set<NodeContext> currentlyModifiedNodes = new THashSet<NodeContext>();
\r
791 private final TreeEditor editor;
\r
792 private Color invalidModificationColor = null;
\r
795 * @param item the TreeItem to start editing
\r
796 * @param columnIndex the index of the column to edit, starts counting from
\r
798 * @return <code>true</code> if the editing was initiated successfully or
\r
799 * <code>false</code> if editing could not be started due to lack of
\r
800 * {@link Modifier} for the labeler in question.
\r
802 private String startEditing(final TreeItem item, final int columnIndex, String columnKey) {
\r
804 return "Rename not supported for selection";
\r
806 GENodeQueryManager manager = new GENodeQueryManager(this.explorerContext, null, null, TreeItemReference.create(item.getParentItem()));
\r
807 final NodeContext context = (NodeContext) item.getData();
\r
808 Labeler labeler = manager.query(context, BuiltinKeys.SELECTED_LABELER);
\r
809 if (labeler == null)
\r
810 return "Rename not supported for selection";
\r
812 if(columnKey == null) columnKey = columns[columnIndex].getKey();
\r
814 // columnKey might be prefixed with '#' to indicate
\r
815 // textual editing is preferred. Try to get modifier
\r
816 // for that first and only if it fails, try without
\r
818 Modifier modifier = labeler.getModifier(modificationContext, columnKey);
\r
819 if (modifier == null) {
\r
820 if(columnKey.startsWith("#"))
\r
821 modifier = labeler.getModifier(modificationContext, columnKey.substring(1));
\r
822 if (modifier == null)
\r
823 return "Rename not supported for selection";
\r
825 if (modifier instanceof DeniedModifier) {
\r
826 DeniedModifier dm = (DeniedModifier)modifier;
\r
827 return dm.getMessage();
\r
830 // Prevent editing of a single node context multiple times.
\r
831 if (currentlyModifiedNodes.contains(context)) {
\r
832 //System.out.println("discarding duplicate edit for context " + context);
\r
833 return "Rename not supported for selection";
\r
836 // Clean up any previous editor control
\r
837 Control oldEditor = editor.getEditor();
\r
838 if (oldEditor != null)
\r
839 oldEditor.dispose();
\r
841 if (modifier instanceof DialogModifier) {
\r
842 performDialogEditing(item, columnIndex, context, (DialogModifier) modifier);
\r
843 } else if (modifier instanceof CustomModifier) {
\r
844 startCustomEditing(item, columnIndex, context, (CustomModifier) modifier);
\r
845 } else if (modifier instanceof EnumerationModifier) {
\r
846 startEnumerationEditing(item, columnIndex, context, (EnumerationModifier) modifier);
\r
848 startTextEditing(item, columnIndex, context, modifier);
\r
856 * @param columnIndex
\r
860 void performDialogEditing(final TreeItem item, final int columnIndex, final NodeContext context,
\r
861 final DialogModifier modifier) {
\r
862 final AtomicBoolean disposed = new AtomicBoolean(false);
\r
863 Consumer<String> callback = result -> {
\r
864 if (disposed.get())
\r
866 String error = modifier.isValid(result);
\r
867 if (error == null) {
\r
868 modifier.modify(result);
\r
869 // Item may be disposed if the tree gets reset after a previous editing.
\r
870 if (!item.isDisposed()) {
\r
871 item.setText(columnIndex, result);
\r
872 queueSelectionRefresh(context);
\r
877 currentlyModifiedNodes.add(context);
\r
879 String status = modifier.query(tree, item, columnIndex, context, callback);
\r
880 if (status != null)
\r
881 ErrorLogger.defaultLog( new Status(IStatus.INFO, Activator.PLUGIN_ID, status) );
\r
883 currentlyModifiedNodes.remove(context);
\r
884 disposed.set(true);
\r
888 private void reconfigureTreeEditor(TreeItem item, int columnIndex, Control control, int widthHint, int heightHint, int insetX, int insetY) {
\r
889 Point size = control.computeSize(widthHint, heightHint);
\r
890 editor.horizontalAlignment = SWT.LEFT;
\r
891 Rectangle itemRect = item.getBounds(columnIndex),
\r
892 rect = tree.getClientArea();
\r
893 editor.minimumWidth = Math.max(size.x, itemRect.width) + insetX * 2;
\r
894 int left = itemRect.x,
\r
895 right = rect.x + rect.width;
\r
896 editor.minimumWidth = Math.min(editor.minimumWidth, right - left);
\r
897 editor.minimumHeight = size.y + insetY * 2;
\r
901 void reconfigureTreeEditorForText(TreeItem item, int columnIndex, Control control, String text, int heightHint, int insetX, int insetY) {
\r
902 GC gc = new GC(control);
\r
903 Point size = gc.textExtent(text);
\r
905 reconfigureTreeEditor(item, columnIndex, control, size.x, SWT.DEFAULT, insetX, insetY);
\r
910 * @param columnIndex
\r
914 void startCustomEditing(final TreeItem item, final int columnIndex, final NodeContext context,
\r
915 final CustomModifier modifier) {
\r
916 final Object obj = modifier.createControl(tree, item, columnIndex, context);
\r
917 if (!(obj instanceof Control))
\r
918 throw new UnsupportedOperationException("SWT control required, got " + obj + " from CustomModifier.createControl(Object)");
\r
919 final Control control = (Control) obj;
\r
921 // final int insetX = 0;
\r
922 // final int insetY = 0;
\r
923 // control.addListener(SWT.Resize, new Listener() {
\r
925 // public void handleEvent(Event e) {
\r
926 // Rectangle rect = control.getBounds();
\r
927 // control.setBounds(rect.x + insetX, rect.y + insetY, rect.width - insetX * 2, rect.height - insetY * 2);
\r
930 control.addListener(SWT.Dispose, new Listener() {
\r
932 public void handleEvent(Event event) {
\r
933 currentlyModifiedNodes.remove(context);
\r
934 queueSelectionRefresh(context);
\r
935 deactivateEditingContext();
\r
939 if (!(control instanceof Shell)) {
\r
940 editor.setEditor(control, item, columnIndex);
\r
944 control.setFocus();
\r
946 GraphExplorerImpl.this.reconfigureTreeEditor(item, columnIndex, control, SWT.DEFAULT, SWT.DEFAULT, 0, 0);
\r
948 activateEditingContext(control);
\r
950 // Removed in disposeListener above
\r
951 currentlyModifiedNodes.add(context);
\r
952 //System.out.println("START CUSTOM EDITING: " + item);
\r
957 * @param columnIndex
\r
961 void startEnumerationEditing(final TreeItem item, final int columnIndex, final NodeContext context, final EnumerationModifier modifier) {
\r
962 String initialText = modifier.getValue();
\r
963 if (initialText == null)
\r
964 throw new AssertionError("Labeler.Modifier.getValue() returned null");
\r
966 List<String> values = modifier.getValues();
\r
967 String selectedValue = modifier.getValue();
\r
968 int selectedIndex = values.indexOf(selectedValue);
\r
969 if (selectedIndex == -1)
\r
970 throw new AssertionFailedException(modifier + " EnumerationModifier.getValue returned '" + selectedValue + "' which is not among the possible values returned by EnumerationModifier.getValues(): " + values);
\r
972 final CCombo combo = new CCombo(tree, SWT.FLAT | SWT.BORDER | SWT.READ_ONLY | SWT.DROP_DOWN);
\r
973 combo.setVisibleItemCount(10);
\r
974 //combo.setEditable(false);
\r
976 for (String value : values) {
\r
979 combo.select(selectedIndex);
\r
981 Listener comboListener = new Listener() {
\r
982 boolean arrowTraverseUsed = false;
\r
984 public void handleEvent(final Event e) {
\r
985 //System.out.println("FOO: " + e);
\r
988 if (e.character == SWT.CR) {
\r
989 // Commit edit directly on ENTER press.
\r
990 String text = combo.getText();
\r
991 modifier.modify(text);
\r
992 // Item may be disposed if the tree gets reset after a previous editing.
\r
993 if (!item.isDisposed()) {
\r
994 item.setText(columnIndex, text);
\r
995 queueSelectionRefresh(context);
\r
999 } else if (e.keyCode == SWT.ESC) {
\r
1000 // Cancel editing immediately
\r
1005 case SWT.Selection:
\r
1007 if (arrowTraverseUsed) {
\r
1008 arrowTraverseUsed = false;
\r
1012 String text = combo.getText();
\r
1013 modifier.modify(text);
\r
1015 // Item may be disposed if the tree gets reset after a previous editing.
\r
1016 if (!item.isDisposed()) {
\r
1017 item.setText(columnIndex, text);
\r
1018 queueSelectionRefresh(context);
\r
1023 case SWT.FocusOut: {
\r
1024 String text = combo.getText();
\r
1025 modifier.modify(text);
\r
1027 // Item may be disposed if the tree gets reset after a previous editing.
\r
1028 if (!item.isDisposed()) {
\r
1029 item.setText(columnIndex, text);
\r
1030 queueSelectionRefresh(context);
\r
1035 case SWT.Traverse: {
\r
1036 switch (e.detail) {
\r
1037 case SWT.TRAVERSE_RETURN:
\r
1038 String text = combo.getText();
\r
1039 modifier.modify(text);
\r
1040 if (!item.isDisposed()) {
\r
1041 item.setText(columnIndex, text);
\r
1042 queueSelectionRefresh(context);
\r
1044 arrowTraverseUsed = false;
\r
1046 case SWT.TRAVERSE_ESCAPE:
\r
1050 case SWT.TRAVERSE_ARROW_NEXT:
\r
1051 case SWT.TRAVERSE_ARROW_PREVIOUS:
\r
1052 arrowTraverseUsed = true;
\r
1055 //System.out.println("unhandled traversal: " + e.detail);
\r
1061 currentlyModifiedNodes.remove(context);
\r
1062 deactivateEditingContext();
\r
1067 combo.addListener(SWT.MouseWheel, VetoingEventHandler.INSTANCE);
\r
1068 combo.addListener(SWT.KeyDown, comboListener);
\r
1069 combo.addListener(SWT.FocusOut, comboListener);
\r
1070 combo.addListener(SWT.Traverse, comboListener);
\r
1071 combo.addListener(SWT.Selection, comboListener);
\r
1072 combo.addListener(SWT.Dispose, comboListener);
\r
1074 editor.setEditor(combo, item, columnIndex);
\r
1077 combo.setListVisible(true);
\r
1079 GraphExplorerImpl.this.reconfigureTreeEditorForText(item, columnIndex, combo, combo.getText(), SWT.DEFAULT, 0, 0);
\r
1081 activateEditingContext(combo);
\r
1083 // Removed in comboListener
\r
1084 currentlyModifiedNodes.add(context);
\r
1086 //System.out.println("START ENUMERATION EDITING: " + item);
\r
1091 * @param columnIndex
\r
1095 void startTextEditing(final TreeItem item, final int columnIndex, final NodeContext context, final Modifier modifier) {
\r
1096 String initialText = modifier.getValue();
\r
1097 if (initialText == null)
\r
1098 throw new AssertionError("Labeler.Modifier.getValue() returned null, modifier=" + modifier);
\r
1100 final Composite composite = new Composite(tree, SWT.NONE);
\r
1101 //composite.setBackground(composite.getDisplay().getSystemColor(SWT.COLOR_RED));
\r
1102 final Text text = new Text(composite, SWT.BORDER);
\r
1103 final int insetX = 0;
\r
1104 final int insetY = 0;
\r
1105 composite.addListener(SWT.Resize, new Listener() {
\r
1107 public void handleEvent(Event e) {
\r
1108 Rectangle rect = composite.getClientArea();
\r
1109 text.setBounds(rect.x + insetX, rect.y + insetY, rect.width - insetX * 2, rect.height
\r
1113 final FilteringModifier filter = modifier instanceof FilteringModifier ? (FilteringModifier) modifier : null;
\r
1114 Listener textListener = new Listener() {
\r
1116 boolean modified = false;
\r
1119 public void handleEvent(final Event e) {
\r
1123 case SWT.FocusOut:
\r
1125 //System.out.println("FOCUS OUT " + item);
\r
1126 newText = text.getText();
\r
1127 error = modifier.isValid(newText);
\r
1128 if (error == null) {
\r
1129 modifier.modify(newText);
\r
1131 // Item may be disposed if the tree gets reset after a previous editing.
\r
1132 if (!item.isDisposed()) {
\r
1133 item.setText(columnIndex, newText);
\r
1134 queueSelectionRefresh(context);
\r
1137 // System.out.println("validation error: " + error);
\r
1140 composite.dispose();
\r
1143 newText = text.getText();
\r
1144 error = modifier.isValid(newText);
\r
1145 if (error != null) {
\r
1146 text.setBackground(invalidModificationColor);
\r
1147 errorStatus(error);
\r
1148 //System.out.println("validation error: " + error);
\r
1150 text.setBackground(null);
\r
1151 errorStatus(null);
\r
1157 // Safety check since it seems that this may happen with
\r
1159 if (item.isDisposed())
\r
1162 // Filter input if necessary
\r
1163 e.text = filter != null ? filter.filter(e.text) : e.text;
\r
1165 newText = text.getText();
\r
1166 String leftText = newText.substring(0, e.start);
\r
1167 String rightText = newText.substring(e.end, newText.length());
\r
1168 GraphExplorerImpl.this.reconfigureTreeEditorForText(
\r
1169 item, columnIndex, text, leftText + e.text + rightText,
\r
1170 SWT.DEFAULT, insetX, insetY);
\r
1172 case SWT.Traverse:
\r
1173 switch (e.detail) {
\r
1174 case SWT.TRAVERSE_RETURN:
\r
1176 newText = text.getText();
\r
1177 error = modifier.isValid(newText);
\r
1178 if (error == null) {
\r
1179 modifier.modify(newText);
\r
1180 if (!item.isDisposed()) {
\r
1181 item.setText(columnIndex, newText);
\r
1182 queueSelectionRefresh(context);
\r
1187 case SWT.TRAVERSE_ESCAPE:
\r
1188 composite.dispose();
\r
1192 //System.out.println("unhandled traversal: " + e.detail);
\r
1198 currentlyModifiedNodes.remove(context);
\r
1199 deactivateEditingContext();
\r
1200 errorStatus(null);
\r
1205 // Set the initial text before registering a listener. We do not want immediate modification!
\r
1206 text.setText(initialText);
\r
1207 text.addListener(SWT.FocusOut, textListener);
\r
1208 text.addListener(SWT.Traverse, textListener);
\r
1209 text.addListener(SWT.Verify, textListener);
\r
1210 text.addListener(SWT.Modify, textListener);
\r
1211 text.addListener(SWT.Dispose, textListener);
\r
1212 editor.setEditor(composite, item, columnIndex);
\r
1216 // Initialize TreeEditor properly.
\r
1217 GraphExplorerImpl.this.reconfigureTreeEditorForText(
\r
1218 item, columnIndex, text, initialText,
\r
1219 SWT.DEFAULT, insetX, insetY);
\r
1221 // Removed in textListener
\r
1222 currentlyModifiedNodes.add(context);
\r
1224 activateEditingContext(text);
\r
1226 //System.out.println("START TEXT EDITING: " + item);
\r
1229 protected void errorStatus(String error) {
\r
1230 IStatusLineManager status = getStatusLineManager();
\r
1231 if (status != null) {
\r
1232 status.setErrorMessage(error);
\r
1236 protected IStatusLineManager getStatusLineManager() {
\r
1237 if (serviceLocator instanceof IWorkbenchPart) {
\r
1238 return WorkbenchUtils.getStatusLine((IWorkbenchPart) serviceLocator);
\r
1239 } else if (serviceLocator instanceof IWorkbenchSite) {
\r
1240 return WorkbenchUtils.getStatusLine((IWorkbenchSite) serviceLocator);
\r
1245 protected void activateEditingContext(Control control) {
\r
1246 if (contextService != null) {
\r
1247 editingContext = contextService.activateContext(INLINE_EDITING_UI_CONTEXT);
\r
1249 if (control != null && focusService != null) {
\r
1250 focusService.addFocusTracker(control, INLINE_EDITING_UI_CONTEXT);
\r
1251 // No need to remove the control, it will be
\r
1252 // removed automatically when it is disposed.
\r
1256 protected void deactivateEditingContext() {
\r
1257 IContextActivation a = editingContext;
\r
1259 editingContext = null;
\r
1260 contextService.deactivateContext(a);
\r
1265 * @param forContext
\r
1267 void queueSelectionRefresh(NodeContext forContext) {
\r
1268 selectionRefreshContexts.add(forContext);
\r
1272 public String startEditing(NodeContext context, String columnKey_) {
\r
1273 assertNotDisposed();
\r
1274 if (!thread.currentThreadAccess())
\r
1275 throw new IllegalStateException("not in SWT display thread " + thread.getThread());
\r
1277 String columnKey = columnKey_;
\r
1278 if(columnKey.startsWith("#")) {
\r
1279 columnKey = columnKey.substring(1);
\r
1282 Integer columnIndex = columnKeyToIndex.get(columnKey);
\r
1283 if (columnIndex == null)
\r
1284 return "Rename not supported for selection";
\r
1286 TreeItem item = contextToItem.getRight(context);
\r
1288 return "Rename not supported for selection";
\r
1290 return startEditing(item, columnIndex, columnKey_);
\r
1295 public String startEditing(String columnKey) {
\r
1297 ISelection selection = postSelectionProvider.getSelection();
\r
1298 if(selection == null) return "Rename not supported for selection";
\r
1299 NodeContext context = ISelectionUtils.filterSingleSelection(selection, NodeContext.class);
\r
1300 if(context == null) return "Rename not supported for selection";
\r
1302 return startEditing(context, columnKey);
\r
1307 * @param site <code>null</code> if the explorer is detached from the workbench
\r
1308 * @param parent the parent SWT composite
\r
1309 * @param style the tree style to use, check the see tags for the available flags
\r
1314 * @see SWT#FULL_SELECTION
\r
1315 * @see SWT#NO_SCROLL
\r
1316 * @see SWT#H_SCROLL
\r
1317 * @see SWT#V_SCROLL
\r
1319 public GraphExplorerImpl(Composite parent, int style) {
\r
1321 setServiceLocator(null);
\r
1323 this.localResourceManager = new LocalResourceManager(JFaceResources.getResources());
\r
1324 this.resourceManager = new DeviceResourceManager(parent.getDisplay());
\r
1326 this.imageLoaderJob = new ImageLoaderJob(this);
\r
1327 this.imageLoaderJob.setPriority(Job.DECORATE);
\r
1329 invalidModificationColor = (Color) localResourceManager.get( ColorDescriptor.createFrom( new RGB(255, 128, 128) ) );
\r
1331 this.thread = SWTThread.getThreadAccess(parent);
\r
1333 for(int i=0;i<10;i++) explorerContext.activity.push(0);
\r
1335 tree = new Tree(parent, style);
\r
1336 tree.addListener(SWT.SetData, this);
\r
1337 tree.addListener(SWT.Expand, this);
\r
1338 tree.addListener(SWT.Dispose, this);
\r
1339 tree.addListener(SWT.Activate, this);
\r
1341 tree.setData(KEY_GRAPH_EXPLORER, this);
\r
1343 // These are both required for performing column resizing without flicker.
\r
1344 // See SWT.Resize event handling in #handleEvent() for more explanations.
\r
1345 parent.addListener(SWT.Resize, this);
\r
1346 tree.addListener(SWT.Resize, this);
\r
1348 originalFont = JFaceResources.getDefaultFontDescriptor();
\r
1349 // originalBackground = JFaceResources.getColorRegistry().get(symbolicName);
\r
1350 // originalForeground = tree.getForeground();
\r
1352 tree.setFont((Font) localResourceManager.get(originalFont));
\r
1354 columns = new Column[] { new Column(ColumnKeys.SINGLE) };
\r
1355 columnKeyToIndex = Collections.singletonMap(ColumnKeys.SINGLE, 0);
\r
1357 editor = new TreeEditor(tree);
\r
1358 editor.horizontalAlignment = SWT.LEFT;
\r
1359 editor.grabHorizontal = true;
\r
1360 editor.minimumWidth = 50;
\r
1362 setBasicListeners();
\r
1363 setDefaultProcessors();
\r
1365 this.toolTip = new GraphExplorerToolTip(explorerContext, tree);
\r
1369 public IThreadWorkQueue getThread() {
\r
1373 TreeItem previousSingleSelection = null;
\r
1374 long focusGainedAt = Long.MIN_VALUE;
\r
1376 protected GraphExplorerToolTip toolTip;
\r
1378 protected void setBasicListeners() {
\r
1379 // Keep track of the previous single selection to help
\r
1380 // decide whether to start editing a tree node on mouse
\r
1382 tree.addListener(SWT.Selection, new Listener() {
\r
1384 public void handleEvent(Event event) {
\r
1385 TreeItem[] selection = tree.getSelection();
\r
1386 if (selection.length == 1) {
\r
1387 //for (TreeItem item : selection)
\r
1388 // System.out.println("selection: " + item);
\r
1389 previousSingleSelection = selection[0];
\r
1391 previousSingleSelection = null;
\r
1396 // Try to start editing of tree column when clicked for the second time.
\r
1397 Listener mouseEditListener = new Listener() {
\r
1399 Future<?> startEdit = null;
\r
1402 public void handleEvent(Event event) {
\r
1403 if (event.type == SWT.DragDetect) {
\r
1404 // Needed to prevent editing from being started when in fact
\r
1405 // the user starts dragging an item.
\r
1406 //System.out.println("DRAG DETECT: " + event);
\r
1410 //System.out.println("mouse down: " + event);
\r
1411 if (event.button == 1) {
\r
1412 // Always ignore the first mouse button press that focuses
\r
1413 // the control. Do not let it start in-line editing since
\r
1414 // that is very annoying to users and not how the UI's that
\r
1415 // people are used to behave.
\r
1416 long eventTime = ((long) event.time) & 0xFFFFFFFFL;
\r
1417 if ((eventTime - focusGainedAt) < 250L) {
\r
1418 //System.out.println("ignore mouse down " + focusGainedAt + ", " + eventTime + " = " + (eventTime-focusGainedAt));
\r
1421 //System.out.println("testing whether to start editing");
\r
1423 final Point point = new Point(event.x, event.y);
\r
1424 final TreeItem item = tree.getItem(point);
\r
1427 //System.out.println("mouse down @ " + point + ": " + item + ", previous item: " + previousSingleSelection);
\r
1429 // Only start editing if the item was already selected.
\r
1430 if (!item.equals(previousSingleSelection)) {
\r
1435 if (tree.getColumnCount() > 1) {
\r
1436 // TODO: reconsider this logic, might not be good in general.
\r
1437 for (int i = 0; i < tree.getColumnCount(); i++) {
\r
1438 if (item.getBounds(i).contains(point)) {
\r
1439 tryScheduleEdit(event, item, point, 100, i);
\r
1444 //System.out.println("clicks: " + event.count);
\r
1445 if (item.getBounds().contains(point)) {
\r
1446 if (event.count == 1) {
\r
1447 tryScheduleEdit(event, item, point, 500, 0);
\r
1456 void tryScheduleEdit(Event event, final TreeItem item, Point point, long delayMs, final int column) {
\r
1457 //System.out.println("\tCONTAINS: " + item);
\r
1458 if (!cancelEdit())
\r
1461 //System.out.println("\tScheduling edit: " + item);
\r
1462 startEdit = ThreadUtils.getNonBlockingWorkExecutor().schedule(new Runnable() {
\r
1464 public void run() {
\r
1465 ThreadUtils.asyncExec(thread, new Runnable() {
\r
1467 public void run() {
\r
1468 if (item.isDisposed())
\r
1470 startEditing(item, column, null);
\r
1474 }, delayMs, TimeUnit.MILLISECONDS);
\r
1477 boolean cancelEdit() {
\r
1478 Future<?> f = startEdit;
\r
1480 // Try to cancel the start edit task if it's not running yet.
\r
1482 if (!f.isDone()) {
\r
1483 boolean ret = f.cancel(false);
\r
1484 //System.out.println("\tCancelled edit: " + ret);
\r
1488 //System.out.println("\tNo edit in progress to cancel");
\r
1492 tree.addListener(SWT.MouseDown, mouseEditListener);
\r
1493 tree.addListener(SWT.DragDetect, mouseEditListener);
\r
1494 tree.addListener(SWT.DragDetect, new Listener() {
\r
1496 public void handleEvent(Event event) {
\r
1497 Point test = new Point(event.x, event.y);
\r
1498 TreeItem item = tree.getItem(test);
\r
1499 if(item != null) {
\r
1500 for(int i=0;i<tree.getColumnCount();i++) {
\r
1501 Rectangle rect = item.getBounds(i);
\r
1502 if(rect.contains(test)) {
\r
1503 tree.setData(KEY_DRAG_COLUMN, i);
\r
1508 tree.setData(KEY_DRAG_COLUMN, -1);
\r
1511 tree.addListener(SWT.MouseMove, new Listener() {
\r
1513 public void handleEvent(Event event) {
\r
1514 Point test = new Point(event.x, event.y);
\r
1515 TreeItem item = tree.getItem(test);
\r
1516 if(item != null) {
\r
1517 for(int i=0;i<tree.getColumnCount();i++) {
\r
1518 Rectangle rect = item.getBounds(i);
\r
1519 if(rect.contains(test)) {
\r
1520 transientState.setActiveColumn(i);
\r
1525 transientState.setActiveColumn(null);
\r
1529 // Add focus/mouse/key listeners for supporting the respective
\r
1530 // add/remove listener methods in IGraphExplorer.
\r
1531 tree.addFocusListener(new FocusListener() {
\r
1533 public void focusGained(FocusEvent e) {
\r
1534 focusGainedAt = ((long) e.time) & 0xFFFFFFFFL;
\r
1535 for (FocusListener listener : focusListeners)
\r
1536 listener.focusGained(e);
\r
1539 public void focusLost(FocusEvent e) {
\r
1540 for (FocusListener listener : focusListeners)
\r
1541 listener.focusLost(e);
\r
1544 tree.addMouseListener(new MouseListener() {
\r
1546 public void mouseDoubleClick(MouseEvent e) {
\r
1547 for (MouseListener listener : mouseListeners) {
\r
1548 listener.mouseDoubleClick(e);
\r
1552 public void mouseDown(MouseEvent e) {
\r
1553 for (MouseListener listener : mouseListeners) {
\r
1554 listener.mouseDown(e);
\r
1558 public void mouseUp(MouseEvent e) {
\r
1559 for (MouseListener listener : mouseListeners) {
\r
1560 listener.mouseUp(e);
\r
1564 tree.addKeyListener(new KeyListener() {
\r
1566 public void keyPressed(KeyEvent e) {
\r
1567 for (KeyListener listener : keyListeners) {
\r
1568 listener.keyPressed(e);
\r
1572 public void keyReleased(KeyEvent e) {
\r
1573 for (KeyListener listener : keyListeners) {
\r
1574 listener.keyReleased(e);
\r
1579 // Add a tree selection listener for keeping the selection of
\r
1580 // GraphExplorer's ISelectionProvider up-to-date.
\r
1581 tree.addSelectionListener(new SelectionListener() {
\r
1583 public void widgetDefaultSelected(SelectionEvent e) {
\r
1584 widgetSelected(e);
\r
1587 public void widgetSelected(SelectionEvent e) {
\r
1588 widgetSelectionChanged(false);
\r
1592 // This listener takes care of updating the set of currently selected
\r
1593 // TreeItem instances. This set is needed because we need to know in
\r
1594 // #setData(Event) whether the updated item was a part of the current
\r
1595 // selection in which case the selection must be updated.
\r
1596 selectionProvider.addSelectionChangedListener(new ISelectionChangedListener() {
\r
1598 public void selectionChanged(SelectionChangedEvent event) {
\r
1599 //System.out.println("selection changed: " + event.getSelection());
\r
1600 Set<NodeContext> set = ISelectionUtils.filterSetSelection(event.getSelection(), NodeContext.class);
\r
1601 selectedItems.clear();
\r
1602 for (NodeContext nc : set) {
\r
1603 TreeItem item = contextToItem.getRight(nc);
\r
1605 selectedItems.put(item, nc);
\r
1607 //System.out.println("newly selected items: " + selectedItems);
\r
1613 * Mod count for delaying post selection changed events.
\r
1615 int postSelectionModCount = 0;
\r
1618 * Last tree selection modification time for implementing a quiet
\r
1619 * time for selection changes.
\r
1621 long lastSelectionModTime = System.currentTimeMillis() - 10000;
\r
1624 * Current target time for the selection to be set. Calculated
\r
1625 * according to the set quiet time and last selection modification
\r
1628 long selectionSetTargetTime = 0;
\r
1631 * <code>true</code> if delayed selection runnable is current scheduled or
\r
1634 boolean delayedSelectionScheduled = false;
\r
1636 Runnable SELECTION_DELAY = new Runnable() {
\r
1638 public void run() {
\r
1639 if (tree.isDisposed())
\r
1641 long now = System.currentTimeMillis();
\r
1642 long waitTimeLeft = selectionSetTargetTime - now;
\r
1643 if (waitTimeLeft > 0) {
\r
1644 // Not enough quiet time, reschedule.
\r
1645 delayedSelectionScheduled = true;
\r
1646 tree.getDisplay().timerExec((int) waitTimeLeft, this);
\r
1648 // Time to perform selection, stop rescheduling.
\r
1649 delayedSelectionScheduled = false;
\r
1655 private void widgetSelectionChanged(boolean forceSelectionChange) {
\r
1656 long modTime = System.currentTimeMillis();
\r
1657 long delta = modTime - lastSelectionModTime;
\r
1658 lastSelectionModTime = modTime;
\r
1659 if (!forceSelectionChange && delta < SELECTION_CHANGE_QUIET_TIME) {
\r
1660 long msToWait = SELECTION_CHANGE_QUIET_TIME - delta;
\r
1661 selectionSetTargetTime = modTime + msToWait;
\r
1662 if (!delayedSelectionScheduled) {
\r
1663 delayedSelectionScheduled = true;
\r
1664 tree.getDisplay().timerExec((int) msToWait, SELECTION_DELAY);
\r
1666 // Make sure that post selection change events do not fire.
\r
1667 ++postSelectionModCount;
\r
1671 // Immediate selection reconstruction.
\r
1675 private void resetSelection() {
\r
1676 final ISelection selection = getWidgetSelection();
\r
1678 //System.out.println("resetSelection(" + postSelectionModCount + ")");
\r
1679 //System.out.println(" provider selection: " + selectionProvider.getSelection());
\r
1680 //System.out.println(" widget selection: " + selection);
\r
1682 selectionProvider.setAndFireNonEqualSelection(selection);
\r
1684 // Implement deferred firing of post selection events
\r
1685 final int count = ++postSelectionModCount;
\r
1686 //System.out.println("[" + System.currentTimeMillis() + "] scheduling postSelectionChanged " + count + ": " + selection);
\r
1687 ThreadUtils.getNonBlockingWorkExecutor().schedule(new Runnable() {
\r
1689 public void run() {
\r
1690 int newCount = postSelectionModCount;
\r
1691 // Don't publish selection yet, there's another change incoming.
\r
1692 //System.out.println("[" + System.currentTimeMillis() + "] checking post selection publish: " + count + " vs. " + newCount + ": " + selection);
\r
1693 if (newCount != count)
\r
1695 //System.out.println("[" + System.currentTimeMillis() + "] " + count + " count equals, firing post selection listeners: " + selection);
\r
1697 if (tree.isDisposed())
\r
1700 //System.out.println("scheduling fire post selection changed: " + selection);
\r
1701 tree.getDisplay().asyncExec(new Runnable() {
\r
1703 public void run() {
\r
1704 if (tree.isDisposed() || selectionProvider == null)
\r
1706 //System.out.println("firing post selection changed: " + selection);
\r
1707 selectionProvider.firePostSelection(selection);
\r
1711 }, POST_SELECTION_DELAY, TimeUnit.MILLISECONDS);
\r
1714 protected void setDefaultProcessors() {
\r
1715 // Add a simple IMAGER query processor that always returns null.
\r
1716 // With this processor no images will ever be shown.
\r
1717 // setPrimitiveProcessor(new StaticImagerProcessor(null));
\r
1719 setProcessor(new DefaultComparableChildrenProcessor());
\r
1720 setProcessor(new DefaultLabelDecoratorsProcessor());
\r
1721 setProcessor(new DefaultImageDecoratorsProcessor());
\r
1722 setProcessor(new DefaultSelectedLabelerProcessor());
\r
1723 setProcessor(new DefaultLabelerFactoriesProcessor());
\r
1724 setProcessor(new DefaultSelectedImagerProcessor());
\r
1725 setProcessor(new DefaultImagerFactoriesProcessor());
\r
1726 setPrimitiveProcessor(new DefaultLabelerProcessor());
\r
1727 setPrimitiveProcessor(new DefaultCheckedStateProcessor());
\r
1728 setPrimitiveProcessor(new DefaultImagerProcessor());
\r
1729 setPrimitiveProcessor(new DefaultLabelDecoratorProcessor());
\r
1730 setPrimitiveProcessor(new DefaultImageDecoratorProcessor());
\r
1731 setPrimitiveProcessor(new NoSelectionRequestProcessor());
\r
1733 setProcessor(new DefaultFinalChildrenProcessor(this));
\r
1735 setProcessor(new DefaultPrunedChildrenProcessor());
\r
1736 setProcessor(new DefaultSelectedViewpointProcessor());
\r
1737 setProcessor(new DefaultSelectedLabelDecoratorFactoriesProcessor());
\r
1738 setProcessor(new DefaultSelectedImageDecoratorFactoriesProcessor());
\r
1739 setProcessor(new DefaultViewpointContributionsProcessor());
\r
1741 setPrimitiveProcessor(new DefaultViewpointProcessor());
\r
1742 setPrimitiveProcessor(new DefaultViewpointContributionProcessor());
\r
1743 setPrimitiveProcessor(new DefaultSelectedViewpointFactoryProcessor());
\r
1744 setPrimitiveProcessor(new DefaultIsExpandedProcessor());
\r
1745 setPrimitiveProcessor(new DefaultShowMaxChildrenProcessor());
\r
1749 public <T> void setProcessor(NodeQueryProcessor<T> processor) {
\r
1750 assertNotDisposed();
\r
1751 if (processor == null)
\r
1752 throw new IllegalArgumentException("null processor");
\r
1754 processors.put(processor.getIdentifier(), processor);
\r
1758 public <T> void setPrimitiveProcessor(PrimitiveQueryProcessor<T> processor) {
\r
1759 assertNotDisposed();
\r
1760 if (processor == null)
\r
1761 throw new IllegalArgumentException("null processor");
\r
1763 PrimitiveQueryProcessor<?> oldProcessor = primitiveProcessors.put(processor.getIdentifier(), processor);
\r
1765 if (oldProcessor instanceof ProcessorLifecycle)
\r
1766 ((ProcessorLifecycle) oldProcessor).detached(this);
\r
1767 if (processor instanceof ProcessorLifecycle)
\r
1768 ((ProcessorLifecycle) processor).attached(this);
\r
1772 public <T> void setDataSource(DataSource<T> provider) {
\r
1773 assertNotDisposed();
\r
1774 if (provider == null)
\r
1775 throw new IllegalArgumentException("null provider");
\r
1776 dataSources.put(provider.getProvidedClass(), provider);
\r
1779 @SuppressWarnings("unchecked")
\r
1781 public <T> DataSource<T> removeDataSource(Class<T> forProvidedClass) {
\r
1782 assertNotDisposed();
\r
1783 if (forProvidedClass == null)
\r
1784 throw new IllegalArgumentException("null class");
\r
1785 return dataSources.remove(forProvidedClass);
\r
1789 public void setPersistor(StatePersistor persistor) {
\r
1790 this.persistor = persistor;
\r
1794 public SelectionDataResolver getSelectionDataResolver() {
\r
1795 return selectionDataResolver;
\r
1799 public void setSelectionDataResolver(SelectionDataResolver r) {
\r
1800 this.selectionDataResolver = r;
\r
1804 public SelectionFilter getSelectionFilter() {
\r
1805 return selectionFilter;
\r
1809 public void setSelectionFilter(SelectionFilter f) {
\r
1810 this.selectionFilter = f;
\r
1811 // TODO: re-filter current selection?
\r
1815 public void setSelectionTransformation(BinaryFunction<Object[], GraphExplorer, Object[]> f) {
\r
1816 this.selectionTransformation = f;
\r
1820 public <T> void addListener(T listener) {
\r
1821 if(listener instanceof FocusListener) {
\r
1822 focusListeners.add((FocusListener)listener);
\r
1823 } else if(listener instanceof MouseListener) {
\r
1824 mouseListeners.add((MouseListener)listener);
\r
1825 } else if(listener instanceof KeyListener) {
\r
1826 keyListeners.add((KeyListener)listener);
\r
1831 public <T> void removeListener(T listener) {
\r
1832 if(listener instanceof FocusListener) {
\r
1833 focusListeners.remove(listener);
\r
1834 } else if(listener instanceof MouseListener) {
\r
1835 mouseListeners.remove(listener);
\r
1836 } else if(listener instanceof KeyListener) {
\r
1837 keyListeners.remove(listener);
\r
1841 public void addSelectionListener(SelectionListener listener) {
\r
1842 tree.addSelectionListener(listener);
\r
1845 public void removeSelectionListener(SelectionListener listener) {
\r
1846 tree.removeSelectionListener(listener);
\r
1849 private Set<String> uiContexts;
\r
1852 public void setUIContexts(Set<String> contexts) {
\r
1853 this.uiContexts = contexts;
\r
1857 public void setRoot(final Object root) {
\r
1858 if(uiContexts != null && uiContexts.size() == 1)
\r
1859 setRootContext0(NodeContextBuilder.buildWithData(BuiltinKeys.INPUT, root, BuiltinKeys.UI_CONTEXT, uiContexts.iterator().next()));
\r
1861 setRootContext0(NodeContextBuilder.buildWithData(BuiltinKeys.INPUT, root));
\r
1865 public void setRootContext(final NodeContext context) {
\r
1866 setRootContext0(context);
\r
1869 private void setRootContext0(final NodeContext context) {
\r
1870 Assert.isNotNull(context, "root must not be null");
\r
1871 if (isDisposed() || tree.isDisposed())
\r
1873 Display display = tree.getDisplay();
\r
1874 if (display.getThread() == Thread.currentThread()) {
\r
1875 doSetRoot(context);
\r
1877 display.asyncExec(new Runnable() {
\r
1879 public void run() {
\r
1880 doSetRoot(context);
\r
1886 private void initializeState() {
\r
1887 if (persistor == null)
\r
1890 ExplorerState state = persistor.deserialize(
\r
1891 Platform.getStateLocation(Activator.getDefault().getBundle()).toFile(),
\r
1894 // topNodeToSet will be processed by #setData when it encounters a
\r
1895 // NodeContext that matches this one.
\r
1896 // topNodePath = state.topNodePath;
\r
1897 // topNodePathChildIndex = state.topNodePathChildIndex;
\r
1898 // currentTopNodePathIndex = 0;
\r
1900 Object processor = getPrimitiveProcessor(BuiltinKeys.IS_EXPANDED);
\r
1901 if (processor instanceof DefaultIsExpandedProcessor) {
\r
1902 DefaultIsExpandedProcessor isExpandedProcessor = (DefaultIsExpandedProcessor)processor;
\r
1903 for(NodeContext expanded : state.expandedNodes) {
\r
1904 isExpandedProcessor.setExpanded(expanded, true);
\r
1909 private void saveState() {
\r
1910 if (persistor == null)
\r
1913 NodeContext[] topNodePath = NodeContext.NONE;
\r
1914 int[] topNodePathChildIndex = {};
\r
1915 Collection<NodeContext> expandedNodes = Collections.emptyList();
\r
1916 Map<String, Integer> columnWidths = Collections.<String, Integer> emptyMap();
\r
1918 // Resolve top node path
\r
1919 TreeItem topItem = tree.getTopItem();
\r
1920 if (topItem != null) {
\r
1921 NodeContext topNode = (NodeContext) topItem.getData();
\r
1922 if (topNode != null) {
\r
1923 topNodePath = getNodeContextPathSegments(topNode);
\r
1924 topNodePathChildIndex = new int[topNodePath.length];
\r
1925 for (int i = 0; i < topNodePath.length; ++i) {
\r
1926 // TODO: get child indexes
\r
1927 topNodePathChildIndex[i] = 0;
\r
1932 // Resolve expanded nodes
\r
1933 Object processor = getPrimitiveProcessor(BuiltinKeys.IS_EXPANDED);
\r
1934 if (processor instanceof IsExpandedProcessor) {
\r
1935 IsExpandedProcessor isExpandedProcessor = (IsExpandedProcessor) processor;
\r
1936 expandedNodes = isExpandedProcessor.getExpanded();
\r
1940 TreeColumn[] columns = tree.getColumns();
\r
1941 if (columns.length > 1) {
\r
1942 columnWidths = new HashMap<String, Integer>();
\r
1943 for (int i = 0; i < columns.length; ++i) {
\r
1944 columnWidths.put(columns[i].getText(), columns[i].getWidth());
\r
1948 persistor.serialize(
\r
1949 Platform.getStateLocation(Activator.getDefault().getBundle()).toFile(),
\r
1951 new ExplorerState(topNodePath, topNodePathChildIndex, expandedNodes, columnWidths));
\r
1955 * Invoke only from SWT thread to reset the root of the graph explorer tree.
\r
1959 private void doSetRoot(NodeContext root) {
\r
1960 if (tree.isDisposed())
\r
1962 if (root.getConstant(BuiltinKeys.INPUT) == null) {
\r
1963 ErrorLogger.defaultLogError("root node context does not contain BuiltinKeys.INPUT key. Node = " + root, new Exception("trace"));
\r
1967 // Empty caches, release queries.
\r
1968 GraphExplorerContext oldContext = explorerContext;
\r
1969 GraphExplorerContext newContext = new GraphExplorerContext();
\r
1970 GENodeQueryManager manager = new GENodeQueryManager(newContext, null, null, TreeItemReference.create(null));
\r
1971 this.explorerContext = newContext;
\r
1972 oldContext.safeDispose();
\r
1973 toolTip.setGraphExplorerContext(explorerContext);
\r
1975 // Need to empty these or otherwise they won't be emptied until the
\r
1976 // explorer is disposed which would mean that many unwanted references
\r
1977 // will be held by this map.
\r
1978 clearPrimitiveProcessors();
\r
1980 this.rootContext = root.getConstant(BuiltinKeys.IS_ROOT) != null ? root
\r
1981 : NodeContextUtil.withConstant(root, BuiltinKeys.IS_ROOT, Boolean.TRUE);
\r
1983 explorerContext.getCache().incRef(this.rootContext);
\r
1985 initializeState();
\r
1987 NodeContext[] contexts = manager.query(rootContext, BuiltinKeys.FINAL_CHILDREN);
\r
1989 tree.setItemCount(contexts.length);
\r
1991 select(rootContext);
\r
1992 refreshColumnSizes();
\r
1996 public NodeContext getRoot() {
\r
1997 return rootContext;
\r
2001 public NodeContext getParentContext(NodeContext context) {
\r
2003 throw new IllegalStateException("disposed");
\r
2004 if (!thread.currentThreadAccess())
\r
2005 throw new IllegalStateException("not in SWT display thread " + thread.getThread());
\r
2007 TreeItem item = contextToItem.getRight(context);
\r
2008 if(item == null) return null;
\r
2009 TreeItem parentItem = item.getParentItem();
\r
2010 if(parentItem == null) return null;
\r
2011 return (NodeContext)parentItem.getData();
\r
2014 Point previousTreeSize;
\r
2015 Point previousTreeParentSize;
\r
2016 boolean activatedBefore = false;
\r
2019 public void handleEvent(Event event) {
\r
2020 //System.out.println("EVENT: " + event);
\r
2021 switch(event.type) {
\r
2023 //System.out.println("EXPAND: " + event.item);
\r
2024 if ((tree.getStyle() & SWT.VIRTUAL) != 0) {
\r
2025 expandVirtual(event);
\r
2027 System.out.println("TODO: non-virtual tree item expand");
\r
2031 // Only invoked for SWT.VIRTUAL trees
\r
2033 // Happened for Hannu once during program startup.
\r
2034 // java.lang.AssertionError
\r
2035 // at org.simantics.browsing.ui.common.internal.GENodeQueryManager.query(GENodeQueryManager.java:190)
\r
2036 // at org.simantics.browsing.ui.swt.GraphExplorerImpl.setData(GraphExplorerImpl.java:2315)
\r
2037 // at org.simantics.browsing.ui.swt.GraphExplorerImpl.handleEvent(GraphExplorerImpl.java:2039)
\r
2038 // I do not know whether SWT guarantees that SetData events
\r
2039 // don't come after Dispose event has been issued, but I
\r
2040 // think its better to have this check here just incase.
\r
2044 case SWT.Activate:
\r
2045 // This ensures that column sizes are refreshed at
\r
2046 // least once when the GE is first shown.
\r
2047 if (!activatedBefore) {
\r
2048 refreshColumnSizes();
\r
2049 activatedBefore = true;
\r
2053 //new Exception().printStackTrace();
\r
2060 if (event.widget == tree) {
\r
2061 // This case is meant for listening to tree width increase.
\r
2062 // The column resizing must be performed only after the tree
\r
2063 // itself as been resized.
\r
2064 Point size = tree.getSize();
\r
2066 if (previousTreeSize != null) {
\r
2067 dx = size.x - previousTreeSize.x;
\r
2069 previousTreeSize = size;
\r
2070 //System.out.println("RESIZE: " + dx + " - size=" + size);
\r
2073 tree.setRedraw(false);
\r
2074 refreshColumnSizes(size);
\r
2075 tree.setRedraw(true);
\r
2077 } else if (event.widget == tree.getParent()) {
\r
2078 // This case is meant for listening to tree width decrease.
\r
2079 // The columns must be resized before the tree widget itself
\r
2080 // is resized to prevent scroll bar flicker. This can be achieved
\r
2081 // by listening to the resize events of the tree parent widget.
\r
2082 Composite parent = tree.getParent();
\r
2083 Point size = parent.getSize();
\r
2085 // We must subtract the parent's border and possible
\r
2086 // scroll bar width from the new target width of the columns.
\r
2087 size.x -= tree.getParent().getBorderWidth() * 2;
\r
2088 ScrollBar vBar = parent.getVerticalBar();
\r
2089 if (vBar != null && vBar.isVisible())
\r
2090 size.x -= vBar.getSize().x;
\r
2093 if (previousTreeParentSize != null) {
\r
2094 dx = size.x - previousTreeParentSize.x;
\r
2096 previousTreeParentSize = size;
\r
2097 //System.out.println("RESIZE: " + dx + " - size=" + size);
\r
2100 tree.setRedraw(false);
\r
2101 refreshColumnSizes(size);
\r
2102 tree.setRedraw(true);
\r
2112 protected void refreshColumnSizes() {
\r
2113 // Composite treeParent = tree.getParent();
\r
2114 // Point size = treeParent.getSize();
\r
2115 // size.x -= treeParent.getBorderWidth() * 2;
\r
2116 Point size = tree.getSize();
\r
2117 refreshColumnSizes(size);
\r
2118 tree.getParent().layout();
\r
2122 * This has been disabled since the logic of handling column widths has been
\r
2123 * externalized to parties creating {@link GraphExplorerImpl} instances.
\r
2125 protected void refreshColumnSizes(Point toSize) {
\r
2127 refreshingColumnSizes = true;
\r
2129 int columnCount = tree.getColumnCount();
\r
2130 if (columnCount > 0) {
\r
2131 Point size = toSize;
\r
2132 int targetWidth = size.x - tree.getBorderWidth() * 2;
\r
2135 // Take the vertical scroll bar existence into to account when
\r
2136 // calculating the overflow column width.
\r
2137 ScrollBar vBar = tree.getVerticalBar();
\r
2138 //if (vBar != null && vBar.isVisible())
\r
2140 targetWidth -= vBar.getSize().x;
\r
2142 List<TreeColumn> resizing = new ArrayList<TreeColumn>();
\r
2143 int usedWidth = 0;
\r
2144 int resizingWidth = 0;
\r
2145 int totalWeight = 0;
\r
2146 for (int i = 0; i < columnCount - 1; ++i) {
\r
2147 TreeColumn col = tree.getColumn(i);
\r
2148 //System.out.println(" " + col.getText() + ": " + col.getWidth());
\r
2149 int width = col.getWidth();
\r
2150 usedWidth += width;
\r
2151 Column c = (Column) col.getData();
\r
2152 if (c.hasGrab()) {
\r
2153 resizing.add(col);
\r
2154 resizingWidth += width;
\r
2155 totalWeight += c.getWeight();
\r
2159 int requiredWidthAdjustment = targetWidth - usedWidth;
\r
2160 if (requiredWidthAdjustment < 0)
\r
2161 requiredWidthAdjustment = Math.min(requiredWidthAdjustment, -resizing.size());
\r
2162 double diff = requiredWidthAdjustment;
\r
2163 //System.out.println("REQUIRED WIDTH ADJUSTMENT: " + requiredWidthAdjustment);
\r
2165 // Decide how much to give space to / take space from each grabbing column
\r
2166 double wrel = 1.0 / resizing.size();
\r
2168 double[] weightedShares = new double[resizing.size()];
\r
2169 for (int i = 0; i < resizing.size(); ++i) {
\r
2170 TreeColumn col = resizing.get(i);
\r
2171 Column c = (Column) col.getData();
\r
2172 if (totalWeight == 0) {
\r
2173 weightedShares[i] = wrel;
\r
2175 weightedShares[i] = (double) c.getWeight() / (double) totalWeight;
\r
2178 //System.out.println("grabbing columns:" + resizing);
\r
2179 //System.out.println("weighted space distribution: " + Arrays.toString(weightedShares));
\r
2181 // Always shrink the columns if necessary, but don't enlarge before
\r
2182 // there is sufficient space to at least give all resizable columns
\r
2183 // some more width.
\r
2184 if (diff < 0 || (diff > 0 && diff > resizing.size())) {
\r
2185 // Need to either shrink or enlarge the resizable columns if possible.
\r
2186 for (int i = 0; i < resizing.size(); ++i) {
\r
2187 TreeColumn col = resizing.get(i);
\r
2188 Column c = (Column) col.getData();
\r
2189 int cw = col.getWidth();
\r
2190 //double wrel = (double) cw / (double) resizingWidth;
\r
2191 //int delta = Math.min((int) Math.round(wrel * diff), requiredWidthAdjustment);
\r
2192 double ddelta = weightedShares[i] * diff;
\r
2195 delta = (int) Math.floor(ddelta);
\r
2197 delta = Math.min((int) Math.floor(ddelta), requiredWidthAdjustment);
\r
2199 //System.out.println("size delta(" + col.getText() + "): " + ddelta + " => " + delta);
\r
2200 //System.out.println("argh(" + col.getText() + "): " + c.getWidth() + " vs. " + col.getWidth() + " vs. " + (cw+delta));
\r
2201 int newWidth = Math.max(c.getWidth(), cw + delta);
\r
2202 requiredWidthAdjustment -= (newWidth - cw);
\r
2203 col.setWidth(newWidth);
\r
2207 //System.out.println("FILLER WIDTH LEFT: " + requiredWidthAdjustment);
\r
2209 TreeColumn last = tree.getColumn(columnCount - 1);
\r
2210 // HACK: see #setColumns for why this is here.
\r
2211 if (FILLER.equals(last.getText())) {
\r
2212 last.setWidth(Math.max(0, requiredWidthAdjustment));
\r
2216 refreshingColumnSizes = false;
\r
2221 private void doDispose() {
\r
2222 explorerContext.dispose();
\r
2224 // No longer necessary, the used executors are shared.
\r
2225 //scheduler.shutdown();
\r
2226 //scheduler2.shutdown();
\r
2228 processors.clear();
\r
2229 detachPrimitiveProcessors();
\r
2230 primitiveProcessors.clear();
\r
2231 dataSources.clear();
\r
2233 pendingItems.clear();
\r
2235 rootContext = null;
\r
2237 contextToItem.clear();
\r
2239 mouseListeners.clear();
\r
2241 selectionProvider.clearListeners();
\r
2242 selectionProvider = null;
\r
2243 selectionDataResolver = null;
\r
2244 selectionRefreshContexts.clear();
\r
2245 selectedItems.clear();
\r
2246 originalFont = null;
\r
2248 localResourceManager.dispose();
\r
2250 // Must shutdown image loader job before disposing its ResourceManager
\r
2251 imageLoaderJob.dispose();
\r
2252 imageLoaderJob.cancel();
\r
2254 imageLoaderJob.join();
\r
2255 } catch (InterruptedException e) {
\r
2256 ErrorLogger.defaultLogError(e);
\r
2258 resourceManager.dispose();
\r
2260 postSelectionProvider.dispose();
\r
2264 private void expandVirtual(final Event event) {
\r
2265 TreeItem item = (TreeItem) event.item;
\r
2266 assert (item != null);
\r
2267 NodeContext context = (NodeContext) item.getData();
\r
2268 assert (context != null);
\r
2270 GENodeQueryManager manager = new GENodeQueryManager(this.explorerContext, null, null, TreeItemReference.create(item));
\r
2271 NodeContext[] children = manager.query(context, BuiltinKeys.FINAL_CHILDREN);
\r
2272 int maxChildren = getMaxChildren(manager, context);
\r
2273 item.setItemCount(children.length < maxChildren ? children.length : maxChildren);
\r
2276 private NodeContext getNodeContext(TreeItem item) {
\r
2277 assert(item != null);
\r
2279 NodeContext context = (NodeContext)item.getData();
\r
2280 assert(context != null);
\r
2285 private NodeContext getParentContext(TreeItem item) {
\r
2286 TreeItem parentItem = item.getParentItem();
\r
2287 if(parentItem != null) {
\r
2288 return getNodeContext(parentItem);
\r
2290 return rootContext;
\r
2294 private static final String LISTENER_SET_INDICATOR = "LSI";
\r
2295 private static final String PENDING = "PENDING";
\r
2296 private int contextSelectionChangeModCount = 0;
\r
2299 * Only invoked for SWT.VIRTUAL widgets.
\r
2303 private void setData(final Event event) {
\r
2304 assert (event != null);
\r
2305 TreeItem item = (TreeItem) event.item;
\r
2306 assert (item != null);
\r
2308 // Based on experience it seems to be possible that
\r
2309 // SetData events are sent for disposed TreeItems.
\r
2310 if (item.isDisposed() || item.getData(PENDING) != null)
\r
2313 //System.out.println("GE.SetData " + item);
\r
2315 GENodeQueryManager manager = new GENodeQueryManager(this.explorerContext, null, null, TreeItemReference.create(item.getParentItem()));
\r
2317 NodeContext parentContext = getParentContext(item);
\r
2318 assert (parentContext != null);
\r
2320 NodeContext[] parentChildren = manager.query(parentContext, BuiltinKeys.FINAL_CHILDREN);
\r
2322 // Some children have disappeared since counting
\r
2323 if (event.index < 0) {
\r
2324 ErrorLogger.defaultLogError("GraphExplorer.setData: how can event.index be < 0: " + event.index + " ??", new Exception());
\r
2327 if (event.index >= parentChildren.length)
\r
2330 NodeContext context = parentChildren[event.index];
\r
2331 assert (context != null);
\r
2332 item.setData(context);
\r
2334 // Manage NodeContext -> TreeItem mappings
\r
2335 contextToItem.map(context, item);
\r
2336 if (item.getData(LISTENER_SET_INDICATOR) == null) {
\r
2337 // This "if" exists because setData will get called many
\r
2338 // times for the same (NodeContext, TreeItem) pairs.
\r
2339 // Each TreeItem only needs one listener, but this
\r
2340 // is needed to tell whether it already has a listener
\r
2342 item.setData(LISTENER_SET_INDICATOR, LISTENER_SET_INDICATOR);
\r
2343 item.addListener(SWT.Dispose, itemDisposeListener);
\r
2346 boolean isExpanded = manager.query(context, BuiltinKeys.IS_EXPANDED);
\r
2348 PrunedChildrenResult children = manager.query(context, BuiltinKeys.PRUNED_CHILDREN);
\r
2349 int maxChildren = getMaxChildren(manager, context);
\r
2350 //item.setItemCount(children.getPrunedChildren().length < maxChildren ? children.getPrunedChildren().length : maxChildren);
\r
2352 NodeContext[] pruned = children.getPrunedChildren();
\r
2353 int count = Math.min(pruned.length, maxChildren);
\r
2355 if (isExpanded || item.getItemCount() > 1) {
\r
2356 item.setItemCount(count);
\r
2357 TreeItem[] childItems = item.getItems();
\r
2358 for(int i=0;i<count;i++)
\r
2359 contextToItem.map(pruned[i], childItems[i]);
\r
2361 if (children.getPrunedChildren().length == 0) {
\r
2362 item.setItemCount(0);
\r
2364 // item.setItemCount(1);
\r
2365 item.setItemCount(count);
\r
2366 TreeItem[] childItems = item.getItems();
\r
2367 for(int i=0;i<count;i++)
\r
2368 contextToItem.map(pruned[i], childItems[i]);
\r
2369 // item.getItem(0).setData(PENDING, PENDING);
\r
2370 // item.getItem(0).setItemCount(o);
\r
2374 setTextAndImage(item, manager, context, event.index);
\r
2376 // Check if the node should be auto-expanded?
\r
2377 if ((autoExpandLevel == ALL_LEVELS || autoExpandLevel > 1) && !isExpanded) {
\r
2378 //System.out.println("NOT EXPANDED(" +context + ", " + item + ")");
\r
2379 int level = getTreeItemLevel(item);
\r
2380 if ((autoExpandLevel == ALL_LEVELS || level <= autoExpandLevel)
\r
2381 && !explorerContext.autoExpanded.containsKey(context))
\r
2383 //System.out.println("AUTO-EXPANDING(" + context + ", " + item + ")");
\r
2384 explorerContext.autoExpanded.put(context, Boolean.TRUE);
\r
2385 setExpanded(context, true);
\r
2389 item.setExpanded(isExpanded);
\r
2391 if ((tree.getStyle() & SWT.CHECK) != 0) {
\r
2392 CheckedState checked = manager.query(context, BuiltinKeys.IS_CHECKED);
\r
2393 item.setChecked(CheckedState.CHECKED_STATES.contains(checked));
\r
2394 item.setGrayed(CheckedState.GRAYED == checked);
\r
2397 //System.out.println("GE.SetData completed " + item);
\r
2399 // This test makes sure that selectionProvider holds the correct
\r
2400 // selection with respect to the actual selection stored by the virtual
\r
2401 // SWT Tree widget.
\r
2402 // The data items shown below the items occupied by the selected and now removed data
\r
2403 // will be squeezed to use the tree items previously used for the now
\r
2404 // removed data. When this happens, the NodeContext items stored by the
\r
2405 // tree items will be different from what the GraphExplorer's
\r
2406 // ISelectionProvider thinks the selection currently is. To compensate,
\r
2407 // 1. Recognize the situation
\r
2408 // 2. ASAP set the selection provider selection to what is actually
\r
2409 // offered by the tree widget.
\r
2410 NodeContext selectedContext = selectedItems.get(item);
\r
2411 // System.out.println("selectedContext(" + item + "): " + selectedContext);
\r
2412 if (selectedContext != null && !selectedContext.equals(context)) {
\r
2413 final int modCount = ++contextSelectionChangeModCount;
\r
2414 // System.out.println("SELECTION MUST BE UPDATED (modCount=" + modCount + "): " + item);
\r
2415 // System.out.println(" old context: " + selectedContext);
\r
2416 // System.out.println(" new context: " + context);
\r
2417 // System.out.println(" provider selection: " + selectionProvider.getSelection());
\r
2418 // System.out.println(" widget selection: " + getWidgetSelection());
\r
2419 ThreadUtils.asyncExec(thread, new Runnable() {
\r
2421 public void run() {
\r
2424 int count = contextSelectionChangeModCount;
\r
2425 // System.out.println("MODCOUNT: " + modCount + " vs. " + count);
\r
2426 if (modCount != count)
\r
2428 widgetSelectionChanged(true);
\r
2433 // This must be done to keep the visible tree selection properly
\r
2434 // in sync with the selectionProvider JFace proxy of this class in
\r
2435 // cases where an in-line editor was previously active for the node
\r
2437 if (selectionRefreshContexts.remove(context)) {
\r
2438 final ISelection currentSelection = selectionProvider.getSelection();
\r
2439 // asyncExec is here to prevent ui glitches that
\r
2440 // seem to occur if the selection setting is done
\r
2441 // directly here in between setData invocations.
\r
2442 ThreadUtils.asyncExec(thread, new Runnable() {
\r
2444 public void run() {
\r
2447 // System.out.println("REFRESHING SELECTION: " + currentSelection);
\r
2448 // System.out.println("BEFORE setSelection: " + Arrays.toString(tree.getSelection()));
\r
2449 // System.out.println("BEFORE setSelection: " + selectionProvider.getSelection());
\r
2450 setSelection(currentSelection, true);
\r
2451 // System.out.println("AFTER setSelection: " + Arrays.toString(tree.getSelection()));
\r
2452 // System.out.println("AFTER setSelection: " + selectionProvider.getSelection());
\r
2457 // TODO: doesn't work if any part of the node path that should be
\r
2458 // revealed is out of view.
\r
2459 // Disabled until a better solution is devised.
\r
2460 // Suggestion: include item indexes into the stored node context path
\r
2461 // to make it possible for this method to know whether the current
\r
2462 // node path segment is currently out of view based on event.index.
\r
2463 // If out of view, this code needs to scroll the view programmatically
\r
2465 // if (currentTopNodePathIndex >= 0 && topNodePath.length > 0) {
\r
2466 // NodeContext topNode = topNodePath[currentTopNodePathIndex];
\r
2467 // if (topNode.equals(context)) {
\r
2468 // final TreeItem topItem = item;
\r
2469 // ++currentTopNodePathIndex;
\r
2470 // if (currentTopNodePathIndex >= topNodePath.length) {
\r
2471 // // Mission accomplished. End search for top node here.
\r
2472 // topNodePath = NodeContext.NONE;
\r
2473 // currentTopNodePathIndex = -1;
\r
2475 // ThreadUtils.asyncExec(thread, new Runnable() {
\r
2477 // public void run() {
\r
2478 // if (isDisposed())
\r
2480 // tree.setTopItem(topItem);
\r
2486 // Check if vertical scroll bar has become visible and refresh layout.
\r
2487 ScrollBar verticalBar = tree.getVerticalBar();
\r
2488 if(verticalBar != null) {
\r
2489 boolean currentlyVerticalBarVisible = verticalBar.isVisible();
\r
2490 if (verticalBarVisible != currentlyVerticalBarVisible) {
\r
2491 verticalBarVisible = currentlyVerticalBarVisible;
\r
2492 Composite parent = tree.getParent();
\r
2493 if (parent != null)
\r
2500 * @return see {@link GraphExplorer#setAutoExpandLevel(int)} for how the
\r
2501 * return value is calculated. Items without parents have level=2,
\r
2502 * their children level=3, etc. Returns 0 for invalid items
\r
2504 private int getTreeItemLevel(TreeItem item) {
\r
2508 for (TreeItem parent = item; parent != null; parent = parent.getParentItem(), ++level);
\r
2509 //System.out.println("\tgetTreeItemLevel(" + parent + ")");
\r
2510 //System.out.println("level(" + item + "): " + level);
\r
2518 private NodeContext[] getNodeContextPathSegments(NodeContext node) {
\r
2519 TreeItem item = contextToItem.getRight(node);
\r
2521 return NodeContext.NONE;
\r
2522 int level = getTreeItemLevel(item);
\r
2524 return NodeContext.NONE;
\r
2525 // Exclude root from the saved node path.
\r
2527 NodeContext[] segments = new NodeContext[level];
\r
2528 for (TreeItem parent = item; parent != null; parent = parent.getParentItem(), --level) {
\r
2529 NodeContext ctx = (NodeContext) item.getData();
\r
2531 return NodeContext.NONE;
\r
2532 segments[level-1] = ctx;
\r
2541 @SuppressWarnings("unused")
\r
2542 private NodeContextPath getNodeContextPath(NodeContext node) {
\r
2543 NodeContext[] path = getNodeContextPathSegments(node);
\r
2544 return new NodeContextPath(path);
\r
2547 void setImage(NodeContext node, TreeItem item, Imager imager, Collection<ImageDecorator> decorators, int itemIndex) {
\r
2548 Image[] images = columnImageArray;
\r
2549 Arrays.fill(images, null);
\r
2550 if (imager == null) {
\r
2551 item.setImage(images);
\r
2555 Object[] descOrImage = columnDescOrImageArray;
\r
2556 Arrays.fill(descOrImage, null);
\r
2557 boolean finishLoadingInJob = false;
\r
2559 for (Column column : columns) {
\r
2560 String key = column.getKey();
\r
2561 ImageDescriptor desc = imager.getImage(key);
\r
2562 if (desc != null) {
\r
2563 // Attempt to decorate the label
\r
2564 if (!decorators.isEmpty()) {
\r
2565 for (ImageDecorator id : decorators) {
\r
2566 ImageDescriptor ds = id.decorateImage(desc, key, itemIndex);
\r
2572 // Try resolving only cached images here and now
\r
2573 Object img = localResourceManager.find(desc);
\r
2575 img = resourceManager.find(desc);
\r
2577 images[index] = img != null ? (Image) img : null;
\r
2578 descOrImage[index] = img == null ? desc : img;
\r
2579 finishLoadingInJob |= img == null;
\r
2584 // Finish loading the final image in the image loader job if necessary.
\r
2585 if (finishLoadingInJob) {
\r
2586 // Prevent UI from flashing unnecessarily by reusing the old image
\r
2587 // in the item if it exists.
\r
2588 for (int c = 0; c < columns.length; ++c) {
\r
2589 Image img = item.getImage(c);
\r
2593 item.setImage(images);
\r
2595 // Schedule loading to another thread to refrain from blocking
\r
2596 // the UI with database operations.
\r
2597 queueImageTask(item, new ImageTask(
\r
2600 Arrays.copyOf(descOrImage, descOrImage.length)));
\r
2602 // Set any images that were resolved.
\r
2603 item.setImage(images);
\r
2607 private void queueImageTask(TreeItem item, ImageTask task) {
\r
2608 synchronized (imageTasks) {
\r
2609 imageTasks.put(item, task);
\r
2611 imageLoaderJob.scheduleIfNecessary(100);
\r
2615 * Invoked in a job worker thread.
\r
2618 * @see ImageLoaderJob
\r
2621 protected IStatus setPendingImages(IProgressMonitor monitor) {
\r
2622 ImageTask[] tasks = null;
\r
2623 synchronized (imageTasks) {
\r
2624 tasks = imageTasks.values().toArray(new ImageTask[imageTasks.size()]);
\r
2625 imageTasks.clear();
\r
2627 if (tasks.length == 0)
\r
2628 return Status.OK_STATUS;
\r
2630 MultiStatus status = null;
\r
2632 // Load missing images
\r
2633 for (ImageTask task : tasks) {
\r
2634 Object[] descs = task.descsOrImages;
\r
2635 for (int i = 0; i < descs.length; ++i) {
\r
2636 Object obj = descs[i];
\r
2637 if (obj instanceof ImageDescriptor) {
\r
2638 ImageDescriptor desc = (ImageDescriptor) obj;
\r
2640 descs[i] = resourceManager.get((ImageDescriptor) desc);
\r
2641 } catch (DeviceResourceException e) {
\r
2642 if (status == null)
\r
2643 status = new MultiStatus(Activator.PLUGIN_ID, 0, "Problems loading images:", null);
\r
2644 status.add(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Image descriptor loading failed: " + desc, e));
\r
2650 // Perform final UI updates in the UI thread.
\r
2651 final ImageTask[] _tasks = tasks;
\r
2652 thread.asyncExec(new Runnable() {
\r
2654 public void run() {
\r
2655 if (!tree.isDisposed()) {
\r
2656 tree.setRedraw(false);
\r
2657 setImages(_tasks);
\r
2658 tree.setRedraw(true);
\r
2663 return status != null ? status : Status.OK_STATUS;
\r
2667 * Invoked in the UI thread only.
\r
2671 void setImages(ImageTask[] tasks) {
\r
2672 for (ImageTask task : tasks)
\r
2678 * Invoked in the UI thread only.
\r
2682 void setImage(ImageTask task) {
\r
2683 // Be sure not to process disposed items.
\r
2684 if (task.item.isDisposed())
\r
2686 // Discard this task if the TreeItem has switched owning NodeContext.
\r
2687 if (!contextToItem.contains(task.node, task.item))
\r
2690 Object[] descs = task.descsOrImages;
\r
2691 Image[] images = columnImageArray;
\r
2692 Arrays.fill(images, null);
\r
2693 for (int i = 0; i < descs.length; ++i) {
\r
2694 Object desc = descs[i];
\r
2695 if (desc instanceof Image) {
\r
2696 images[i] = (Image) desc;
\r
2699 task.item.setImage(images);
\r
2702 void setText(TreeItem item, Labeler labeler, Collection<LabelDecorator> decorators, int itemIndex) {
\r
2703 if (labeler != null) {
\r
2704 String[] texts = new String[columns.length];
\r
2706 Map<String, String> labels = labeler.getLabels();
\r
2707 Map<String, String> runtimeLabels = labeler.getRuntimeLabels();
\r
2708 for (Column column : columns) {
\r
2709 String key = column.getKey();
\r
2711 if (runtimeLabels != null) s = runtimeLabels.get(key);
\r
2712 if (s == null) s = labels.get(key);
\r
2714 FontDescriptor font = originalFont;
\r
2715 ColorDescriptor bg = originalBackground;
\r
2716 ColorDescriptor fg = originalForeground;
\r
2718 // Attempt to decorate the label
\r
2719 if (!decorators.isEmpty()) {
\r
2720 for (LabelDecorator ld : decorators) {
\r
2721 String ds = ld.decorateLabel(s, key, itemIndex);
\r
2725 FontDescriptor dfont = ld.decorateFont(font, key, itemIndex);
\r
2726 if (dfont != null)
\r
2729 ColorDescriptor dbg = ld.decorateBackground(bg, key, itemIndex);
\r
2733 ColorDescriptor dfg = ld.decorateForeground(fg, key, itemIndex);
\r
2739 if (font != originalFont) {
\r
2740 //System.out.println("set font: " + index + ": " + font);
\r
2741 item.setFont(index, (Font) localResourceManager.get(font));
\r
2743 if (bg != originalBackground)
\r
2744 item.setBackground(index, (Color) localResourceManager.get(bg));
\r
2745 if (fg != originalForeground)
\r
2746 item.setForeground(index, (Color) localResourceManager.get(fg));
\r
2752 item.setText(texts);
\r
2754 item.setText(Labeler.NO_LABEL);
\r
2758 void setTextAndImage(TreeItem item, NodeQueryManager manager, NodeContext context, int itemIndex) {
\r
2759 Labeler labeler = manager.query(context, BuiltinKeys.SELECTED_LABELER);
\r
2760 if (labeler != null) {
\r
2761 labeler.setListener(labelListener);
\r
2763 Imager imager = manager.query(context, BuiltinKeys.SELECTED_IMAGER);
\r
2764 Collection<LabelDecorator> labelDecorators = manager.query(context, BuiltinKeys.LABEL_DECORATORS);
\r
2765 Collection<ImageDecorator> imageDecorators = manager.query(context, BuiltinKeys.IMAGE_DECORATORS);
\r
2767 setText(item, labeler, labelDecorators, itemIndex);
\r
2768 setImage(context, item, imager, imageDecorators, itemIndex);
\r
2772 public void setFocus() {
\r
2777 public <T> T query(NodeContext context, CacheKey<T> key) {
\r
2778 return this.explorerContext.cache.get(context, key);
\r
2782 public boolean isDisposed() {
\r
2786 protected void assertNotDisposed() {
\r
2788 throw new IllegalStateException("disposed");
\r
2794 * @param selection
\r
2795 * @param forceControlUpdate
\r
2798 public void setSelection(final ISelection selection, boolean forceControlUpdate) {
\r
2799 assertNotDisposed();
\r
2800 boolean equalsOld = selectionProvider.selectionEquals(selection);
\r
2801 if (equalsOld && !forceControlUpdate) {
\r
2802 // Just set the selection object instance, fire no events nor update
\r
2803 // the viewer selection.
\r
2804 selectionProvider.setSelection(selection);
\r
2806 // Schedule viewer and selection update if necessary.
\r
2807 if (tree.isDisposed())
\r
2809 Display d = tree.getDisplay();
\r
2810 if (d.getThread() == Thread.currentThread()) {
\r
2811 updateSelectionToControl(selection);
\r
2813 d.asyncExec(new Runnable() {
\r
2815 public void run() {
\r
2816 if (tree.isDisposed())
\r
2818 updateSelectionToControl(selection);
\r
2826 /* Contains the best currently found tree item and its priority
\r
2828 private static class SelectionResolutionStatus {
\r
2829 int bestPriority = Integer.MAX_VALUE;
\r
2830 TreeItem bestItem;
\r
2834 * @param selection
\r
2837 private void updateSelectionToControl(ISelection selection) {
\r
2838 if (selectionDataResolver == null)
\r
2840 if (!(selection instanceof IStructuredSelection))
\r
2843 // Initialize selection resolution status map
\r
2844 IStructuredSelection iss = (IStructuredSelection) selection;
\r
2845 final THashMap<Object,SelectionResolutionStatus> statusMap =
\r
2846 new THashMap<Object,SelectionResolutionStatus>(iss.size());
\r
2847 for(Iterator<?> it = iss.iterator(); it.hasNext();) {
\r
2848 Object selectionElement = it.next();
\r
2849 Object resolvedElement = selectionDataResolver.resolve(selectionElement);
\r
2852 new SelectionResolutionStatus());
\r
2855 // Iterate all tree items and try to match them to the selection
\r
2856 iterateTreeItems(new TObjectProcedure<TreeItem>() {
\r
2858 public boolean execute(TreeItem treeItem) {
\r
2859 NodeContext nodeContext = (NodeContext)treeItem.getData();
\r
2860 if(nodeContext == null)
\r
2862 SelectionResolutionStatus status = statusMap.get(nodeContext);
\r
2863 if(status != null) {
\r
2864 status.bestPriority = 0; // best possible match
\r
2865 status.bestItem = treeItem;
\r
2869 Object input = nodeContext.getConstant(BuiltinKeys.INPUT);
\r
2870 status = statusMap.get(input);
\r
2871 if(status != null) {
\r
2872 NodeType nodeType = nodeContext.getConstant(NodeType.TYPE);
\r
2873 int curPriority = nodeType instanceof EntityNodeType
\r
2874 ? 1 // Prefer EntityNodeType matches to other node types
\r
2876 if(curPriority < status.bestPriority) {
\r
2877 status.bestPriority = curPriority;
\r
2878 status.bestItem = treeItem;
\r
2885 // Update selection
\r
2886 ArrayList<TreeItem> items = new ArrayList<TreeItem>(statusMap.size());
\r
2887 for(SelectionResolutionStatus status : statusMap.values())
\r
2888 if(status.bestItem != null)
\r
2889 items.add(status.bestItem);
\r
2890 select(items.toArray(new TreeItem[items.size()]));
\r
2896 public ISelection getWidgetSelection() {
\r
2897 TreeItem[] items = tree.getSelection();
\r
2898 if (items.length == 0)
\r
2899 return StructuredSelection.EMPTY;
\r
2901 List<NodeContext> nodes = new ArrayList<NodeContext>(items.length);
\r
2903 // Caches for resolving node contexts the hard way if necessary.
\r
2904 GENodeQueryManager manager = null;
\r
2905 NodeContext lastParentContext = null;
\r
2906 NodeContext[] lastChildren = null;
\r
2908 for (int i = 0; i < items.length; i++) {
\r
2909 TreeItem item = items[i];
\r
2910 NodeContext ctx = (NodeContext) item.getData();
\r
2911 // It may happen due to the virtual nature of the tree control
\r
2912 // that it contains TreeItems which have not yet been ran through
\r
2913 // #setData(Event).
\r
2914 if (ctx != null) {
\r
2917 TreeItem parentItem = item.getParentItem();
\r
2918 NodeContext parentContext = parentItem != null ? getNodeContext(parentItem) : rootContext;
\r
2919 if (parentContext != null) {
\r
2920 NodeContext[] children = lastChildren;
\r
2921 if (parentContext != lastParentContext) {
\r
2922 if (manager == null)
\r
2923 manager = new GENodeQueryManager(this.explorerContext, null, null, null);
\r
2924 lastChildren = children = manager.query(parentContext, BuiltinKeys.FINAL_CHILDREN);
\r
2925 lastParentContext = parentContext;
\r
2927 int index = parentItem != null ? parentItem.indexOf(item) : tree.indexOf(item);
\r
2928 if (index >= 0 && index < children.length) {
\r
2929 NodeContext child = children[index];
\r
2930 if (child != null) {
\r
2932 // Cache NodeContext in TreeItem for faster access
\r
2933 item.setData(child);
\r
2939 //System.out.println("widget selection " + items.length + " items / " + nodes.size() + " node contexts");
\r
2940 ISelection selection = constructSelection(nodes.toArray(NodeContext.NONE));
\r
2945 public TransientExplorerState getTransientState() {
\r
2946 if (!thread.currentThreadAccess())
\r
2947 throw new AssertionError(getClass().getSimpleName() + ".getActiveColumn called from non SWT-thread: " + Thread.currentThread());
\r
2948 return transientState;
\r
2955 private void select(TreeItem item) {
\r
2956 tree.setSelection(item);
\r
2957 tree.showSelection();
\r
2958 selectionProvider.setAndFireNonEqualSelection(constructSelection((NodeContext) item.getData()));
\r
2965 private void select(TreeItem[] items) {
\r
2966 //System.out.println("Select: " + Arrays.toString(items));
\r
2967 tree.setSelection(items);
\r
2968 tree.showSelection();
\r
2969 NodeContext[] data = new NodeContext[items.length];
\r
2970 for (int i = 0; i < data.length; i++) {
\r
2971 data[i] = (NodeContext) items[i].getData();
\r
2973 selectionProvider.setAndFireNonEqualSelection(constructSelection(data));
\r
2976 private void iterateTreeItems(TObjectProcedure<TreeItem> procedure) {
\r
2977 for(TreeItem item : tree.getItems())
\r
2978 if(!iterateTreeItems(item, procedure))
\r
2982 private boolean iterateTreeItems(TreeItem item,
\r
2983 TObjectProcedure<TreeItem> procedure) {
\r
2984 if(!procedure.execute(item))
\r
2986 if(item.getExpanded())
\r
2987 for(TreeItem child : item.getItems())
\r
2988 if(!iterateTreeItems(child, procedure))
\r
2998 private boolean trySelect(TreeItem item, Object input) {
\r
2999 NodeContext itemCtx = (NodeContext) item.getData();
\r
3000 if (itemCtx != null) {
\r
3001 if (input.equals(itemCtx.getConstant(BuiltinKeys.INPUT))) {
\r
3006 if (item.getExpanded()) {
\r
3007 for (TreeItem child : item.getItems()) {
\r
3008 if (trySelect(child, input))
\r
3015 private boolean equalsEnough(NodeContext c1, NodeContext c2) {
\r
3017 Object input1 = c1.getConstant(BuiltinKeys.INPUT);
\r
3018 Object input2 = c2.getConstant(BuiltinKeys.INPUT);
\r
3019 if(!ObjectUtils.objectEquals(input1, input2))
\r
3022 Object type1 = c1.getConstant(NodeType.TYPE);
\r
3023 Object type2 = c2.getConstant(NodeType.TYPE);
\r
3024 if(!ObjectUtils.objectEquals(type1, type2))
\r
3031 private NodeContext tryFind(NodeContext context) {
\r
3032 for (TreeItem item : tree.getItems()) {
\r
3033 NodeContext found = tryFind(item, context);
\r
3034 if(found != null) return found;
\r
3039 private NodeContext tryFind(TreeItem item, NodeContext context) {
\r
3040 NodeContext itemCtx = (NodeContext) item.getData();
\r
3041 if (itemCtx != null) {
\r
3042 if (equalsEnough(context, itemCtx)) {
\r
3046 if (item.getExpanded()) {
\r
3047 for (TreeItem child : item.getItems()) {
\r
3048 NodeContext found = tryFind(child, context);
\r
3049 if(found != null) return found;
\r
3056 public boolean select(NodeContext context) {
\r
3058 assertNotDisposed();
\r
3060 if (context == null || context.equals(rootContext)) {
\r
3061 tree.deselectAll();
\r
3062 selectionProvider.setAndFireNonEqualSelection(TreeSelection.EMPTY);
\r
3066 // if (context.equals(rootContext)) {
\r
3067 // tree.deselectAll();
\r
3068 // selectionProvider.setAndFireNonEqualSelection(constructSelection(context));
\r
3072 Object input = context.getConstant(BuiltinKeys.INPUT);
\r
3074 for (TreeItem item : tree.getItems()) {
\r
3075 if (trySelect(item, input))
\r
3083 private NodeContext tryFind2(NodeContext context) {
\r
3084 Set<NodeContext> ctxs = contextToItem.getLeftSet();
\r
3085 for(NodeContext c : ctxs)
\r
3086 if(equalsEnough(c, context))
\r
3091 private boolean waitVisible(NodeContext parent, NodeContext context) {
\r
3092 long start = System.nanoTime();
\r
3094 TreeItem parentItem = contextToItem.getRight(parent);
\r
3096 if(parentItem == null)
\r
3100 NodeContext target = tryFind2(context);
\r
3101 if(target != null) {
\r
3102 TreeItem item = contextToItem.getRight(target);
\r
3103 if (!(item.getParentItem().equals(parentItem)))
\r
3105 tree.setTopItem(item);
\r
3109 Display.getCurrent().readAndDispatch();
\r
3110 long duration = System.nanoTime() - start;
\r
3111 if(duration > 10e9)
\r
3116 private boolean selectPathInternal(NodeContext[] contexts, int position) {
\r
3117 //System.out.println("NodeContext path : " + contexts);
\r
3119 NodeContext head = tryFind(contexts[position]);
\r
3121 if(position == contexts.length-1) {
\r
3122 return select(head);
\r
3126 //setExpanded(head, true);
\r
3128 if(!waitVisible(head, contexts[position+1]))
\r
3131 setExpanded(head, true);
\r
3133 return selectPathInternal(contexts, position+1);
\r
3138 public boolean selectPath(Collection<NodeContext> contexts) {
\r
3140 if(contexts == null) throw new IllegalArgumentException("Null list is not allowed");
\r
3141 if(contexts.isEmpty()) throw new IllegalArgumentException("Empty list is not allowed");
\r
3143 return selectPathInternal(contexts.toArray(new NodeContext[contexts.size()]), 0);
\r
3148 public boolean isVisible(NodeContext context) {
\r
3150 for (TreeItem item : tree.getItems()) {
\r
3151 NodeContext found = tryFind(item, context);
\r
3152 if(found != null)
\r
3160 protected ISelection constructSelection(NodeContext... contexts) {
\r
3161 if (contexts == null)
\r
3162 throw new IllegalArgumentException("null contexts");
\r
3163 if (contexts.length == 0)
\r
3164 return StructuredSelection.EMPTY;
\r
3165 if (selectionFilter == null)
\r
3166 return new StructuredSelection(transformSelection(contexts));
\r
3167 return new StructuredSelection( transformSelection(filter(selectionFilter, contexts)) );
\r
3170 protected Object[] transformSelection(Object[] objects) {
\r
3171 return selectionTransformation.call(this, objects);
\r
3174 protected static Object[] filter(SelectionFilter filter, NodeContext[] contexts) {
\r
3175 int len = contexts.length;
\r
3176 Object[] objects = new Object[len];
\r
3177 for (int i = 0; i < len; ++i)
\r
3178 objects[i] = filter.filter(contexts[i]);
\r
3183 public void setExpanded(final NodeContext context, final boolean expanded) {
\r
3184 assertNotDisposed();
\r
3185 ThreadUtils.asyncExec(thread, new Runnable() {
\r
3187 public void run() {
\r
3188 if (!isDisposed())
\r
3189 doSetExpanded(context, expanded);
\r
3194 private void doSetExpanded(NodeContext context, boolean expanded) {
\r
3195 //System.out.println("doSetExpanded(" + context + ", " + expanded + ")");
\r
3196 TreeItem item = contextToItem.getRight(context);
\r
3197 if (item != null) {
\r
3198 item.setExpanded(expanded);
\r
3200 PrimitiveQueryProcessor<?> pqp = explorerContext.getPrimitiveProcessor(BuiltinKeys.IS_EXPANDED);
\r
3201 if (pqp instanceof IsExpandedProcessor) {
\r
3202 IsExpandedProcessor iep = (IsExpandedProcessor) pqp;
\r
3203 iep.replaceExpanded(context, expanded);
\r
3208 public void setColumnsVisible(boolean visible) {
\r
3209 columnsAreVisible = visible;
\r
3210 if(tree != null) tree.setHeaderVisible(columnsAreVisible);
\r
3214 public void setColumns(final Column[] columns) {
\r
3215 setColumns(columns, null);
\r
3219 public void setColumns(final Column[] columns, Consumer<Map<Column, Object>> callback) {
\r
3220 assertNotDisposed();
\r
3221 checkUniqueColumnKeys(columns);
\r
3223 Display d = tree.getDisplay();
\r
3224 if (d.getThread() == Thread.currentThread())
\r
3225 doSetColumns(columns, callback);
\r
3227 d.asyncExec(() -> {
\r
3228 if (tree.isDisposed())
\r
3230 doSetColumns(columns, callback);
\r
3234 private void checkUniqueColumnKeys(Column[] cols) {
\r
3235 Set<String> usedColumnKeys = new HashSet<String>();
\r
3236 List<Column> duplicateColumns = new ArrayList<Column>();
\r
3237 for (Column c : cols) {
\r
3238 if (!usedColumnKeys.add(c.getKey()))
\r
3239 duplicateColumns.add(c);
\r
3241 if (!duplicateColumns.isEmpty()) {
\r
3242 throw new IllegalArgumentException("All columns do not have unique keys: " + cols + ", overlapping: " + duplicateColumns);
\r
3247 * Only meant to be invoked from the SWT UI thread.
\r
3251 private void doSetColumns(Column[] cols, Consumer<Map<Column, Object>> callback) {
\r
3252 // Attempt to keep previous column widths.
\r
3253 Map<String, Integer> prevWidths = new HashMap<String, Integer>();
\r
3254 for (TreeColumn column : tree.getColumns()) {
\r
3255 prevWidths.put(column.getText(), column.getWidth());
\r
3259 HashMap<String, Integer> keyToIndex = new HashMap<String, Integer>();
\r
3260 for (int i = 0; i < cols.length; ++i) {
\r
3261 keyToIndex.put(cols[i].getKey(), i);
\r
3264 this.columns = Arrays.copyOf(cols, cols.length);
\r
3265 //this.columns[cols.length] = FILLER_COLUMN;
\r
3266 this.columnKeyToIndex = keyToIndex;
\r
3267 this.columnImageArray = new Image[cols.length];
\r
3268 this.columnDescOrImageArray = new Object[cols.length];
\r
3270 Map<Column, Object> map = new HashMap<Column, Object>();
\r
3272 tree.setHeaderVisible(columnsAreVisible);
\r
3273 for (Column column : columns) {
\r
3274 TreeColumn c = new TreeColumn(tree, toSWT(column.getAlignment()));
\r
3275 map.put(column, c);
\r
3276 c.setData(column);
\r
3277 c.setText(column.getLabel());
\r
3278 c.setToolTipText(column.getTooltip());
\r
3280 int cw = column.getWidth();
\r
3282 // Try to keep previous widths
\r
3283 Integer w = prevWidths.get(column);
\r
3286 else if (cw != Column.DEFAULT_CONTROL_WIDTH)
\r
3289 // Go for some kind of default settings then...
\r
3290 if (ColumnKeys.PROPERTY.equals(column.getKey()))
\r
3296 // if (!column.hasGrab() && !FILLER.equals(column.getKey())) {
\r
3297 // c.addListener(SWT.Resize, resizeListener);
\r
3298 // c.setResizable(true);
\r
3300 // //c.setResizable(false);
\r
3305 if(callback != null) callback.accept(map);
\r
3307 // Make sure the explorer fits the columns properly after initialization.
\r
3308 tree.getDisplay().asyncExec(new Runnable() {
\r
3310 public void run() {
\r
3311 if (tree.isDisposed())
\r
3313 refreshColumnSizes();
\r
3318 int toSWT(Align alignment) {
\r
3319 switch (alignment) {
\r
3320 case LEFT: return SWT.LEFT;
\r
3321 case CENTER: return SWT.CENTER;
\r
3322 case RIGHT: return SWT.RIGHT;
\r
3323 default: throw new Error("unhandled alignment: " + alignment);
\r
3328 public Column[] getColumns() {
\r
3329 return Arrays.copyOf(columns, columns.length);
\r
3332 private void detachPrimitiveProcessors() {
\r
3333 for (PrimitiveQueryProcessor<?> p : primitiveProcessors.values()) {
\r
3334 if (p instanceof ProcessorLifecycle) {
\r
3335 ((ProcessorLifecycle) p).detached(this);
\r
3340 private void clearPrimitiveProcessors() {
\r
3341 for (PrimitiveQueryProcessor<?> p : primitiveProcessors.values()) {
\r
3342 if (p instanceof ProcessorLifecycle) {
\r
3343 ((ProcessorLifecycle) p).clear();
\r
3348 Listener resizeListener = new Listener() {
\r
3350 public void handleEvent(Event event) {
\r
3351 // Prevent infinite recursion.
\r
3352 if (refreshingColumnSizes)
\r
3354 //TreeColumn column = (TreeColumn) event.widget;
\r
3355 //Column c = (Column) column.getData();
\r
3356 refreshColumnSizes();
\r
3360 Listener itemDisposeListener = new Listener() {
\r
3362 public void handleEvent(Event event) {
\r
3363 if (event.type == SWT.Dispose) {
\r
3364 if (event.widget instanceof TreeItem) {
\r
3365 TreeItem ti = (TreeItem) event.widget;
\r
3366 //NodeContext ctx = (NodeContext) ti.getData();
\r
3367 // System.out.println("DISPOSE CONTEXT TO ITEM: " + ctx + " -> " + System.identityHashCode(ti));
\r
3368 // System.out.println(" map size BEFORE: " + contextToItem.size());
\r
3369 @SuppressWarnings("unused")
\r
3370 NodeContext removed = contextToItem.removeWithRight(ti);
\r
3371 // System.out.println(" REMOVED: " + removed);
\r
3372 // System.out.println(" map size AFTER: " + contextToItem.size());
\r
3381 LabelerListener labelListener = new LabelerListener() {
\r
3383 public boolean columnModified(final NodeContext context, final String key, final String newLabel) {
\r
3384 //System.out.println("column " + key + " modified for " + context + " to " + newLabel);
\r
3385 if (tree.isDisposed())
\r
3388 synchronized (labelRefreshRunnables) {
\r
3389 Runnable refresher = new Runnable() {
\r
3391 public void run() {
\r
3392 // Tree is guaranteed to be non-disposed if this is invoked.
\r
3394 // contextToItem should be accessed only in the SWT thread to keep things thread-safe.
\r
3395 final TreeItem item = contextToItem.getRight(context);
\r
3396 if (item == null || item.isDisposed())
\r
3399 final Integer index = columnKeyToIndex.get(key);
\r
3400 if (index == null)
\r
3403 //System.out.println(" found index: " + index);
\r
3404 //System.out.println(" found item: " + item);
\r
3406 GENodeQueryManager manager = new GENodeQueryManager(explorerContext, null, null, null);
\r
3408 // FIXME: indexOf is quadratic
\r
3409 int itemIndex = 0;
\r
3410 TreeItem parentItem = item.getParentItem();
\r
3411 if (parentItem == null) {
\r
3412 itemIndex = tree.indexOf(item);
\r
3413 //tree.clear(parentIndex, false);
\r
3415 itemIndex = parentItem.indexOf(item);
\r
3416 //item.clear(parentIndex, false);
\r
3418 setTextAndImage(item, manager, context, itemIndex);
\r
3419 } catch (SWTException e) {
\r
3420 ErrorLogger.defaultLogError(e);
\r
3424 //System.out.println(System.currentTimeMillis() + " queueing label refresher: " + refresher);
\r
3425 labelRefreshRunnables.put(context, refresher);
\r
3427 if (!refreshIsQueued) {
\r
3428 refreshIsQueued = true;
\r
3430 long now = System.currentTimeMillis();
\r
3431 long elapsed = now - lastLabelRefreshScheduled;
\r
3432 if (elapsed < DEFAULT_CONSECUTIVE_LABEL_REFRESH_DELAY)
\r
3433 delay = DEFAULT_CONSECUTIVE_LABEL_REFRESH_DELAY - elapsed;
\r
3434 //System.out.println("scheduling with delay: " + delay + " (" + lastLabelRefreshScheduled + " -> " + now + " = " + elapsed + ")");
\r
3436 ThreadUtils.getNonBlockingWorkExecutor().schedule(new Runnable() {
\r
3438 public void run() {
\r
3439 scheduleImmediateLabelRefresh();
\r
3441 }, delay, TimeUnit.MILLISECONDS);
\r
3443 scheduleImmediateLabelRefresh();
\r
3445 lastLabelRefreshScheduled = now;
\r
3452 public boolean columnsModified(final NodeContext context, final Map<String, String> columns) {
\r
3453 System.out.println("TODO: implement GraphExplorerImpl.labelListener.columnsModified");
\r
3458 private void scheduleImmediateLabelRefresh() {
\r
3459 Runnable[] runnables = null;
\r
3460 synchronized (labelRefreshRunnables) {
\r
3461 if (labelRefreshRunnables.isEmpty())
\r
3464 runnables = labelRefreshRunnables.values().toArray(new Runnable[labelRefreshRunnables.size()]);
\r
3465 labelRefreshRunnables.clear();
\r
3466 refreshIsQueued = false;
\r
3468 final Runnable[] rs = runnables;
\r
3470 if (tree.isDisposed())
\r
3472 tree.getDisplay().asyncExec(new Runnable() {
\r
3474 public void run() {
\r
3475 if (tree.isDisposed())
\r
3477 //System.out.println(System.currentTimeMillis() + " EXECUTING " + rs.length + " label refresh runnables");
\r
3478 tree.setRedraw(false);
\r
3479 for (Runnable r : rs) {
\r
3482 tree.setRedraw(true);
\r
3487 long lastLabelRefreshScheduled = 0;
\r
3488 boolean refreshIsQueued = false;
\r
3489 Map<NodeContext, Runnable> labelRefreshRunnables = new HashMap<NodeContext, Runnable>();
\r
3491 @SuppressWarnings("unchecked")
\r
3493 public <T> T getAdapter(Class<T> adapter) {
\r
3494 if(ISelectionProvider.class == adapter) return (T) postSelectionProvider;
\r
3495 else if(IPostSelectionProvider.class == adapter) return (T) postSelectionProvider;
\r
3499 @SuppressWarnings("unchecked")
\r
3501 public <T> T getControl() {
\r
3506 * @see org.simantics.browsing.ui.GraphExplorer#setAutoExpandLevel(int)
\r
3509 public void setAutoExpandLevel(int level) {
\r
3510 this.autoExpandLevel = level;
\r
3514 public <T> NodeQueryProcessor<T> getProcessor(QueryKey<T> key) {
\r
3515 return explorerContext.getProcessor(key);
\r
3519 public <T> PrimitiveQueryProcessor<T> getPrimitiveProcessor(PrimitiveQueryKey<T> key) {
\r
3520 return explorerContext.getPrimitiveProcessor(key);
\r
3524 public boolean isEditable() {
\r
3529 public void setEditable(boolean editable) {
\r
3530 if (!thread.currentThreadAccess())
\r
3531 throw new IllegalStateException("not in SWT display thread " + thread.getThread());
\r
3533 this.editable = editable;
\r
3534 Display display = tree.getDisplay();
\r
3535 tree.setBackground(editable ? null : display.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
\r
3539 * For setting a more local service locator for the explorer than the global
\r
3540 * workbench service locator. Sometimes required to give this implementation
\r
3541 * access to local workbench services like IFocusService.
\r
3544 * Must be invoked during right after construction.
\r
3546 * @param serviceLocator
\r
3547 * a specific service locator or <code>null</code> to use the
\r
3548 * workbench global service locator
\r
3550 public void setServiceLocator(IServiceLocator serviceLocator) {
\r
3551 if (serviceLocator == null && PlatformUI.isWorkbenchRunning())
\r
3552 serviceLocator = PlatformUI.getWorkbench();
\r
3553 this.serviceLocator = serviceLocator;
\r
3554 if (serviceLocator != null) {
\r
3555 this.contextService = (IContextService) serviceLocator.getService(IContextService.class);
\r
3556 this.focusService = (IFocusService) serviceLocator.getService(IFocusService.class);
\r
3561 public Object getClicked(Object event) {
\r
3562 MouseEvent e = (MouseEvent)event;
\r
3563 final Tree tree = (Tree) e.getSource();
\r
3564 Point point = new Point(e.x, e.y);
\r
3565 TreeItem item = tree.getItem(point);
\r
3567 // No selectable item at point?
\r
3571 Object data = item.getData();
\r
Code Review / simantics / platform.git / blob