1 package org.simantics.browsing.ui.nattable;
\r
3 import java.util.ArrayList;
\r
4 import java.util.Arrays;
\r
5 import java.util.Collection;
\r
6 import java.util.Collections;
\r
7 import java.util.Deque;
\r
8 import java.util.HashMap;
\r
9 import java.util.HashSet;
\r
10 import java.util.LinkedList;
\r
11 import java.util.List;
\r
12 import java.util.Map;
\r
13 import java.util.Set;
\r
14 import java.util.WeakHashMap;
\r
15 import java.util.concurrent.CopyOnWriteArrayList;
\r
16 import java.util.concurrent.ExecutorService;
\r
17 import java.util.concurrent.ScheduledExecutorService;
\r
18 import java.util.concurrent.Semaphore;
\r
19 import java.util.concurrent.TimeUnit;
\r
20 import java.util.concurrent.atomic.AtomicBoolean;
\r
21 import java.util.concurrent.atomic.AtomicReference;
\r
22 import java.util.function.Consumer;
\r
24 import org.eclipse.core.runtime.Assert;
\r
25 import org.eclipse.core.runtime.IProgressMonitor;
\r
26 import org.eclipse.core.runtime.IStatus;
\r
27 import org.eclipse.core.runtime.MultiStatus;
\r
28 import org.eclipse.core.runtime.Platform;
\r
29 import org.eclipse.core.runtime.Status;
\r
30 import org.eclipse.core.runtime.jobs.Job;
\r
31 import org.eclipse.jface.resource.ColorDescriptor;
\r
32 import org.eclipse.jface.resource.DeviceResourceException;
\r
33 import org.eclipse.jface.resource.DeviceResourceManager;
\r
34 import org.eclipse.jface.resource.FontDescriptor;
\r
35 import org.eclipse.jface.resource.ImageDescriptor;
\r
36 import org.eclipse.jface.resource.JFaceResources;
\r
37 import org.eclipse.jface.resource.LocalResourceManager;
\r
38 import org.eclipse.jface.viewers.ColumnWeightData;
\r
39 import org.eclipse.jface.viewers.ICellEditorValidator;
\r
40 import org.eclipse.jface.viewers.IPostSelectionProvider;
\r
41 import org.eclipse.jface.viewers.ISelection;
\r
42 import org.eclipse.jface.viewers.ISelectionChangedListener;
\r
43 import org.eclipse.jface.viewers.ISelectionProvider;
\r
44 import org.eclipse.jface.viewers.SelectionChangedEvent;
\r
45 import org.eclipse.jface.viewers.StructuredSelection;
\r
46 import org.eclipse.jface.window.Window;
\r
47 import org.eclipse.nebula.widgets.nattable.NatTable;
\r
48 import org.eclipse.nebula.widgets.nattable.config.AbstractRegistryConfiguration;
\r
49 import org.eclipse.nebula.widgets.nattable.config.CellConfigAttributes;
\r
50 import org.eclipse.nebula.widgets.nattable.config.IConfigRegistry;
\r
51 import org.eclipse.nebula.widgets.nattable.config.IEditableRule;
\r
52 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
\r
53 import org.eclipse.nebula.widgets.nattable.data.IDataProvider;
\r
54 import org.eclipse.nebula.widgets.nattable.data.ListDataProvider;
\r
55 import org.eclipse.nebula.widgets.nattable.data.convert.DefaultDisplayConverter;
\r
56 import org.eclipse.nebula.widgets.nattable.data.validate.IDataValidator;
\r
57 import org.eclipse.nebula.widgets.nattable.data.validate.ValidationFailedException;
\r
58 import org.eclipse.nebula.widgets.nattable.edit.EditConfigAttributes;
\r
59 import org.eclipse.nebula.widgets.nattable.edit.EditConfigHelper;
\r
60 import org.eclipse.nebula.widgets.nattable.edit.ICellEditHandler;
\r
61 import org.eclipse.nebula.widgets.nattable.edit.config.DefaultEditConfiguration;
\r
62 import org.eclipse.nebula.widgets.nattable.edit.config.DialogErrorHandling;
\r
63 import org.eclipse.nebula.widgets.nattable.edit.editor.AbstractCellEditor;
\r
64 import org.eclipse.nebula.widgets.nattable.edit.editor.ComboBoxCellEditor;
\r
65 import org.eclipse.nebula.widgets.nattable.edit.editor.ICellEditor;
\r
66 import org.eclipse.nebula.widgets.nattable.edit.editor.IEditErrorHandler;
\r
67 import org.eclipse.nebula.widgets.nattable.edit.editor.TextCellEditor;
\r
68 import org.eclipse.nebula.widgets.nattable.edit.gui.AbstractDialogCellEditor;
\r
69 import org.eclipse.nebula.widgets.nattable.grid.GridRegion;
\r
70 import org.eclipse.nebula.widgets.nattable.grid.cell.AlternatingRowConfigLabelAccumulator;
\r
71 import org.eclipse.nebula.widgets.nattable.grid.data.DefaultCornerDataProvider;
\r
72 import org.eclipse.nebula.widgets.nattable.grid.data.DefaultRowHeaderDataProvider;
\r
73 import org.eclipse.nebula.widgets.nattable.grid.layer.ColumnHeaderLayer;
\r
74 import org.eclipse.nebula.widgets.nattable.grid.layer.CornerLayer;
\r
75 import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultColumnHeaderDataLayer;
\r
76 import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultRowHeaderDataLayer;
\r
77 import org.eclipse.nebula.widgets.nattable.grid.layer.GridLayer;
\r
78 import org.eclipse.nebula.widgets.nattable.grid.layer.RowHeaderLayer;
\r
79 import org.eclipse.nebula.widgets.nattable.hideshow.ColumnHideShowLayer;
\r
80 import org.eclipse.nebula.widgets.nattable.hideshow.event.HideRowPositionsEvent;
\r
81 import org.eclipse.nebula.widgets.nattable.hideshow.event.ShowRowPositionsEvent;
\r
82 import org.eclipse.nebula.widgets.nattable.layer.DataLayer;
\r
83 import org.eclipse.nebula.widgets.nattable.layer.ILayerListener;
\r
84 import org.eclipse.nebula.widgets.nattable.layer.LabelStack;
\r
85 import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnOverrideLabelAccumulator;
\r
86 import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
\r
87 import org.eclipse.nebula.widgets.nattable.layer.event.ILayerEvent;
\r
88 import org.eclipse.nebula.widgets.nattable.painter.NatTableBorderOverlayPainter;
\r
89 import org.eclipse.nebula.widgets.nattable.reorder.ColumnReorderLayer;
\r
90 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
\r
91 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer.MoveDirectionEnum;
\r
92 import org.eclipse.nebula.widgets.nattable.selection.command.SelectCellCommand;
\r
93 import org.eclipse.nebula.widgets.nattable.sort.config.SingleClickSortConfiguration;
\r
94 import org.eclipse.nebula.widgets.nattable.style.CellStyleAttributes;
\r
95 import org.eclipse.nebula.widgets.nattable.style.DisplayMode;
\r
96 import org.eclipse.nebula.widgets.nattable.style.Style;
\r
97 import org.eclipse.nebula.widgets.nattable.ui.menu.AbstractHeaderMenuConfiguration;
\r
98 import org.eclipse.nebula.widgets.nattable.ui.menu.PopupMenuBuilder;
\r
99 import org.eclipse.nebula.widgets.nattable.util.GUIHelper;
\r
100 import org.eclipse.nebula.widgets.nattable.viewport.ViewportLayer;
\r
101 import org.eclipse.nebula.widgets.nattable.widget.EditModeEnum;
\r
102 import org.eclipse.swt.SWT;
\r
103 import org.eclipse.swt.events.DisposeEvent;
\r
104 import org.eclipse.swt.events.DisposeListener;
\r
105 import org.eclipse.swt.events.FocusEvent;
\r
106 import org.eclipse.swt.events.FocusListener;
\r
107 import org.eclipse.swt.events.KeyEvent;
\r
108 import org.eclipse.swt.events.KeyListener;
\r
109 import org.eclipse.swt.events.MouseEvent;
\r
110 import org.eclipse.swt.events.MouseListener;
\r
111 import org.eclipse.swt.events.SelectionListener;
\r
112 import org.eclipse.swt.graphics.Color;
\r
113 import org.eclipse.swt.graphics.Point;
\r
114 import org.eclipse.swt.graphics.RGB;
\r
115 import org.eclipse.swt.graphics.Rectangle;
\r
116 import org.eclipse.swt.widgets.Composite;
\r
117 import org.eclipse.swt.widgets.Control;
\r
118 import org.eclipse.swt.widgets.Display;
\r
119 import org.eclipse.swt.widgets.Event;
\r
120 import org.eclipse.swt.widgets.Listener;
\r
121 import org.eclipse.swt.widgets.ScrollBar;
\r
122 import org.eclipse.ui.PlatformUI;
\r
123 import org.eclipse.ui.contexts.IContextActivation;
\r
124 import org.eclipse.ui.contexts.IContextService;
\r
125 import org.eclipse.ui.services.IServiceLocator;
\r
126 import org.eclipse.ui.swt.IFocusService;
\r
127 import org.simantics.browsing.ui.BuiltinKeys;
\r
128 import org.simantics.browsing.ui.Column;
\r
129 import org.simantics.browsing.ui.Column.Align;
\r
130 import org.simantics.browsing.ui.DataSource;
\r
131 import org.simantics.browsing.ui.ExplorerState;
\r
132 import org.simantics.browsing.ui.GraphExplorer;
\r
133 import org.simantics.browsing.ui.NodeContext;
\r
134 import org.simantics.browsing.ui.NodeContext.CacheKey;
\r
135 import org.simantics.browsing.ui.NodeContext.PrimitiveQueryKey;
\r
136 import org.simantics.browsing.ui.NodeContext.QueryKey;
\r
137 import org.simantics.browsing.ui.NodeQueryManager;
\r
138 import org.simantics.browsing.ui.NodeQueryProcessor;
\r
139 import org.simantics.browsing.ui.PrimitiveQueryProcessor;
\r
140 import org.simantics.browsing.ui.PrimitiveQueryUpdater;
\r
141 import org.simantics.browsing.ui.SelectionDataResolver;
\r
142 import org.simantics.browsing.ui.SelectionFilter;
\r
143 import org.simantics.browsing.ui.StatePersistor;
\r
144 import org.simantics.browsing.ui.common.ColumnKeys;
\r
145 import org.simantics.browsing.ui.common.ErrorLogger;
\r
146 import org.simantics.browsing.ui.common.NodeContextBuilder;
\r
147 import org.simantics.browsing.ui.common.NodeContextUtil;
\r
148 import org.simantics.browsing.ui.common.internal.GENodeQueryManager;
\r
149 import org.simantics.browsing.ui.common.internal.IGECache;
\r
150 import org.simantics.browsing.ui.common.internal.IGraphExplorerContext;
\r
151 import org.simantics.browsing.ui.common.internal.UIElementReference;
\r
152 import org.simantics.browsing.ui.common.processors.AbstractPrimitiveQueryProcessor;
\r
153 import org.simantics.browsing.ui.common.processors.DefaultCheckedStateProcessor;
\r
154 import org.simantics.browsing.ui.common.processors.DefaultComparableChildrenProcessor;
\r
155 import org.simantics.browsing.ui.common.processors.DefaultFinalChildrenProcessor;
\r
156 import org.simantics.browsing.ui.common.processors.DefaultImageDecoratorProcessor;
\r
157 import org.simantics.browsing.ui.common.processors.DefaultImagerFactoriesProcessor;
\r
158 import org.simantics.browsing.ui.common.processors.DefaultImagerProcessor;
\r
159 import org.simantics.browsing.ui.common.processors.DefaultLabelDecoratorProcessor;
\r
160 import org.simantics.browsing.ui.common.processors.DefaultLabelerFactoriesProcessor;
\r
161 import org.simantics.browsing.ui.common.processors.DefaultLabelerProcessor;
\r
162 import org.simantics.browsing.ui.common.processors.DefaultPrunedChildrenProcessor;
\r
163 import org.simantics.browsing.ui.common.processors.DefaultSelectedImageDecoratorFactoriesProcessor;
\r
164 import org.simantics.browsing.ui.common.processors.DefaultSelectedLabelDecoratorFactoriesProcessor;
\r
165 import org.simantics.browsing.ui.common.processors.DefaultSelectedLabelerProcessor;
\r
166 import org.simantics.browsing.ui.common.processors.DefaultSelectedViewpointFactoryProcessor;
\r
167 import org.simantics.browsing.ui.common.processors.DefaultSelectedViewpointProcessor;
\r
168 import org.simantics.browsing.ui.common.processors.DefaultViewpointContributionProcessor;
\r
169 import org.simantics.browsing.ui.common.processors.DefaultViewpointContributionsProcessor;
\r
170 import org.simantics.browsing.ui.common.processors.DefaultViewpointProcessor;
\r
171 import org.simantics.browsing.ui.common.processors.IsExpandedProcessor;
\r
172 import org.simantics.browsing.ui.common.processors.NoSelectionRequestProcessor;
\r
173 import org.simantics.browsing.ui.common.processors.ProcessorLifecycle;
\r
174 import org.simantics.browsing.ui.content.Labeler;
\r
175 import org.simantics.browsing.ui.content.Labeler.CustomModifier;
\r
176 import org.simantics.browsing.ui.content.Labeler.DialogModifier;
\r
177 import org.simantics.browsing.ui.content.Labeler.EnumerationModifier;
\r
178 import org.simantics.browsing.ui.content.Labeler.Modifier;
\r
179 import org.simantics.browsing.ui.nattable.override.DefaultTreeLayerConfiguration2;
\r
180 import org.simantics.browsing.ui.swt.Activator;
\r
181 import org.simantics.browsing.ui.swt.AdaptableHintContext;
\r
182 import org.simantics.browsing.ui.swt.DefaultImageDecoratorsProcessor;
\r
183 import org.simantics.browsing.ui.swt.DefaultIsExpandedProcessor;
\r
184 import org.simantics.browsing.ui.swt.DefaultLabelDecoratorsProcessor;
\r
185 import org.simantics.browsing.ui.swt.DefaultSelectedImagerProcessor;
\r
186 import org.simantics.browsing.ui.swt.DefaultShowMaxChildrenProcessor;
\r
187 import org.simantics.browsing.ui.swt.GraphExplorerImplBase;
\r
188 import org.simantics.browsing.ui.swt.ImageLoaderJob;
\r
189 import org.simantics.browsing.ui.swt.ViewerCellReference;
\r
190 import org.simantics.browsing.ui.swt.ViewerRowReference;
\r
191 import org.simantics.browsing.ui.swt.internal.Threads;
\r
192 import org.simantics.db.layer0.SelectionHints;
\r
193 import org.simantics.utils.datastructures.BinaryFunction;
\r
194 import org.simantics.utils.datastructures.MapList;
\r
195 import org.simantics.utils.datastructures.disposable.AbstractDisposable;
\r
196 import org.simantics.utils.datastructures.hints.IHintContext;
\r
197 import org.simantics.utils.threads.IThreadWorkQueue;
\r
198 import org.simantics.utils.threads.SWTThread;
\r
199 import org.simantics.utils.threads.ThreadUtils;
\r
200 import org.simantics.utils.ui.AdaptionUtils;
\r
201 import org.simantics.utils.ui.ISelectionUtils;
\r
202 import org.simantics.utils.ui.jface.BasePostSelectionProvider;
\r
204 import gnu.trove.map.hash.THashMap;
\r
205 import gnu.trove.map.hash.TObjectIntHashMap;
\r
208 * NatTable based GraphExplorer
\r
210 * This GraphExplorer is not fully compatible with the other implementations, since it is not based on SWT.Tree.
\r
212 * This implementation is useful in scenarios, where there are a lot of data to be displayed, the performance of NatTable is much better to SWT.Tree based implementations.
\r
215 * TODO: ability to hide headers
\r
216 * TODO: code cleanup (copied from GraphExplorerImpl2)
\r
218 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
\r
221 public class NatTableGraphExplorer extends GraphExplorerImplBase implements GraphExplorer{
\r
222 public static final int DEFAULT_MAX_CHILDREN = 10000;
\r
223 private static final boolean DEBUG_SELECTION_LISTENERS = false;
\r
224 private static final boolean DEBUG = false;
\r
226 private Composite composite;
\r
227 private NatTable natTable;
\r
229 private GETreeLayer treeLayer;
\r
230 private DataLayer dataLayer;
\r
231 private ViewportLayer viewportLayer;
\r
232 private SelectionLayer selectionLayer;
\r
233 private GEColumnHeaderDataProvider columnHeaderDataProvider;
\r
234 private GEColumnAccessor columnAccessor;
\r
235 private DefaultRowHeaderDataLayer rowHeaderDataLayer;
\r
236 private DataLayer columnHeaderDataLayer;
\r
237 private DataLayer cornerDataLayer;
\r
239 private List<TreeNode> list = new ArrayList<>();
\r
241 private NatTableSelectionAdaptor selectionAdaptor;
\r
242 private NatTableColumnLayout layout;
\r
244 LocalResourceManager localResourceManager;
\r
245 DeviceResourceManager resourceManager;
\r
248 private IThreadWorkQueue thread;
\r
250 @SuppressWarnings({ "rawtypes" })
\r
251 final HashMap<CacheKey<?>, NodeQueryProcessor> processors = new HashMap<CacheKey<?>, NodeQueryProcessor>();
\r
252 @SuppressWarnings({ "rawtypes" })
\r
253 final HashMap<Object, PrimitiveQueryProcessor> primitiveProcessors = new HashMap<Object, PrimitiveQueryProcessor>();
\r
254 @SuppressWarnings({ "rawtypes" })
\r
255 final HashMap<Class, DataSource> dataSources = new HashMap<Class, DataSource>();
\r
257 FontDescriptor originalFont;
\r
258 protected ColorDescriptor originalForeground;
\r
259 protected ColorDescriptor originalBackground;
\r
260 private Color invalidModificationColor;
\r
262 private Column[] columns;
\r
263 private Map<String,Integer> columnKeyToIndex;
\r
264 private boolean columnsAreVisible = true;
\r
266 private NodeContext rootContext;
\r
267 private TreeNode rootNode;
\r
268 private StatePersistor persistor = null;
\r
270 private boolean editable = true;
\r
272 private boolean disposed = false;
\r
274 private final CopyOnWriteArrayList<FocusListener> focusListeners = new CopyOnWriteArrayList<FocusListener>();
\r
275 private final CopyOnWriteArrayList<MouseListener> mouseListeners = new CopyOnWriteArrayList<MouseListener>();
\r
276 private final CopyOnWriteArrayList<KeyListener> keyListeners = new CopyOnWriteArrayList<KeyListener>();
\r
278 private int autoExpandLevel = 0;
\r
279 private IServiceLocator serviceLocator;
\r
280 private IContextService contextService = null;
\r
281 private IFocusService focusService = null;
\r
282 private IContextActivation editingContext = null;
\r
284 GeViewerContext explorerContext = new GeViewerContext(this);
\r
286 private GraphExplorerPostSelectionProvider postSelectionProvider = new GraphExplorerPostSelectionProvider(this);
\r
287 private BasePostSelectionProvider selectionProvider = new BasePostSelectionProvider();
\r
288 private SelectionDataResolver selectionDataResolver;
\r
289 private SelectionFilter selectionFilter;
\r
291 private MapList<NodeContext, TreeNode> contextToNodeMap;
\r
293 private ModificationContext modificationContext = null;
\r
295 private boolean filterSelectionEdit = true;
\r
297 private boolean expand;
\r
298 private boolean verticalBarVisible = false;
\r
300 private BinaryFunction<Object[], GraphExplorer, Object[]> selectionTransformation = new BinaryFunction<Object[], GraphExplorer, Object[]>() {
\r
303 public Object[] call(GraphExplorer explorer, Object[] objects) {
\r
304 Object[] result = new Object[objects.length];
\r
305 for (int i = 0; i < objects.length; i++) {
\r
306 IHintContext context = new AdaptableHintContext(SelectionHints.KEY_MAIN);
\r
307 context.setHint(SelectionHints.KEY_MAIN, objects[i]);
\r
308 result[i] = context;
\r
315 static class TransientStateImpl implements TransientExplorerState {
\r
317 private Integer activeColumn = null;
\r
320 public synchronized Integer getActiveColumn() {
\r
321 return activeColumn;
\r
324 public synchronized void setActiveColumn(Integer column) {
\r
325 activeColumn = column;
\r
330 private TransientStateImpl transientState = new TransientStateImpl();
\r
332 public NatTableGraphExplorer(Composite parent) {
\r
333 this(parent, SWT.BORDER | SWT.MULTI );
\r
336 public NatTableGraphExplorer(Composite parent, int style) {
\r
337 this.composite = parent;
\r
340 this.localResourceManager = new LocalResourceManager(JFaceResources.getResources());
\r
341 this.resourceManager = new DeviceResourceManager(parent.getDisplay());
\r
343 this.imageLoaderJob = new ImageLoaderJob(this);
\r
344 this.imageLoaderJob.setPriority(Job.DECORATE);
\r
345 contextToNodeMap = new MapList<NodeContext, TreeNode>();
\r
347 invalidModificationColor = (Color) localResourceManager.get(ColorDescriptor.createFrom(new RGB(255, 128, 128)));
\r
349 this.thread = SWTThread.getThreadAccess(parent);
\r
351 for (int i = 0; i < 10; i++)
\r
352 explorerContext.activity.push(0);
\r
354 originalFont = JFaceResources.getDefaultFontDescriptor();
\r
356 columns = new Column[0];
\r
357 createNatTable(style);
\r
358 layout = new NatTableColumnLayout(natTable, columnHeaderDataProvider, rowHeaderDataLayer);
\r
359 this.composite.setLayout(layout);
\r
361 setBasicListeners();
\r
362 setDefaultProcessors();
\r
364 natTable.addDisposeListener(new DisposeListener() {
\r
367 public void widgetDisposed(DisposeEvent e) {
\r
373 Listener listener = new Listener() {
\r
376 public void handleEvent(Event event) {
\r
378 switch (event.type) {
\r
387 case SWT.Deactivate:
\r
394 natTable.addListener(SWT.Activate, listener);
\r
395 natTable.addListener(SWT.Deactivate, listener);
\r
396 natTable.addListener(SWT.Show, listener);
\r
397 natTable.addListener(SWT.Hide, listener);
\r
398 natTable.addListener(SWT.Paint,listener);
\r
400 setColumns( new Column[] { new Column(ColumnKeys.SINGLE) });
\r
404 private long focusGainedAt = 0L;
\r
405 private boolean visible = false;
\r
406 private Collection<TreeNode> selectedNodes = new ArrayList<TreeNode>();
\r
408 protected void setBasicListeners() {
\r
410 natTable.addFocusListener(new FocusListener() {
\r
412 public void focusGained(FocusEvent e) {
\r
413 focusGainedAt = ((long) e.time) & 0xFFFFFFFFL;
\r
414 for (FocusListener listener : focusListeners)
\r
415 listener.focusGained(e);
\r
418 public void focusLost(FocusEvent e) {
\r
419 for (FocusListener listener : focusListeners)
\r
420 listener.focusLost(e);
\r
423 natTable.addMouseListener(new MouseListener() {
\r
425 public void mouseDoubleClick(MouseEvent e) {
\r
426 for (MouseListener listener : mouseListeners) {
\r
427 listener.mouseDoubleClick(e);
\r
431 public void mouseDown(MouseEvent e) {
\r
432 for (MouseListener listener : mouseListeners) {
\r
433 listener.mouseDown(e);
\r
437 public void mouseUp(MouseEvent e) {
\r
438 for (MouseListener listener : mouseListeners) {
\r
439 listener.mouseUp(e);
\r
443 natTable.addKeyListener(new KeyListener() {
\r
445 public void keyPressed(KeyEvent e) {
\r
446 for (KeyListener listener : keyListeners) {
\r
447 listener.keyPressed(e);
\r
451 public void keyReleased(KeyEvent e) {
\r
452 for (KeyListener listener : keyListeners) {
\r
453 listener.keyReleased(e);
\r
458 selectionAdaptor.addSelectionChangedListener(new ISelectionChangedListener() {
\r
461 public void selectionChanged(SelectionChangedEvent event) {
\r
462 //System.out.println("GraphExplorerImpl2.fireSelection");
\r
463 selectedNodes = AdaptionUtils.adaptToCollection(event.getSelection(), TreeNode.class);
\r
464 Collection<NodeContext> selectedContexts = AdaptionUtils.adaptToCollection(event.getSelection(), NodeContext.class);
\r
465 selectionProvider.setAndFireSelection(constructSelection(selectedContexts.toArray(new NodeContext[selectedContexts.size()])));
\r
469 selectionAdaptor.addPostSelectionChangedListener(new ISelectionChangedListener() {
\r
472 public void selectionChanged(SelectionChangedEvent event) {
\r
473 //System.out.println("GraphExplorerImpl2.firePostSelection");
\r
474 Collection<NodeContext> selectedContexts = AdaptionUtils.adaptToCollection(event.getSelection(), NodeContext.class);
\r
475 selectionProvider.firePostSelection(constructSelection(selectedContexts.toArray(new NodeContext[selectedContexts.size()])));
\r
482 private NodeContext pendingRoot;
\r
484 private void activate() {
\r
485 if (pendingRoot != null && !expand) {
\r
486 doSetRoot(pendingRoot);
\r
487 pendingRoot = null;
\r
492 * Invoke only from SWT thread to reset the root of the graph explorer tree.
\r
496 private void doSetRoot(NodeContext root) {
\r
497 Display display = composite.getDisplay();
\r
498 if (display.getThread() != Thread.currentThread()) {
\r
499 throw new RuntimeException("Invoke from SWT thread only");
\r
501 // System.out.println("doSetRoot " + root);
\r
504 if (natTable.isDisposed())
\r
506 if (root.getConstant(BuiltinKeys.INPUT) == null) {
\r
507 ErrorLogger.defaultLogError("root node context does not contain BuiltinKeys.INPUT key. Node = " + root, new Exception("trace"));
\r
513 // Empty caches, release queries.
\r
514 if (rootNode != null) {
\r
515 rootNode.dispose();
\r
517 GeViewerContext oldContext = explorerContext;
\r
518 GeViewerContext newContext = new GeViewerContext(this);
\r
519 this.explorerContext = newContext;
\r
520 oldContext.safeDispose();
\r
522 // Need to empty these or otherwise they won't be emptied until the
\r
523 // explorer is disposed which would mean that many unwanted references
\r
524 // will be held by this map.
\r
525 clearPrimitiveProcessors();
\r
527 this.rootContext = root.getConstant(BuiltinKeys.IS_ROOT) != null ? root
\r
528 : NodeContextUtil.withConstant(root, BuiltinKeys.IS_ROOT, Boolean.TRUE);
\r
530 explorerContext.getCache().incRef(this.rootContext);
\r
535 select(rootContext);
\r
536 //refreshColumnSizes();
\r
537 rootNode = new TreeNode(rootContext, explorerContext);
\r
538 if (DEBUG) System.out.println("setRoot " + rootNode);
\r
540 // Delay content reading.
\r
542 // This is required for cases when GEImpl2 is attached to selection view. Reading content
\r
543 // instantly could stagnate SWT thread under rapid changes in selection. By delaying the
\r
544 // content reading we give the system a change to dispose the GEImpl2 before the content is read.
\r
545 display.asyncExec(new Runnable() {
\r
548 public void run() {
\r
549 if (rootNode != null) {
\r
550 rootNode.updateChildren();
\r
551 rootNode.setExpanded(true);
\r
559 private synchronized void listReIndex() {
\r
560 for (TreeNode n : list) {
\r
561 n.setListIndex(-2);
\r
564 for (TreeNode c : rootNode.getChildren())
\r
566 natTable.refresh();
\r
569 private void _insertToList(TreeNode n) {
\r
570 n.setListIndex(list.size());
\r
572 for (TreeNode c : n.getChildren()) {
\r
577 public List<TreeNode> getItems() {
\r
578 return Collections.unmodifiableList(list);
\r
581 private void initializeState() {
\r
582 if (persistor == null)
\r
585 ExplorerState state = persistor.deserialize(
\r
586 Platform.getStateLocation(Activator.getDefault().getBundle()).toFile(),
\r
590 Object processor = getPrimitiveProcessor(BuiltinKeys.IS_EXPANDED);
\r
591 if (processor instanceof DefaultIsExpandedProcessor) {
\r
592 DefaultIsExpandedProcessor isExpandedProcessor = (DefaultIsExpandedProcessor)processor;
\r
593 for(NodeContext expanded : state.expandedNodes) {
\r
594 isExpandedProcessor.setExpanded(expanded, true);
\r
600 public NodeContext getRoot() {
\r
601 return rootContext;
\r
605 public IThreadWorkQueue getThread() {
\r
610 public NodeContext getParentContext(NodeContext context) {
\r
612 throw new IllegalStateException("disposed");
\r
613 if (!thread.currentThreadAccess())
\r
614 throw new IllegalStateException("not in SWT display thread " + thread.getThread());
\r
616 List<TreeNode> nodes = contextToNodeMap.getValuesUnsafe(context);
\r
617 for (int i = 0; i < nodes.size(); i++) {
\r
618 if (nodes.get(i).getParent() != null)
\r
619 return nodes.get(i).getParent().getContext();
\r
626 @SuppressWarnings("unchecked")
\r
628 public <T> T getAdapter(Class<T> adapter) {
\r
629 if(ISelectionProvider.class == adapter) return (T) postSelectionProvider;
\r
630 else if(IPostSelectionProvider.class == adapter) return (T) postSelectionProvider;
\r
635 protected void setDefaultProcessors() {
\r
636 // Add a simple IMAGER query processor that always returns null.
\r
637 // With this processor no images will ever be shown.
\r
638 // setPrimitiveProcessor(new StaticImagerProcessor(null));
\r
640 setProcessor(new DefaultComparableChildrenProcessor());
\r
641 setProcessor(new DefaultLabelDecoratorsProcessor());
\r
642 setProcessor(new DefaultImageDecoratorsProcessor());
\r
643 setProcessor(new DefaultSelectedLabelerProcessor());
\r
644 setProcessor(new DefaultLabelerFactoriesProcessor());
\r
645 setProcessor(new DefaultSelectedImagerProcessor());
\r
646 setProcessor(new DefaultImagerFactoriesProcessor());
\r
647 setPrimitiveProcessor(new DefaultLabelerProcessor());
\r
648 setPrimitiveProcessor(new DefaultCheckedStateProcessor());
\r
649 setPrimitiveProcessor(new DefaultImagerProcessor());
\r
650 setPrimitiveProcessor(new DefaultLabelDecoratorProcessor());
\r
651 setPrimitiveProcessor(new DefaultImageDecoratorProcessor());
\r
652 setPrimitiveProcessor(new NoSelectionRequestProcessor());
\r
654 setProcessor(new DefaultFinalChildrenProcessor(this));
\r
656 setProcessor(new DefaultPrunedChildrenProcessor());
\r
657 setProcessor(new DefaultSelectedViewpointProcessor());
\r
658 setProcessor(new DefaultSelectedLabelDecoratorFactoriesProcessor());
\r
659 setProcessor(new DefaultSelectedImageDecoratorFactoriesProcessor());
\r
660 setProcessor(new DefaultViewpointContributionsProcessor());
\r
662 setPrimitiveProcessor(new DefaultViewpointProcessor());
\r
663 setPrimitiveProcessor(new DefaultViewpointContributionProcessor());
\r
664 setPrimitiveProcessor(new DefaultSelectedViewpointFactoryProcessor());
\r
665 setPrimitiveProcessor(new TreeNodeIsExpandedProcessor());
\r
666 setPrimitiveProcessor(new DefaultShowMaxChildrenProcessor());
\r
670 public Column[] getColumns() {
\r
671 return Arrays.copyOf(columns, columns.length);
\r
675 public void setColumnsVisible(boolean visible) {
\r
676 columnsAreVisible = visible;
\r
677 //FIXME if(natTable != null) this.columnHeaderDataLayer.setHeaderVisible(columnsAreVisible);
\r
681 public void setColumns(final Column[] columns) {
\r
682 setColumns(columns, null);
\r
686 public void setColumns(final Column[] columns, Consumer<Map<Column, Object>> callback) {
\r
687 assertNotDisposed();
\r
688 checkUniqueColumnKeys(columns);
\r
690 Display d = composite.getDisplay();
\r
691 if (d.getThread() == Thread.currentThread()) {
\r
692 doSetColumns(columns, callback);
\r
693 natTable.refresh(true);
\r
695 d.asyncExec(new Runnable() {
\r
697 public void run() {
\r
698 if (natTable == null)
\r
700 if (natTable.isDisposed())
\r
702 doSetColumns(columns, callback);
\r
703 natTable.refresh();
\r
704 natTable.getParent().layout();
\r
709 private void checkUniqueColumnKeys(Column[] cols) {
\r
710 Set<String> usedColumnKeys = new HashSet<String>();
\r
711 List<Column> duplicateColumns = new ArrayList<Column>();
\r
712 for (Column c : cols) {
\r
713 if (!usedColumnKeys.add(c.getKey()))
\r
714 duplicateColumns.add(c);
\r
716 if (!duplicateColumns.isEmpty()) {
\r
717 throw new IllegalArgumentException("All columns do not have unique keys: " + cols + ", overlapping: " + duplicateColumns);
\r
721 private void doSetColumns(Column[] cols, Consumer<Map<Column, Object>> callback) {
\r
723 HashMap<String, Integer> keyToIndex = new HashMap<String, Integer>();
\r
724 for (int i = 0; i < cols.length; ++i) {
\r
725 keyToIndex.put(cols[i].getKey(), i);
\r
728 this.columns = Arrays.copyOf(cols, cols.length);
\r
729 //this.columns[cols.length] = FILLER_COLUMN;
\r
730 this.columnKeyToIndex = keyToIndex;
\r
732 columnHeaderDataProvider.updateColumnSizes();
\r
734 Map<Column, Object> map = new HashMap<Column, Object>();
\r
736 // FIXME : temporary workaround for ModelBrowser.
\r
737 // natTable.setHeaderVisible(columns.length == 1 ? false : columnsAreVisible);
\r
739 int columnIndex = 0;
\r
741 for (Column column : columns) {
\r
742 int width = column.getWidth();
\r
743 if(column.hasGrab()) {
\r
746 layout.setColumnData(columnIndex, new ColumnWeightData(column.getWeight(), width));
\r
751 layout.setColumnData(columnIndex, new ColumnWeightData(columns.length > 1 ? 0 : 1, width));
\r
759 if(callback != null) callback.accept(map);
\r
762 int toSWT(Align alignment) {
\r
763 switch (alignment) {
\r
764 case LEFT: return SWT.LEFT;
\r
765 case CENTER: return SWT.CENTER;
\r
766 case RIGHT: return SWT.RIGHT;
\r
767 default: throw new Error("unhandled alignment: " + alignment);
\r
772 public <T> void setProcessor(NodeQueryProcessor<T> processor) {
\r
773 assertNotDisposed();
\r
774 if (processor == null)
\r
775 throw new IllegalArgumentException("null processor");
\r
777 processors.put(processor.getIdentifier(), processor);
\r
781 public <T> void setPrimitiveProcessor(PrimitiveQueryProcessor<T> processor) {
\r
782 assertNotDisposed();
\r
783 if (processor == null)
\r
784 throw new IllegalArgumentException("null processor");
\r
786 PrimitiveQueryProcessor<?> oldProcessor = primitiveProcessors.put(
\r
787 processor.getIdentifier(), processor);
\r
789 if (oldProcessor instanceof ProcessorLifecycle)
\r
790 ((ProcessorLifecycle) oldProcessor).detached(this);
\r
791 if (processor instanceof ProcessorLifecycle)
\r
792 ((ProcessorLifecycle) processor).attached(this);
\r
796 public <T> void setDataSource(DataSource<T> provider) {
\r
797 assertNotDisposed();
\r
798 if (provider == null)
\r
799 throw new IllegalArgumentException("null provider");
\r
800 dataSources.put(provider.getProvidedClass(), provider);
\r
803 @SuppressWarnings("unchecked")
\r
805 public <T> DataSource<T> removeDataSource(Class<T> forProvidedClass) {
\r
806 assertNotDisposed();
\r
807 if (forProvidedClass == null)
\r
808 throw new IllegalArgumentException("null class");
\r
809 return dataSources.remove(forProvidedClass);
\r
813 public void setPersistor(StatePersistor persistor) {
\r
814 this.persistor = persistor;
\r
818 public SelectionDataResolver getSelectionDataResolver() {
\r
819 return selectionDataResolver;
\r
823 public void setSelectionDataResolver(SelectionDataResolver r) {
\r
824 this.selectionDataResolver = r;
\r
828 public SelectionFilter getSelectionFilter() {
\r
829 return selectionFilter;
\r
833 public void setSelectionFilter(SelectionFilter f) {
\r
834 this.selectionFilter = f;
\r
835 // TODO: re-filter current selection?
\r
838 protected ISelection constructSelection(NodeContext... contexts) {
\r
839 if (contexts == null)
\r
840 throw new IllegalArgumentException("null contexts");
\r
841 if (contexts.length == 0)
\r
842 return StructuredSelection.EMPTY;
\r
843 if (selectionFilter == null)
\r
844 return new StructuredSelection(transformSelection(contexts));
\r
845 return new StructuredSelection( transformSelection(filter(selectionFilter, contexts)) );
\r
848 protected Object[] transformSelection(Object[] objects) {
\r
849 return selectionTransformation.call(this, objects);
\r
852 protected static Object[] filter(SelectionFilter filter, NodeContext[] contexts) {
\r
853 int len = contexts.length;
\r
854 Object[] objects = new Object[len];
\r
855 for (int i = 0; i < len; ++i)
\r
856 objects[i] = filter.filter(contexts[i]);
\r
861 public void setSelectionTransformation(
\r
862 BinaryFunction<Object[], GraphExplorer, Object[]> f) {
\r
863 this.selectionTransformation = f;
\r
866 public ISelection getWidgetSelection() {
\r
867 return selectionAdaptor.getSelection();
\r
871 public <T> void addListener(T listener) {
\r
872 if (listener instanceof FocusListener) {
\r
873 focusListeners.add((FocusListener) listener);
\r
874 } else if (listener instanceof MouseListener) {
\r
875 mouseListeners.add((MouseListener) listener);
\r
876 } else if (listener instanceof KeyListener) {
\r
877 keyListeners.add((KeyListener) listener);
\r
882 public <T> void removeListener(T listener) {
\r
883 if (listener instanceof FocusListener) {
\r
884 focusListeners.remove(listener);
\r
885 } else if (listener instanceof MouseListener) {
\r
886 mouseListeners.remove(listener);
\r
887 } else if (listener instanceof KeyListener) {
\r
888 keyListeners.remove(listener);
\r
892 public void addSelectionListener(SelectionListener listener) {
\r
893 selectionAdaptor.addSelectionListener(listener);
\r
896 public void removeSelectionListener(SelectionListener listener) {
\r
897 selectionAdaptor.removeSelectionListener(listener);
\r
900 private Set<String> uiContexts;
\r
903 public void setUIContexts(Set<String> contexts) {
\r
904 this.uiContexts = contexts;
\r
908 public void setRoot(final Object root) {
\r
909 if(uiContexts != null && uiContexts.size() == 1)
\r
910 setRootContext0(NodeContextBuilder.buildWithData(BuiltinKeys.INPUT, root, BuiltinKeys.UI_CONTEXT, uiContexts.iterator().next()));
\r
912 setRootContext0(NodeContextBuilder.buildWithData(BuiltinKeys.INPUT, root));
\r
916 public void setRootContext(final NodeContext context) {
\r
917 setRootContext0(context);
\r
920 private void setRoot(NodeContext context) {
\r
922 pendingRoot = context;
\r
923 Display.getDefault().asyncExec(new Runnable() {
\r
925 public void run() {
\r
926 if (natTable!= null && !natTable.isDisposed())
\r
932 doSetRoot(context);
\r
935 private void setRootContext0(final NodeContext context) {
\r
936 Assert.isNotNull(context, "root must not be null");
\r
937 if (isDisposed() || natTable.isDisposed())
\r
939 Display display = natTable.getDisplay();
\r
940 if (display.getThread() == Thread.currentThread()) {
\r
943 display.asyncExec(new Runnable() {
\r
945 public void run() {
\r
953 public void setFocus() {
\r
954 natTable.setFocus();
\r
957 @SuppressWarnings("unchecked")
\r
959 public <T> T getControl() {
\r
960 return (T)natTable;
\r
965 public boolean isDisposed() {
\r
969 protected void assertNotDisposed() {
\r
971 throw new IllegalStateException("disposed");
\r
975 public boolean isEditable() {
\r
980 public void setEditable(boolean editable) {
\r
981 if (!thread.currentThreadAccess())
\r
982 throw new IllegalStateException("not in SWT display thread " + thread.getThread());
\r
984 this.editable = editable;
\r
985 Display display = natTable.getDisplay();
\r
986 natTable.setBackground(editable ? null : display.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
\r
989 private void doDispose() {
\r
993 // TODO: Since GENodeQueryManager is cached in QueryChache and it refers to this class
\r
994 // we have to remove all references here to reduce memory consumption.
\r
996 // Proper fix would be to remove references between QueryCache and GENodeQueryManagers.
\r
997 if (rootNode != null) {
\r
998 rootNode.dispose();
\r
1001 explorerContext.dispose();
\r
1002 explorerContext = null;
\r
1003 processors.clear();
\r
1004 detachPrimitiveProcessors();
\r
1005 primitiveProcessors.clear();
\r
1006 dataSources.clear();
\r
1007 pendingItems.clear();
\r
1008 rootContext = null;
\r
1009 mouseListeners.clear();
\r
1010 selectionProvider.clearListeners();
\r
1011 selectionProvider = null;
\r
1012 selectionDataResolver = null;
\r
1013 selectedNodes.clear();
\r
1014 selectedNodes = null;
\r
1015 selectionTransformation = null;
\r
1016 originalFont = null;
\r
1017 localResourceManager.dispose();
\r
1018 localResourceManager = null;
\r
1019 // Must shutdown image loader job before disposing its ResourceManager
\r
1020 imageLoaderJob.dispose();
\r
1021 imageLoaderJob.cancel();
\r
1023 imageLoaderJob.join();
\r
1024 imageLoaderJob = null;
\r
1025 } catch (InterruptedException e) {
\r
1026 ErrorLogger.defaultLogError(e);
\r
1028 resourceManager.dispose();
\r
1029 resourceManager = null;
\r
1031 contextToNodeMap.clear(); // should be empty at this point.
\r
1032 contextToNodeMap = null;
\r
1033 if (postSelectionProvider != null) {
\r
1034 postSelectionProvider.dispose();
\r
1035 postSelectionProvider = null;
\r
1037 imageTasks = null;
\r
1038 modificationContext = null;
\r
1039 focusService = null;
\r
1040 contextService = null;
\r
1041 serviceLocator = null;
\r
1043 columnKeyToIndex.clear();
\r
1044 columnKeyToIndex = null;
\r
1045 // if (natTable != null) {
\r
1046 // natTable.dispose();
\r
1047 // natTable = null;
\r
1051 viewportLayer = null;
\r
1052 selectionLayer = null;
\r
1053 columnHeaderDataProvider = null;
\r
1054 columnAccessor = null;
\r
1055 rowHeaderDataLayer = null;
\r
1056 columnHeaderDataLayer = null;
\r
1057 cornerDataLayer = null;
\r
1062 public boolean select(NodeContext context) {
\r
1064 assertNotDisposed();
\r
1066 if (context == null || context.equals(rootContext) || contextToNodeMap.getValuesUnsafe(context).size() == 0) {
\r
1067 StructuredSelection s = new StructuredSelection();
\r
1068 selectionAdaptor.setSelection(s);
\r
1069 selectionProvider.setAndFireNonEqualSelection(s);
\r
1073 selectionAdaptor.setSelection(new StructuredSelection(contextToNodeMap.getValuesUnsafe(context).get(0)));
\r
1079 public boolean select(TreeNode node) {
\r
1080 assertNotDisposed();
\r
1082 if (!list.contains(node)) {
\r
1083 StructuredSelection s = new StructuredSelection();
\r
1084 selectionAdaptor.setSelection(s);
\r
1085 selectionProvider.setAndFireNonEqualSelection(s);
\r
1088 selectionAdaptor.setSelection(new StructuredSelection(node));
\r
1092 public void show(TreeNode node) {
\r
1093 int index = node.getListIndex();
\r
1095 int position = treeLayer.getRowPositionByIndex(index);
\r
1096 if (position < 0) {
\r
1097 treeLayer.expandToTreeRow(index);
\r
1098 position = treeLayer.getRowPositionByIndex(index);
\r
1100 viewportLayer.moveRowPositionIntoViewport(position);
\r
1104 public boolean selectPath(Collection<NodeContext> contexts) {
\r
1106 if(contexts == null) throw new IllegalArgumentException("Null list is not allowed");
\r
1107 if(contexts.isEmpty()) throw new IllegalArgumentException("Empty list is not allowed");
\r
1109 return selectPathInternal(contexts.toArray(new NodeContext[contexts.size()]), 0);
\r
1113 private boolean selectPathInternal(NodeContext[] contexts, int position) {
\r
1115 NodeContext head = contexts[position];
\r
1117 if(position == contexts.length-1) {
\r
1118 return select(head);
\r
1122 setExpanded(head, true);
\r
1123 if(!waitVisible(contexts[position+1])) return false;
\r
1125 return selectPathInternal(contexts, position+1);
\r
1129 private boolean waitVisible(NodeContext context) {
\r
1130 long start = System.nanoTime();
\r
1131 while(!isVisible(context)) {
\r
1132 Display.getCurrent().readAndDispatch();
\r
1133 long duration = System.nanoTime() - start;
\r
1134 if(duration > 10e9) return false;
\r
1140 public boolean isVisible(NodeContext context) {
\r
1141 if (contextToNodeMap.getValuesUnsafe(context).size() == 0)
\r
1144 return true; //FIXME
\r
1145 // Object elements[] = viewer.getVisibleExpandedElements();
\r
1146 // return org.simantics.utils.datastructures.Arrays.contains(elements, contextToNodeMap.getValuesUnsafe(context).get(0));
\r
1152 public TransientExplorerState getTransientState() {
\r
1153 if (!thread.currentThreadAccess())
\r
1154 throw new AssertionError(getClass().getSimpleName() + ".getActiveColumn called from non SWT-thread: " + Thread.currentThread());
\r
1155 return transientState;
\r
1159 public <T> T query(NodeContext context, CacheKey<T> key) {
\r
1160 return this.explorerContext.cache.get(context, key);
\r
1164 * For setting a more local service locator for the explorer than the global
\r
1165 * workbench service locator. Sometimes required to give this implementation
\r
1166 * access to local workbench services like IFocusService.
\r
1169 * Must be invoked during right after construction.
\r
1171 * @param serviceLocator
\r
1172 * a specific service locator or <code>null</code> to use the
\r
1173 * workbench global service locator
\r
1175 public void setServiceLocator(IServiceLocator serviceLocator) {
\r
1176 if (serviceLocator == null && PlatformUI.isWorkbenchRunning())
\r
1177 serviceLocator = PlatformUI.getWorkbench();
\r
1178 this.serviceLocator = serviceLocator;
\r
1179 if (serviceLocator != null) {
\r
1180 this.contextService = (IContextService) serviceLocator.getService(IContextService.class);
\r
1181 this.focusService = (IFocusService) serviceLocator.getService(IFocusService.class);
\r
1185 private void detachPrimitiveProcessors() {
\r
1186 for (PrimitiveQueryProcessor<?> p : primitiveProcessors.values()) {
\r
1187 if (p instanceof ProcessorLifecycle) {
\r
1188 ((ProcessorLifecycle) p).detached(this);
\r
1193 private void clearPrimitiveProcessors() {
\r
1194 for (PrimitiveQueryProcessor<?> p : primitiveProcessors.values()) {
\r
1195 if (p instanceof ProcessorLifecycle) {
\r
1196 ((ProcessorLifecycle) p).clear();
\r
1202 public void setExpanded(NodeContext context, boolean expanded) {
\r
1203 for (TreeNode n : contextToNodeMap.getValues(context)) {
\r
1205 treeLayer.expandTreeRow(n.getListIndex());
\r
1207 treeLayer.collapseTreeRow(n.getListIndex());
\r
1213 public void setAutoExpandLevel(int level) {
\r
1214 this.autoExpandLevel = level;
\r
1215 treeLayer.expandAllToLevel(level);
\r
1218 int maxChildren = DEFAULT_MAX_CHILDREN;
\r
1221 public int getMaxChildren() {
\r
1222 return maxChildren;
\r
1226 public void setMaxChildren(int maxChildren) {
\r
1227 this.maxChildren = maxChildren;
\r
1232 public int getMaxChildren(NodeQueryManager manager, NodeContext context) {
\r
1233 Integer result = manager.query(context, BuiltinKeys.SHOW_MAX_CHILDREN);
\r
1234 //System.out.println("getMaxChildren(" + manager + ", " + context + "): " + result);
\r
1235 if (result != null) {
\r
1237 throw new AssertionError("BuiltinKeys.SHOW_MAX_CHILDREN query must never return < 0, got " + result);
\r
1240 return maxChildren;
\r
1244 public <T> NodeQueryProcessor<T> getProcessor(QueryKey<T> key) {
\r
1245 return explorerContext.getProcessor(key);
\r
1249 public <T> PrimitiveQueryProcessor<T> getPrimitiveProcessor(PrimitiveQueryKey<T> key) {
\r
1250 return explorerContext.getPrimitiveProcessor(key);
\r
1253 private HashSet<UpdateItem> pendingItems = new HashSet<UpdateItem>();
\r
1254 private boolean updating = false;
\r
1255 private int updateCounter = 0;
\r
1256 final ScheduledExecutorService uiUpdateScheduler = ThreadUtils.getNonBlockingWorkExecutor();
\r
1258 private class UpdateItem {
\r
1262 public UpdateItem(TreeNode element) {
\r
1266 public UpdateItem(TreeNode element, int columnIndex) {
\r
1267 this.element = element;
\r
1268 this.columnIndex = columnIndex;
\r
1269 if (element != null && element.isDisposed()) {
\r
1270 throw new IllegalArgumentException("Node is disposed. " + element);
\r
1274 public void update(NatTable natTable) {
\r
1275 if (element != null) {
\r
1277 if (element.isDisposed()) {
\r
1280 if (element.updateChildren()) {
\r
1282 System.out.println("Update Item updateChildren " + element.listIndex + " " + element);
\r
1283 printDebug(NatTableGraphExplorer.this);
\r
1286 if (!element.isHidden()) {
\r
1287 if (!element.isExpanded()) {
\r
1288 if (element.listIndex >= 0)
\r
1289 treeLayer.collapseTreeRow(element.listIndex);
\r
1291 System.out.println("Update Item collapse " + element.listIndex);
\r
1292 printDebug(NatTableGraphExplorer.this);
\r
1295 for (TreeNode c : element.getChildren())
\r
1299 TreeNode p = element.getCollapsedAncestor();
\r
1301 if (element.listIndex >= 0)
\r
1302 treeLayer.collapseTreeRow(element.listIndex);
\r
1303 if (p.listIndex >= 0)
\r
1304 treeLayer.collapseTreeRow(p.listIndex);
\r
1306 System.out.println("Update Item ancetor collapse " + p.listIndex);
\r
1307 printDebug(NatTableGraphExplorer.this);
\r
1312 // if (columnIndex >= 0) {
\r
1313 // viewer.update(element, new String[]{columns[columnIndex].getKey()});
\r
1315 // viewer.refresh(element,true);
\r
1317 natTable.redraw();
\r
1320 if (!element.autoExpanded && !element.isDisposed() && autoExpandLevel > 1 && !element.isExpanded() && element.getDepth() <= autoExpandLevel) {
\r
1322 element.autoExpanded = true;
\r
1323 element.initData();
\r
1324 if (DEBUG) System.out.println("Update Item expand " + element.listIndex);
\r
1325 treeLayer.expandTreeRow(element.getListIndex());
\r
1326 //viewer.setExpandedState(element, true);
\r
1330 if (rootNode.updateChildren()) {
\r
1337 public boolean equals(Object obj) {
\r
1340 if (obj.getClass() != getClass())
\r
1342 UpdateItem other = (UpdateItem)obj;
\r
1343 if (columnIndex != other.columnIndex)
\r
1345 if (element != null)
\r
1346 return element.equals(other.element);
\r
1347 return other.element == null;
\r
1351 public int hashCode() {
\r
1352 if (element != null)
\r
1353 return element.hashCode() + columnIndex;
\r
1358 private void update(final TreeNode element, final int columnIndex) {
\r
1359 if (natTable.isDisposed())
\r
1361 if (element != null && element.isDisposed())
\r
1363 if (DEBUG) System.out.println("update " + element + " " + columnIndex);
\r
1364 synchronized (pendingItems) {
\r
1365 pendingItems.add(new UpdateItem(element, columnIndex));
\r
1366 if (updating) return;
\r
1368 scheduleUpdater();
\r
1372 private void update(final TreeNode element) {
\r
1374 if (natTable.isDisposed())
\r
1376 if (element != null && element.isDisposed())
\r
1378 if (DEBUG) System.out.println("update " + element);
\r
1379 synchronized (pendingItems) {
\r
1380 pendingItems.add(new UpdateItem(element));
\r
1381 if (updating) return;
\r
1383 scheduleUpdater();
\r
1387 boolean scheduleUpdater() {
\r
1389 if (natTable.isDisposed())
\r
1392 if (!pendingItems.isEmpty()) {
\r
1394 int activity = explorerContext.activityInt;
\r
1396 if (activity < 100) {
\r
1397 //System.out.println("Scheduling update immediately.");
\r
1398 } else if (activity < 1000) {
\r
1399 //System.out.println("Scheduling update after 500ms.");
\r
1402 //System.out.println("Scheduling update after 3000ms.");
\r
1406 updateCounter = 0;
\r
1408 //System.out.println("Scheduling UI update after " + delay + " ms.");
\r
1409 uiUpdateScheduler.schedule(new Runnable() {
\r
1411 public void run() {
\r
1413 if (natTable == null || natTable.isDisposed())
\r
1416 if (updateCounter > 0) {
\r
1417 updateCounter = 0;
\r
1418 uiUpdateScheduler.schedule(this, 50, TimeUnit.MILLISECONDS);
\r
1420 natTable.getDisplay().asyncExec(new UpdateRunner(NatTableGraphExplorer.this, NatTableGraphExplorer.this.explorerContext));
\r
1424 }, delay, TimeUnit.MILLISECONDS);
\r
1434 public String startEditing(NodeContext context, String columnKey) {
\r
1435 assertNotDisposed();
\r
1436 if (!thread.currentThreadAccess())
\r
1437 throw new IllegalStateException("not in SWT display thread " + thread.getThread());
\r
1439 if(columnKey.startsWith("#")) {
\r
1440 columnKey = columnKey.substring(1);
\r
1443 Integer columnIndex = columnKeyToIndex.get(columnKey);
\r
1444 if (columnIndex == null)
\r
1445 return "Rename not supported for selection";
\r
1447 // viewer.editElement(context, columnIndex);
\r
1448 // if(viewer.isCellEditorActive()) return null;
\r
1449 return "Rename not supported for selection";
\r
1453 public String startEditing(String columnKey) {
\r
1454 ISelection selection = postSelectionProvider.getSelection();
\r
1455 if(selection == null) return "Rename not supported for selection";
\r
1456 NodeContext context = ISelectionUtils.filterSingleSelection(selection, NodeContext.class);
\r
1457 if(context == null) return "Rename not supported for selection";
\r
1459 return startEditing(context, columnKey);
\r
1463 public void setSelection(final ISelection selection, boolean forceControlUpdate) {
\r
1464 assertNotDisposed();
\r
1465 boolean equalsOld = selectionProvider.selectionEquals(selection);
\r
1466 if (equalsOld && !forceControlUpdate) {
\r
1467 // Just set the selection object instance, fire no events nor update
\r
1468 // the viewer selection.
\r
1469 selectionProvider.setSelection(selection);
\r
1471 Collection<NodeContext> coll = AdaptionUtils.adaptToCollection(selection, NodeContext.class);
\r
1472 Collection<TreeNode> nodes = new ArrayList<TreeNode>();
\r
1473 for (NodeContext c : coll) {
\r
1474 List<TreeNode> match = contextToNodeMap.getValuesUnsafe(c);
\r
1475 if(match.size() > 0)
\r
1476 nodes.add(match.get(0));
\r
1478 final ISelection sel = new StructuredSelection(nodes.toArray());
\r
1479 if (coll.size() == 0)
\r
1481 // Schedule viewer and selection update if necessary.
\r
1482 if (natTable.isDisposed())
\r
1484 Display d = natTable.getDisplay();
\r
1485 if (d.getThread() == Thread.currentThread()) {
\r
1486 selectionAdaptor.setSelection(sel);
\r
1488 d.asyncExec(new Runnable() {
\r
1490 public void run() {
\r
1491 if (natTable.isDisposed())
\r
1493 selectionAdaptor.setSelection(sel);
\r
1501 public void setModificationContext(ModificationContext modificationContext) {
\r
1502 this.modificationContext = modificationContext;
\r
1506 final ExecutorService queryUpdateScheduler = Threads.getExecutor();
\r
1509 private double getDisplayScale() {
\r
1510 Point dpi = Display.getCurrent().getDPI();
\r
1511 return (double)dpi.x/96.0;
\r
1514 private void createNatTable(int style) {
\r
1515 GETreeData treeData = new GETreeData(list);
\r
1516 GETreeRowModel<TreeNode> treeRowModel = new GETreeRowModel<TreeNode>(treeData);
\r
1517 columnAccessor = new GEColumnAccessor(this);
\r
1519 IDataProvider dataProvider = new ListDataProvider<TreeNode>(list, columnAccessor);
\r
1521 int defaultFontSize = 12;
\r
1522 int height = (int)Math.ceil(((double)(defaultFontSize))*getDisplayScale()) + DataLayer.DEFAULT_ROW_HEIGHT-defaultFontSize;
\r
1523 dataLayer = new DataLayer(dataProvider, DataLayer.DEFAULT_COLUMN_WIDTH, height);
\r
1525 // resizable rows are unnecessary in Sulca report.
\r
1526 dataLayer.setRowsResizableByDefault(false);
\r
1528 // Row header layer
\r
1529 DefaultRowHeaderDataProvider rowHeaderDataProvider = new DefaultRowHeaderDataProvider(dataProvider);
\r
1530 rowHeaderDataLayer = new DefaultRowHeaderDataLayer(rowHeaderDataProvider);
\r
1532 // adjust row header column width so that row numbers fit into the column.
\r
1533 //adjustRowHeaderWidth(list.size());
\r
1535 // Column header layer
\r
1536 columnHeaderDataProvider = new GEColumnHeaderDataProvider(this, dataLayer);
\r
1537 columnHeaderDataLayer = new DefaultColumnHeaderDataLayer(columnHeaderDataProvider);
\r
1538 columnHeaderDataLayer.setDefaultRowHeight(height);
\r
1539 columnHeaderDataProvider.updateColumnSizes();
\r
1541 //ISortModel sortModel = new EcoSortModel(this, generator,dataLayer);
\r
1543 // Column re-order + hide
\r
1544 ColumnReorderLayer columnReorderLayer = new ColumnReorderLayer(dataLayer);
\r
1545 ColumnHideShowLayer columnHideShowLayer = new ColumnHideShowLayer(columnReorderLayer);
\r
1548 treeLayer = new GETreeLayer(columnHideShowLayer, treeRowModel, false);
\r
1550 selectionLayer = new SelectionLayer(treeLayer);
\r
1552 viewportLayer = new ViewportLayer(selectionLayer);
\r
1554 ColumnHeaderLayer columnHeaderLayer = new ColumnHeaderLayer(columnHeaderDataLayer, viewportLayer, selectionLayer);
\r
1555 // Note: The column header layer is wrapped in a filter row composite.
\r
1556 // This plugs in the filter row functionality
\r
1558 ColumnOverrideLabelAccumulator labelAccumulator = new ColumnOverrideLabelAccumulator(columnHeaderDataLayer);
\r
1559 columnHeaderDataLayer.setConfigLabelAccumulator(labelAccumulator);
\r
1561 // Register labels
\r
1562 //SortHeaderLayer<TreeNode> sortHeaderLayer = new SortHeaderLayer<TreeNode>(columnHeaderLayer, sortModel, false);
\r
1564 RowHeaderLayer rowHeaderLayer = new RowHeaderLayer(rowHeaderDataLayer, viewportLayer, selectionLayer);
\r
1567 DefaultCornerDataProvider cornerDataProvider = new DefaultCornerDataProvider(columnHeaderDataProvider, rowHeaderDataProvider);
\r
1568 cornerDataLayer = new DataLayer(cornerDataProvider);
\r
1569 //CornerLayer cornerLayer = new CornerLayer(cornerDataLayer, rowHeaderLayer, sortHeaderLayer);
\r
1570 CornerLayer cornerLayer = new CornerLayer(cornerDataLayer, rowHeaderLayer, columnHeaderLayer);
\r
1573 //GridLayer gridLayer = new GridLayer(viewportLayer,sortHeaderLayer,rowHeaderLayer, cornerLayer);
\r
1574 GridLayer gridLayer = new GridLayer(viewportLayer, columnHeaderLayer,rowHeaderLayer, cornerLayer, false);
\r
1576 /* Since 1.4.0, alternative row rendering uses row indexes in the original data list.
\r
1577 When combined with collapsed tree rows, rows with odd or even index may end up next to each other,
\r
1578 which defeats the purpose of alternating colors. This overrides that and returns the functionality
\r
1579 that we had with 1.0.1. */
\r
1580 gridLayer.setConfigLabelAccumulatorForRegion(GridRegion.BODY, new RelativeAlternatingRowConfigLabelAccumulator());
\r
1581 gridLayer.addConfiguration(new DefaultEditConfiguration());
\r
1582 //gridLayer.addConfiguration(new DefaultEditBindings());
\r
1583 gridLayer.addConfiguration(new GEEditBindings());
\r
1585 natTable = new NatTable(composite,gridLayer,false);
\r
1587 //selectionLayer.registerCommandHandler(new EcoCopyDataCommandHandler(selectionLayer,columnHeaderDataLayer,columnAccessor, columnHeaderDataProvider));
\r
1589 natTable.addConfiguration(new NatTableHeaderMenuConfiguration(natTable));
\r
1590 natTable.addConfiguration(new DefaultTreeLayerConfiguration2(treeLayer));
\r
1591 natTable.addConfiguration(new SingleClickSortConfiguration());
\r
1592 //natTable.addLayerListener(this);
\r
1594 natTable.addConfiguration(new GENatTableThemeConfiguration(treeData, style));
\r
1595 natTable.addConfiguration(new NatTableHeaderMenuConfiguration(natTable));
\r
1597 natTable.addConfiguration(new AbstractRegistryConfiguration() {
\r
1600 public void configureRegistry(IConfigRegistry configRegistry) {
\r
1601 configRegistry.registerConfigAttribute(
\r
1602 EditConfigAttributes.CELL_EDITABLE_RULE,
\r
1603 new IEditableRule() {
\r
1606 public boolean isEditable(ILayerCell cell,
\r
1607 IConfigRegistry configRegistry) {
\r
1608 int col = cell.getColumnIndex();
\r
1609 int row = cell.getRowIndex();
\r
1610 TreeNode node = list.get(row);
\r
1611 Modifier modifier = getModifier(node,col);
\r
1612 return modifier != null;
\r
1617 public boolean isEditable(int columnIndex, int rowIndex) {
\r
1618 // there are no callers?
\r
1623 configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR, new AdaptableCellEditor());
\r
1624 configRegistry.registerConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_HANDLER, new DialogErrorHandling(), DisplayMode.EDIT);
\r
1625 configRegistry.registerConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_HANDLER, new DialogErrorHandling(), DisplayMode.EDIT);
\r
1626 configRegistry.registerConfigAttribute(EditConfigAttributes.DATA_VALIDATOR, new AdaptableDataValidator(),DisplayMode.EDIT);
\r
1628 Style conversionErrorStyle = new Style();
\r
1629 conversionErrorStyle.setAttributeValue(CellStyleAttributes.BACKGROUND_COLOR, GUIHelper.COLOR_RED);
\r
1630 conversionErrorStyle.setAttributeValue(CellStyleAttributes.FOREGROUND_COLOR, GUIHelper.COLOR_WHITE);
\r
1631 configRegistry.registerConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, conversionErrorStyle, DisplayMode.EDIT);
\r
1633 configRegistry.registerConfigAttribute(CellConfigAttributes.DISPLAY_CONVERTER, new DefaultDisplayConverter(),DisplayMode.EDIT);
\r
1639 if ((style & SWT.BORDER) > 0) {
\r
1640 natTable.addOverlayPainter(new NatTableBorderOverlayPainter());
\r
1643 natTable.configure();
\r
1645 // natTable.addListener(SWT.MenuDetect, new NatTableMenuListener());
\r
1647 // DefaultToolTip toolTip = new EcoCellToolTip(natTable, columnAccessor);
\r
1648 // toolTip.setBackgroundColor(natTable.getDisplay().getSystemColor(SWT.COLOR_WHITE));
\r
1649 // toolTip.setPopupDelay(500);
\r
1650 // toolTip.activate();
\r
1651 // toolTip.setShift(new Point(10, 10));
\r
1654 // menuManager.createContextMenu(composite);
\r
1655 // natTable.setMenu(getMenuManager().getMenu());
\r
1657 selectionAdaptor = new NatTableSelectionAdaptor(natTable, selectionLayer, treeData);
\r
1660 Modifier getModifier(TreeNode element, int columnIndex) {
\r
1661 GENodeQueryManager manager = element.getManager();
\r
1662 final NodeContext context = element.getContext();
\r
1663 Labeler labeler = manager.query(context, BuiltinKeys.SELECTED_LABELER);
\r
1664 if (labeler == null)
\r
1666 Column column = columns[columnIndex];
\r
1668 return labeler.getModifier(modificationContext, column.getKey());
\r
1672 private class AdaptableCellEditor implements ICellEditor {
\r
1673 ICellEditor editor;
\r
1676 public Control activateCell(Composite parent, Object originalCanonicalValue, EditModeEnum editMode,
\r
1677 ICellEditHandler editHandler, ILayerCell cell, IConfigRegistry configRegistry) {
\r
1678 int col = cell.getColumnIndex();
\r
1679 int row = cell.getRowIndex();
\r
1680 TreeNode node = list.get(row);
\r
1681 Modifier modifier = getModifier(node, col);
\r
1682 if (modifier == null)
\r
1686 if (modifier instanceof DialogModifier) {
\r
1687 DialogModifier mod = (DialogModifier)modifier;
\r
1688 editor = new DialogCellEditor(node, col, mod);
\r
1689 } else if (modifier instanceof CustomModifier) {
\r
1690 CustomModifier mod = (CustomModifier)modifier;
\r
1691 editor = new CustomCellEditor(node, col, mod);
\r
1692 } else if (modifier instanceof EnumerationModifier) {
\r
1693 EnumerationModifier mod = (EnumerationModifier)modifier;
\r
1694 editor = new ComboBoxCellEditor(mod.getValues());
\r
1696 editor = new TextCellEditor();
\r
1699 return editor.activateCell(parent, originalCanonicalValue, editMode, editHandler, cell, configRegistry);
\r
1703 public int getColumnIndex() {
\r
1704 return editor.getColumnIndex();
\r
1708 public int getRowIndex() {
\r
1709 return editor.getRowIndex();
\r
1713 public int getColumnPosition() {
\r
1714 return editor.getColumnPosition();
\r
1718 public int getRowPosition() {
\r
1719 return editor.getRowPosition();
\r
1723 public Object getEditorValue() {
\r
1724 return editor.getEditorValue();
\r
1728 public void setEditorValue(Object value) {
\r
1729 editor.setEditorValue(value);
\r
1734 public Object getCanonicalValue() {
\r
1735 return editor.getCanonicalValue();
\r
1739 public Object getCanonicalValue(IEditErrorHandler conversionErrorHandler) {
\r
1740 return editor.getCanonicalValue();
\r
1744 public void setCanonicalValue(Object canonicalValue) {
\r
1745 editor.setCanonicalValue(canonicalValue);
\r
1750 public boolean validateCanonicalValue(Object canonicalValue) {
\r
1751 return editor.validateCanonicalValue(canonicalValue);
\r
1755 public boolean validateCanonicalValue(Object canonicalValue, IEditErrorHandler validationErrorHandler) {
\r
1756 return editor.validateCanonicalValue(canonicalValue, validationErrorHandler);
\r
1760 public boolean commit(MoveDirectionEnum direction) {
\r
1761 return editor.commit(direction);
\r
1765 public boolean commit(MoveDirectionEnum direction, boolean closeAfterCommit) {
\r
1766 return editor.commit(direction, closeAfterCommit);
\r
1770 public boolean commit(MoveDirectionEnum direction, boolean closeAfterCommit, boolean skipValidation) {
\r
1771 return editor.commit(direction, closeAfterCommit, skipValidation);
\r
1775 public void close() {
\r
1781 public boolean isClosed() {
\r
1782 return editor.isClosed();
\r
1786 public Control getEditorControl() {
\r
1787 return editor.getEditorControl();
\r
1791 public Control createEditorControl(Composite parent) {
\r
1792 return editor.createEditorControl(parent);
\r
1796 public boolean openInline(IConfigRegistry configRegistry, List<String> configLabels) {
\r
1797 return EditConfigHelper.openInline(configRegistry, configLabels);
\r
1801 public boolean supportMultiEdit(IConfigRegistry configRegistry, List<String> configLabels) {
\r
1802 return editor.supportMultiEdit(configRegistry, configLabels);
\r
1806 public boolean openMultiEditDialog() {
\r
1807 return editor.openMultiEditDialog();
\r
1811 public boolean openAdjacentEditor() {
\r
1812 return editor.openAdjacentEditor();
\r
1816 public boolean activateAtAnyPosition() {
\r
1821 public boolean activateOnTraversal(IConfigRegistry configRegistry, List<String> configLabels) {
\r
1822 return editor.activateOnTraversal(configRegistry, configLabels);
\r
1826 public void addEditorControlListeners() {
\r
1827 editor.addEditorControlListeners();
\r
1832 public void removeEditorControlListeners() {
\r
1833 editor.removeEditorControlListeners();
\r
1838 public Rectangle calculateControlBounds(Rectangle cellBounds) {
\r
1839 return editor.calculateControlBounds(cellBounds);
\r
1843 private class AdaptableDataValidator implements IDataValidator {
\r
1845 public boolean validate(ILayerCell cell, IConfigRegistry configRegistry, Object newValue) {
\r
1846 int col = cell.getColumnIndex();
\r
1847 int row = cell.getRowIndex();
\r
1848 return validate(col, row, newValue);
\r
1852 public boolean validate(int col, int row, Object newValue) {
\r
1853 TreeNode node = list.get(row);
\r
1854 Modifier modifier = getModifier(node, col);
\r
1855 if (modifier == null)
\r
1858 String err = modifier.isValid(newValue.toString());
\r
1861 modifier.isValid(newValue.toString());
\r
1862 throw new ValidationFailedException(err);
\r
1866 private class CustomCellEditor extends AbstractCellEditor {
\r
1868 CustomModifier customModifier;
\r
1872 public CustomCellEditor(TreeNode node, int column, CustomModifier customModifier) {
\r
1873 this.customModifier = customModifier;
\r
1875 this.column = column;
\r
1879 public Object getEditorValue() {
\r
1880 return customModifier.getValue();
\r
1884 public void setEditorValue(Object value) {
\r
1885 customModifier.modify(value.toString());
\r
1890 public Control getEditorControl() {
\r
1895 public Control createEditorControl(Composite parent) {
\r
1896 return (Control)customModifier.createControl(parent, null, column, node.getContext());
\r
1901 protected Control activateCell(Composite parent, Object originalCanonicalValue) {
\r
1902 this.control = createEditorControl(parent);
\r
1909 private class DialogCellEditor extends AbstractDialogCellEditor {
\r
1911 DialogModifier dialogModifier;
\r
1914 String res = null;
\r
1917 boolean closed = false;
\r
1919 public DialogCellEditor(TreeNode node, int column, DialogModifier dialogModifier) {
\r
1920 this.dialogModifier = dialogModifier;
\r
1922 this.column = column;
\r
1926 public int open() {
\r
1927 sem = new Semaphore(1);
\r
1928 Consumer<String> callback = result -> {
\r
1932 String status = dialogModifier.query(this.parent.getShell(), null, column, node.getContext(), callback);
\r
1933 if (status != null) {
\r
1935 return Window.CANCEL;
\r
1940 } catch (InterruptedException e) {
\r
1941 e.printStackTrace();
\r
1948 public DialogModifier createDialogInstance() {
\r
1950 return dialogModifier;
\r
1954 public Object getDialogInstance() {
\r
1955 return (DialogModifier)this.dialog;
\r
1959 public void close() {
\r
1964 public Object getEditorValue() {
\r
1969 public void setEditorValue(Object value) {
\r
1970 // dialog modifier handles this internally
\r
1974 public boolean isClosed() {
\r
1982 * The job that is used for off-loading image loading tasks (see
\r
1983 * {@link ImageTask} to a worker thread from the main UI thread.
\r
1985 ImageLoaderJob imageLoaderJob;
\r
1987 // Map<NodeContext, ImageTask> imageTasks = new THashMap<NodeContext, ImageTask>();
\r
1988 Map<TreeNode, ImageTask> imageTasks = new THashMap<TreeNode, ImageTask>();
\r
1990 void queueImageTask(TreeNode node, ImageTask task) {
\r
1991 synchronized (imageTasks) {
\r
1992 imageTasks.put(node, task);
\r
1994 imageLoaderJob.scheduleIfNecessary(100);
\r
1998 * Invoked in a job worker thread.
\r
2003 protected IStatus setPendingImages(IProgressMonitor monitor) {
\r
2004 ImageTask[] tasks = null;
\r
2005 synchronized (imageTasks) {
\r
2006 tasks = imageTasks.values().toArray(new ImageTask[imageTasks.size()]);
\r
2007 imageTasks.clear();
\r
2010 MultiStatus status = null;
\r
2012 // Load missing images
\r
2013 for (ImageTask task : tasks) {
\r
2014 Object desc = task.descsOrImage;
\r
2015 if (desc instanceof ImageDescriptor) {
\r
2017 desc = resourceManager.get((ImageDescriptor) desc);
\r
2018 task.descsOrImage = desc;
\r
2019 } catch (DeviceResourceException e) {
\r
2020 if (status == null)
\r
2021 status = new MultiStatus(Activator.PLUGIN_ID, 0, "Problems loading images:", null);
\r
2022 status.add(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Image descriptor loading failed: " + desc, e));
\r
2028 // Perform final UI updates in the UI thread.
\r
2029 final ImageTask[] _tasks = tasks;
\r
2030 thread.asyncExec(new Runnable() {
\r
2032 public void run() {
\r
2033 setImages(_tasks);
\r
2037 return status != null ? status : Status.OK_STATUS;
\r
2041 void setImages(ImageTask[] tasks) {
\r
2042 for (ImageTask task : tasks)
\r
2047 void setImage(ImageTask task) {
\r
2048 if (!task.node.isDisposed())
\r
2049 update(task.node, 0);
\r
2052 private static class GraphExplorerPostSelectionProvider implements IPostSelectionProvider {
\r
2054 private NatTableGraphExplorer ge;
\r
2056 GraphExplorerPostSelectionProvider(NatTableGraphExplorer ge) {
\r
2065 public void setSelection(final ISelection selection) {
\r
2066 if(ge == null) return;
\r
2067 ge.setSelection(selection, false);
\r
2073 public void removeSelectionChangedListener(ISelectionChangedListener listener) {
\r
2074 if(ge == null) return;
\r
2075 if(ge.isDisposed()) {
\r
2076 if (DEBUG_SELECTION_LISTENERS)
\r
2077 System.out.println("GraphExplorerImpl is disposed in removeSelectionChangedListener: " + listener);
\r
2080 ge.selectionProvider.removeSelectionChangedListener(listener);
\r
2084 public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
\r
2085 if(ge == null) return;
\r
2086 if (!ge.thread.currentThreadAccess())
\r
2087 throw new AssertionError(getClass().getSimpleName() + ".addPostSelectionChangedListener called from non SWT-thread: " + Thread.currentThread());
\r
2088 if(ge.isDisposed()) {
\r
2089 System.out.println("Client BUG: GraphExplorerImpl is disposed in addPostSelectionChangedListener: " + listener);
\r
2092 ge.selectionProvider.addPostSelectionChangedListener(listener);
\r
2096 public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
\r
2097 if(ge == null) return;
\r
2098 if(ge.isDisposed()) {
\r
2099 if (DEBUG_SELECTION_LISTENERS)
\r
2100 System.out.println("GraphExplorerImpl is disposed in removePostSelectionChangedListener: " + listener);
\r
2103 ge.selectionProvider.removePostSelectionChangedListener(listener);
\r
2108 public void addSelectionChangedListener(ISelectionChangedListener listener) {
\r
2109 if(ge == null) return;
\r
2110 if (!ge.thread.currentThreadAccess())
\r
2111 throw new AssertionError(getClass().getSimpleName() + ".addSelectionChangedListener called from non SWT-thread: " + Thread.currentThread());
\r
2112 if (ge.natTable.isDisposed() || ge.selectionProvider == null) {
\r
2113 System.out.println("Client BUG: GraphExplorerImpl is disposed in addSelectionChangedListener: " + listener);
\r
2117 ge.selectionProvider.addSelectionChangedListener(listener);
\r
2122 public ISelection getSelection() {
\r
2123 if(ge == null) return StructuredSelection.EMPTY;
\r
2124 if (!ge.thread.currentThreadAccess())
\r
2125 throw new AssertionError(getClass().getSimpleName() + ".getSelection called from non SWT-thread: " + Thread.currentThread());
\r
2126 if (ge.natTable.isDisposed() || ge.selectionProvider == null)
\r
2127 return StructuredSelection.EMPTY;
\r
2128 return ge.selectionProvider.getSelection();
\r
2133 static class ModifierValidator implements ICellEditorValidator {
\r
2134 private Modifier modifier;
\r
2135 public ModifierValidator(Modifier modifier) {
\r
2136 this.modifier = modifier;
\r
2140 public String isValid(Object value) {
\r
2141 return modifier.isValid((String)value);
\r
2145 static class UpdateRunner implements Runnable {
\r
2147 final NatTableGraphExplorer ge;
\r
2149 UpdateRunner(NatTableGraphExplorer ge, IGraphExplorerContext geContext) {
\r
2153 public void run() {
\r
2156 } catch (Throwable t) {
\r
2157 t.printStackTrace();
\r
2161 public void doRun() {
\r
2163 if (ge.isDisposed())
\r
2166 HashSet<UpdateItem> items;
\r
2168 ScrollBar verticalBar = ge.natTable.getVerticalBar();
\r
2171 synchronized (ge.pendingItems) {
\r
2172 items = ge.pendingItems;
\r
2173 ge.pendingItems = new HashSet<UpdateItem>();
\r
2175 if (DEBUG) System.out.println("UpdateRunner.doRun() " + items.size());
\r
2177 //ge.natTable.setRedraw(false);
\r
2178 for (UpdateItem item : items) {
\r
2179 item.update(ge.natTable);
\r
2182 // check if vertical scroll bar has become visible and refresh layout.
\r
2183 boolean currentlyVerticalBarVisible = verticalBar.isVisible();
\r
2184 if (ge.verticalBarVisible != currentlyVerticalBarVisible) {
\r
2185 ge.verticalBarVisible = currentlyVerticalBarVisible;
\r
2186 ge.natTable.getParent().layout();
\r
2189 //ge.natTable.setRedraw(true);
\r
2191 synchronized (ge.pendingItems) {
\r
2192 if (!ge.scheduleUpdater()) {
\r
2193 ge.updating = false;
\r
2197 if (!ge.updating) {
\r
2205 private static void printDebug(NatTableGraphExplorer ge) {
\r
2206 ge.printTree(ge.rootNode, 0);
\r
2207 System.out.println("Expanded");
\r
2208 for (TreeNode n : ge.treeLayer.expanded)
\r
2209 System.out.println(n);
\r
2210 System.out.println("Expanded end");
\r
2211 System.out.println("Hidden ");
\r
2212 for (int i : ge.treeLayer.getHiddenRowIndexes()) {
\r
2213 System.out.print(i + " ");
\r
2215 System.out.println();
\r
2216 // Display.getCurrent().timerExec(1000, new Runnable() {
\r
2219 // public void run() {
\r
2220 // System.out.println("Hidden delayed ");
\r
2221 // for (int i : ge.treeLayer.getHiddenRowIndexes()) {
\r
2222 // System.out.print(i + " ");
\r
2224 // System.out.println();
\r
2230 public static class GeViewerContext extends AbstractDisposable implements IGraphExplorerContext {
\r
2231 // This is for query debugging only.
\r
2233 private NatTableGraphExplorer ge;
\r
2234 int queryIndent = 0;
\r
2236 GECache2 cache = new GECache2();
\r
2237 AtomicBoolean propagating = new AtomicBoolean(false);
\r
2238 Object propagateList = new Object();
\r
2239 Object propagate = new Object();
\r
2240 List<Runnable> scheduleList = new ArrayList<Runnable>();
\r
2241 final Deque<Integer> activity = new LinkedList<Integer>();
\r
2242 int activityInt = 0;
\r
2244 AtomicReference<Runnable> currentQueryUpdater = new AtomicReference<Runnable>();
\r
2247 * Keeps track of nodes that have already been auto-expanded. After
\r
2248 * being inserted into this set, nodes will not be forced to stay in an
\r
2249 * expanded state after that. This makes it possible for the user to
\r
2250 * close auto-expanded nodes.
\r
2252 Map<NodeContext, Boolean> autoExpanded = new WeakHashMap<NodeContext, Boolean>();
\r
2254 public GeViewerContext(NatTableGraphExplorer ge) {
\r
2258 public MapList<NodeContext,TreeNode> getContextToNodeMap() {
\r
2261 return ge.contextToNodeMap;
\r
2264 public NatTableGraphExplorer getGe() {
\r
2269 protected void doDispose() {
\r
2271 autoExpanded.clear();
\r
2275 public IGECache getCache() {
\r
2280 public int queryIndent() {
\r
2281 return queryIndent;
\r
2285 public int queryIndent(int offset) {
\r
2286 queryIndent += offset;
\r
2287 return queryIndent;
\r
2291 @SuppressWarnings("unchecked")
\r
2292 public <T> NodeQueryProcessor<T> getProcessor(Object o) {
\r
2295 return ge.processors.get(o);
\r
2299 @SuppressWarnings("unchecked")
\r
2300 public <T> PrimitiveQueryProcessor<T> getPrimitiveProcessor(Object o) {
\r
2301 return ge.primitiveProcessors.get(o);
\r
2304 @SuppressWarnings("unchecked")
\r
2306 public <T> DataSource<T> getDataSource(Class<T> clazz) {
\r
2307 return ge.dataSources.get(clazz);
\r
2311 public void update(UIElementReference ref) {
\r
2312 if (ref instanceof ViewerCellReference) {
\r
2313 ViewerCellReference tiref = (ViewerCellReference) ref;
\r
2314 Object element = tiref.getElement();
\r
2315 int columnIndex = tiref.getColumn();
\r
2316 // NOTE: must be called regardless of the the item value.
\r
2317 // A null item is currently used to indicate a tree root update.
\r
2318 ge.update((TreeNode)element,columnIndex);
\r
2319 } else if (ref instanceof ViewerRowReference) {
\r
2320 ViewerRowReference rref = (ViewerRowReference)ref;
\r
2321 Object element = rref.getElement();
\r
2322 ge.update((TreeNode)element);
\r
2324 throw new IllegalArgumentException("Ui Reference is unknkown " + ref);
\r
2329 public Object getPropagateLock() {
\r
2334 public Object getPropagateListLock() {
\r
2335 return propagateList;
\r
2339 public boolean isPropagating() {
\r
2340 return propagating.get();
\r
2344 public void setPropagating(boolean b) {
\r
2345 this.propagating.set(b);
\r
2349 public List<Runnable> getScheduleList() {
\r
2350 return scheduleList;
\r
2354 public void setScheduleList(List<Runnable> list) {
\r
2355 this.scheduleList = list;
\r
2359 public Deque<Integer> getActivity() {
\r
2364 public void setActivityInt(int i) {
\r
2365 this.activityInt = i;
\r
2369 public int getActivityInt() {
\r
2370 return activityInt;
\r
2374 public void scheduleQueryUpdate(Runnable r) {
\r
2377 if (ge.isDisposed())
\r
2379 if (currentQueryUpdater.compareAndSet(null, r)) {
\r
2380 ge.queryUpdateScheduler.execute(QUERY_UPDATE_SCHEDULER);
\r
2384 Runnable QUERY_UPDATE_SCHEDULER = new Runnable() {
\r
2386 public void run() {
\r
2387 Runnable r = currentQueryUpdater.getAndSet(null);
\r
2395 public void dispose() {
\r
2397 cache = new DummyCache();
\r
2398 scheduleList.clear();
\r
2399 autoExpanded.clear();
\r
2400 autoExpanded = null;
\r
2406 private class TreeNodeIsExpandedProcessor extends AbstractPrimitiveQueryProcessor<Boolean> implements
\r
2407 IsExpandedProcessor, ProcessorLifecycle {
\r
2409 * The set of currently expanded node contexts.
\r
2411 private final HashSet<NodeContext> expanded = new HashSet<NodeContext>();
\r
2412 private final HashMap<NodeContext, PrimitiveQueryUpdater> expandedQueries = new HashMap<NodeContext, PrimitiveQueryUpdater>();
\r
2414 private NatTable natTable;
\r
2415 private List<TreeNode> list;
\r
2417 public TreeNodeIsExpandedProcessor() {
\r
2421 public Object getIdentifier() {
\r
2422 return BuiltinKeys.IS_EXPANDED;
\r
2426 public String toString() {
\r
2427 return "IsExpandedProcessor";
\r
2431 public Boolean query(PrimitiveQueryUpdater updater, NodeContext context, PrimitiveQueryKey<Boolean> key) {
\r
2432 boolean isExpanded = expanded.contains(context);
\r
2433 expandedQueries.put(context, updater);
\r
2434 return Boolean.valueOf(isExpanded);
\r
2438 public Collection<NodeContext> getExpanded() {
\r
2439 return new HashSet<NodeContext>(expanded);
\r
2443 public boolean getExpanded(NodeContext context) {
\r
2444 return this.expanded.contains(context);
\r
2448 public boolean setExpanded(NodeContext context, boolean expanded) {
\r
2449 return _setExpanded(context, expanded);
\r
2453 public boolean replaceExpanded(NodeContext context, boolean expanded) {
\r
2454 return nodeStatusChanged(context, expanded);
\r
2457 private boolean _setExpanded(NodeContext context, boolean expanded) {
\r
2459 return this.expanded.add(context);
\r
2461 return this.expanded.remove(context);
\r
2465 ILayerListener treeListener = new ILayerListener() {
\r
2468 public void handleLayerEvent(ILayerEvent event) {
\r
2469 if (event instanceof ShowRowPositionsEvent) {
\r
2470 ShowRowPositionsEvent e = (ShowRowPositionsEvent)event;
\r
2471 for (Range r : e.getRowPositionRanges()) {
\r
2472 int expanded = viewportLayer.getRowIndexByPosition(r.start-2)+1;
\r
2473 if (DEBUG)System.out.println("IsExpandedProcessor expand " + expanded);
\r
2474 if (expanded < 0 || expanded >= list.size()) {
\r
2477 nodeStatusChanged(list.get(expanded).getContext(), true);
\r
2479 } else if (event instanceof HideRowPositionsEvent) {
\r
2480 HideRowPositionsEvent e = (HideRowPositionsEvent)event;
\r
2481 for (Range r : e.getRowPositionRanges()) {
\r
2482 int collapsed = viewportLayer.getRowIndexByPosition(r.start-2);
\r
2483 if (DEBUG)System.out.println("IsExpandedProcessor collapse " + collapsed);
\r
2484 if (collapsed < 0 || collapsed >= list.size()) {
\r
2487 nodeStatusChanged(list.get(collapsed).getContext(), false);
\r
2494 protected boolean nodeStatusChanged(NodeContext context, boolean expanded) {
\r
2495 boolean result = _setExpanded(context, expanded);
\r
2496 PrimitiveQueryUpdater updater = expandedQueries.get(context);
\r
2497 if (updater != null)
\r
2498 updater.scheduleReplace(context, BuiltinKeys.IS_EXPANDED, expanded);
\r
2503 public void attached(GraphExplorer explorer) {
\r
2504 Object control = explorer.getControl();
\r
2505 if (control instanceof NatTable) {
\r
2506 this.natTable = (NatTable) control;
\r
2507 this.list = ((NatTableGraphExplorer)explorer).list;
\r
2508 natTable.addLayerListener(treeListener);
\r
2511 System.out.println("WARNING: " + getClass().getSimpleName() + " attached to unsupported control: " + control);
\r
2516 public void clear() {
\r
2518 expandedQueries.clear();
\r
2522 public void detached(GraphExplorer explorer) {
\r
2524 if (natTable != null) {
\r
2525 natTable.removeLayerListener(treeListener);
\r
2526 // natTable.removeListener(SWT.Expand, treeListener);
\r
2527 // natTable.removeListener(SWT.Collapse, treeListener);
\r
2533 private void printTree(TreeNode node, int depth) {
\r
2535 for (int i = 0; i < depth; i++) {
\r
2539 System.out.println(s);
\r
2541 for (TreeNode n : node.getChildren()) {
\r
2548 * Copy-paste of org.simantics.browsing.ui.common.internal.GECache.GECacheKey (internal class that cannot be used)
\r
2550 final private static class GECacheKey {
\r
2552 private NodeContext context;
\r
2553 private CacheKey<?> key;
\r
2555 GECacheKey(NodeContext context, CacheKey<?> key) {
\r
2556 this.context = context;
\r
2558 if (context == null || key == null)
\r
2559 throw new IllegalArgumentException("Null context or key is not accepted");
\r
2562 GECacheKey(GECacheKey other) {
\r
2563 this.context = other.context;
\r
2564 this.key = other.key;
\r
2565 if (context == null || key == null)
\r
2566 throw new IllegalArgumentException("Null context or key is not accepted");
\r
2569 void setValues(NodeContext context, CacheKey<?> key) {
\r
2570 this.context = context;
\r
2572 if (context == null || key == null)
\r
2573 throw new IllegalArgumentException("Null context or key is not accepted");
\r
2577 public int hashCode() {
\r
2578 return context.hashCode() | key.hashCode();
\r
2582 public boolean equals(Object object) {
\r
2584 if (this == object)
\r
2586 else if (object == null)
\r
2589 GECacheKey i = (GECacheKey) object;
\r
2591 return key.equals(i.key) && context.equals(i.context);
\r
2598 * Copy-paste of org.simantics.browsing.ui.common.internal.GECache with added capability of purging all NodeContext related data.
\r
2600 public static class GECache2 implements IGECache {
\r
2602 final HashMap<GECacheKey, IGECacheEntry> entries = new HashMap<GECacheKey, IGECacheEntry>();
\r
2603 final HashMap<GECacheKey, Set<UIElementReference>> treeReferences = new HashMap<GECacheKey, Set<UIElementReference>>();
\r
2604 final HashMap<NodeContext, Set<GECacheKey>> keyRefs = new HashMap<NodeContext, Set<GECacheKey>>();
\r
2607 * This single instance is used for all get operations from the cache. This
\r
2608 * should work since the GE cache is meant to be single-threaded within the
\r
2609 * current UI thread, what ever that thread is. For put operations which
\r
2610 * store the key, this is not used.
\r
2612 NodeContext getNC = new NodeContext() {
\r
2613 @SuppressWarnings("rawtypes")
\r
2615 public Object getAdapter(Class adapter) {
\r
2620 public <T> T getConstant(ConstantKey<T> key) {
\r
2625 public Set<ConstantKey<?>> getKeys() {
\r
2626 return Collections.emptySet();
\r
2629 CacheKey<?> getCK = new CacheKey<Object>() {
\r
2631 public Object processorIdenfitier() {
\r
2635 GECacheKey getKey = new GECacheKey(getNC, getCK);
\r
2638 private void addKey(GECacheKey key) {
\r
2639 Set<GECacheKey> refs = keyRefs.get(key.context);
\r
2640 if (refs != null) {
\r
2643 refs = new HashSet<GECacheKey>();
\r
2645 keyRefs.put(key.context, refs);
\r
2649 private void removeKey(GECacheKey key) {
\r
2650 Set<GECacheKey> refs = keyRefs.get(key.context);
\r
2651 if (refs != null) {
\r
2656 public <T> IGECacheEntry put(NodeContext context, CacheKey<T> key, T value) {
\r
2657 // if (DEBUG) System.out.println("Add entry " + context + " " + key);
\r
2658 IGECacheEntry entry = new GECacheEntry(context, key, value);
\r
2659 GECacheKey gekey = new GECacheKey(context, key);
\r
2660 entries.put(gekey, entry);
\r
2665 @SuppressWarnings("unchecked")
\r
2666 public <T> T get(NodeContext context, CacheKey<T> key) {
\r
2667 getKey.setValues(context, key);
\r
2668 IGECacheEntry entry = entries.get(getKey);
\r
2669 if (entry == null)
\r
2671 return (T) entry.getValue();
\r
2675 public <T> IGECacheEntry getEntry(NodeContext context, CacheKey<T> key) {
\r
2676 assert(context != null);
\r
2677 assert(key != null);
\r
2678 getKey.setValues(context, key);
\r
2679 return entries.get(getKey);
\r
2683 public <T> void remove(NodeContext context, CacheKey<T> key) {
\r
2684 // if (DEBUG) System.out.println("Remove entry " + context + " " + key);
\r
2685 getKey.setValues(context, key);
\r
2686 entries.remove(getKey);
\r
2687 removeKey(getKey);
\r
2691 public <T> Set<UIElementReference> getTreeReference(NodeContext context, CacheKey<T> key) {
\r
2692 assert(context != null);
\r
2693 assert(key != null);
\r
2694 getKey.setValues(context, key);
\r
2695 return treeReferences.get(getKey);
\r
2699 public <T> void putTreeReference(NodeContext context, CacheKey<T> key, UIElementReference reference) {
\r
2700 assert(context != null);
\r
2701 assert(key != null);
\r
2702 //if (DEBUG) System.out.println("Add tree reference " + context + " " + key);
\r
2703 getKey.setValues(context, key);
\r
2704 Set<UIElementReference> refs = treeReferences.get(getKey);
\r
2705 if (refs != null) {
\r
2706 refs.add(reference);
\r
2708 refs = new HashSet<UIElementReference>(4);
\r
2709 refs.add(reference);
\r
2710 GECacheKey gekey = new GECacheKey(getKey);
\r
2711 treeReferences.put(gekey, refs);
\r
2717 public <T> Set<UIElementReference> removeTreeReference(NodeContext context, CacheKey<T> key) {
\r
2718 assert(context != null);
\r
2719 assert(key != null);
\r
2720 //if (DEBUG) System.out.println("Remove tree reference " + context + " " + key);
\r
2721 getKey.setValues(context, key);
\r
2722 removeKey(getKey);
\r
2723 return treeReferences.remove(getKey);
\r
2727 public boolean isShown(NodeContext context) {
\r
2728 return references.get(context) > 0;
\r
2731 private TObjectIntHashMap<NodeContext> references = new TObjectIntHashMap<NodeContext>();
\r
2734 public void incRef(NodeContext context) {
\r
2735 int exist = references.get(context);
\r
2736 references.put(context, exist+1);
\r
2740 public void decRef(NodeContext context) {
\r
2741 int exist = references.get(context);
\r
2742 references.put(context, exist-1);
\r
2744 references.remove(context);
\r
2748 public void dispose() {
\r
2749 references.clear();
\r
2751 treeReferences.clear();
\r
2755 public void dispose(NodeContext context) {
\r
2756 Set<GECacheKey> keys = keyRefs.remove(context);
\r
2757 if (keys != null) {
\r
2758 for (GECacheKey key : keys) {
\r
2759 entries.remove(key);
\r
2760 treeReferences.remove(key);
\r
2768 * Non-functional cache to replace actual cache when GEContext is disposed.
\r
2773 private static class DummyCache extends GECache2 {
\r
2776 public <T> IGECacheEntry getEntry(NodeContext context, CacheKey<T> key) {
\r
2781 public <T> IGECacheEntry put(NodeContext context, CacheKey<T> key,
\r
2787 public <T> void putTreeReference(NodeContext context, CacheKey<T> key,
\r
2788 UIElementReference reference) {
\r
2792 public <T> T get(NodeContext context, CacheKey<T> key) {
\r
2797 public <T> Set<UIElementReference> getTreeReference(
\r
2798 NodeContext context, CacheKey<T> key) {
\r
2803 public <T> void remove(NodeContext context, CacheKey<T> key) {
\r
2808 public <T> Set<UIElementReference> removeTreeReference(
\r
2809 NodeContext context, CacheKey<T> key) {
\r
2814 public boolean isShown(NodeContext context) {
\r
2819 public void incRef(NodeContext context) {
\r
2824 public void decRef(NodeContext context) {
\r
2829 public void dispose() {
\r
2834 private class NatTableHeaderMenuConfiguration extends AbstractHeaderMenuConfiguration {
\r
2837 public NatTableHeaderMenuConfiguration(NatTable natTable) {
\r
2842 protected PopupMenuBuilder createColumnHeaderMenu(NatTable natTable) {
\r
2843 return super.createColumnHeaderMenu(natTable)
\r
2844 .withHideColumnMenuItem()
\r
2845 .withShowAllColumnsMenuItem()
\r
2846 .withAutoResizeSelectedColumnsMenuItem();
\r
2850 protected PopupMenuBuilder createCornerMenu(NatTable natTable) {
\r
2851 return super.createCornerMenu(natTable)
\r
2852 .withShowAllColumnsMenuItem();
\r
2855 protected PopupMenuBuilder createRowHeaderMenu(NatTable natTable) {
\r
2856 return super.createRowHeaderMenu(natTable);
\r
2860 private static class RelativeAlternatingRowConfigLabelAccumulator extends AlternatingRowConfigLabelAccumulator {
\r
2863 public void accumulateConfigLabels(LabelStack configLabels, int columnPosition, int rowPosition) {
\r
2864 configLabels.addLabel((rowPosition % 2 == 0 ? EVEN_ROW_CONFIG_TYPE : ODD_ROW_CONFIG_TYPE));
\r
2869 public Object getClicked(Object event) {
\r
2870 MouseEvent e = (MouseEvent)event;
\r
2871 final NatTable tree = (NatTable) e.getSource();
\r
2872 Point point = new Point(e.x, e.y);
\r
2873 int y = natTable.getRowPositionByY(point.y);
\r
2874 int x = natTable.getColumnPositionByX(point.x);
\r
2875 if (x < 0 | y <= 0)
\r
2877 return list.get(y-1);
\r
Code Review / simantics / platform.git / blob