/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson, others
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Patrick Tasse - Initial API and implementation
+ * François Rajotte - Filter implementation
*******************************************************************************/
package org.eclipse.linuxtools.tmf.ui.widgets.timegraph;
// Fields
// ------------------------------------------------------------------------
- // The tree viewer
+ /** The tree viewer */
private TreeViewer fTreeViewer;
- // The time viewer
+ /** The time viewer */
private TimeGraphViewer fTimeGraphViewer;
- // The top-level input (children excluded)
+ /** The top-level input (children excluded) */
private List<? extends ITimeGraphEntry> fTopInput;
- // All the inputs (children included)
- private List<? extends ITimeGraphEntry> fAllInput;
+ /** The selection listener map */
+ private final Map<ITimeGraphSelectionListener, SelectionListenerWrapper> fSelectionListenerMap = new HashMap<ITimeGraphSelectionListener, SelectionListenerWrapper>();
- // The selection listener map
- private final HashMap<ITimeGraphSelectionListener, SelectionListenerWrapper> fSelectionListenerMap = new HashMap<ITimeGraphSelectionListener, SelectionListenerWrapper>();
-
- // The map of viewer filters
+ /** The map of viewer filters */
private final Map<ViewerFilter, ViewerFilter> fViewerFilterMap = new HashMap<ViewerFilter, ViewerFilter>();
- // Flag to block the tree selection changed listener when triggered by the time graph combo
+ /**
+ * Flag to block the tree selection changed listener when triggered by the
+ * time graph combo
+ */
private boolean fInhibitTreeSelection = false;
- // Number of filler rows used by the tree content provider
+ /** Number of filler rows used by the tree content provider */
private int fNumFillerRows;
- // Calculated item height for Linux workaround
+ /** Calculated item height for Linux workaround */
private int fLinuxItemHeight = 0;
- // The button that opens the filter dialog
+ /** The button that opens the filter dialog */
private Action showFilterAction;
- // The filter dialog
+ /** The filter dialog */
private TimeGraphFilterDialog fFilterDialog;
- // The filter generated from the filter dialog
+ /** The filter generated from the filter dialog */
private RawViewerFilter fFilter;
+ /** Default weight of each part of the sash */
+ private static final int[] DEFAULT_WEIGHTS = { 1, 1 };
+
// ------------------------------------------------------------------------
// Classes
// ------------------------------------------------------------------------
public Object[] getElements(Object inputElement) {
Object[] elements = contentProvider.getElements(inputElement);
// add filler elements to ensure alignment with time analysis viewer
- Object[] oElements = Arrays.copyOf(elements, elements.length + fNumFillerRows, new Object[0].getClass());
+ Object[] oElements = Arrays.copyOf(elements, elements.length + fNumFillerRows, Object[].class);
for (int i = 0; i < fNumFillerRows; i++) {
oElements[elements.length + i] = FILLER;
}
*/
private class ViewerFilterWrapper extends ViewerFilter {
- ViewerFilter fWrappedFilter;
+ private ViewerFilter fWrappedFilter;
ViewerFilterWrapper(ViewerFilter filter) {
super();
}
/**
- * This filter simply keeps a list of elements that should be shown
- * All the other elements will be filtered
+ * This filter simply keeps a list of elements that should be filtered out.
+ * All the other elements will be shown.
+ * By default and when the list is set to null, all elements are shown.
*/
private class RawViewerFilter extends ViewerFilter {
- private List<Object> fNonFiltered = new ArrayList<Object>();
+ private List<Object> fFiltered = null;
- public void setNonFiltered(List<Object> objects) {
- fNonFiltered = objects;
+ public void setFiltered(List<Object> objects) {
+ fFiltered = objects;
}
- public List<Object> getNonFiltered() {
- return fNonFiltered;
+ public List<Object> getFiltered() {
+ return fFiltered;
}
@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
- return fNonFiltered.contains(element);
+ if (fFiltered == null) {
+ return true;
+ }
+ return !fFiltered.contains(element);
}
}
* @param style the style of widget to construct
*/
public TimeGraphCombo(Composite parent, int style) {
+ this(parent, style, DEFAULT_WEIGHTS);
+ }
+
+ /**
+ * Constructs a new instance of this class given its parent and a style
+ * value describing its behavior and appearance.
+ *
+ * @param parent
+ * a widget which will be the parent of the new instance (cannot
+ * be null)
+ * @param style
+ * the style of widget to construct
+ * @param weights
+ * The relative weights of each side of the sash form
+ * @since 2.1
+ */
+ public TimeGraphCombo(Composite parent, int style, int[] weights) {
super(parent, style);
setLayout(new FillLayout());
// Bug in Linux. The tree header height is 0 in constructor,
// so we need to reset it later when the control is resized.
tree.addControlListener(new ControlAdapter() {
- int depth = 0;
+ private int depth = 0;
@Override
public void controlResized(ControlEvent e) {
if (depth == 0) {
@Override
public void treeCollapsed(TreeExpansionEvent event) {
fTimeGraphViewer.setExpandedState((ITimeGraphEntry) event.getElement(), false);
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
return;
}
@Override
public void treeExpanded(TreeExpansionEvent event) {
- fTimeGraphViewer.setExpandedState((ITimeGraphEntry) event.getElement(), true);
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ ITimeGraphEntry entry = (ITimeGraphEntry) event.getElement();
+ fTimeGraphViewer.setExpandedState(entry, true);
+ for (ITimeGraphEntry child : entry.getChildren()) {
+ boolean expanded = fTreeViewer.getExpandedState(child);
+ fTimeGraphViewer.setExpandedState(child, expanded);
+ }
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
return;
}
@Override
public void treeExpanded(TimeGraphTreeExpansionEvent event) {
- fTreeViewer.setExpandedState(event.getEntry(), true);
+ ITimeGraphEntry entry = event.getEntry();
+ fTreeViewer.setExpandedState(entry, true);
+ for (ITimeGraphEntry child : entry.getChildren()) {
+ boolean expanded = fTreeViewer.getExpandedState(child);
+ fTimeGraphViewer.setExpandedState(child, expanded);
+ }
}
});
TreeItem treeItem = tree.getItem(new Point(event.x, event.y));
if (treeItem == null || treeItem.getData() == FILLER) {
event.doit = false;
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
fTreeViewer.setSelection(new StructuredSelection());
fTimeGraphViewer.setSelection(null);
event.doit = false;
Slider scrollBar = fTimeGraphViewer.getVerticalBar();
fTimeGraphViewer.setTopIndex(scrollBar.getSelection() - event.count);
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
return;
}
tree.addListener(SWT.KeyDown, new Listener() {
@Override
public void handleEvent(Event event) {
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
fTreeViewer.setSelection(new StructuredSelection());
event.doit = false;
fTimeGraphViewer.getTimeGraphControl().addControlListener(new ControlAdapter() {
@Override
public void controlResized(ControlEvent e) {
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
return;
}
if (selection instanceof ITimeGraphEntry) {
fTimeGraphViewer.setSelection((ITimeGraphEntry) selection);
}
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
return;
}
fTreeViewer.setSelection(new StructuredSelection());
}
fInhibitTreeSelection = false;
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
return;
}
fTimeGraphViewer.getVerticalBar().addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
return;
}
fTimeGraphViewer.getTimeGraphControl().addMouseWheelListener(new MouseWheelListener() {
@Override
public void mouseScrolled(MouseEvent e) {
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() == 0) {
return;
}
// to a value that would cause blank space to be drawn at the bottom of the tree.
fNumFillerRows = Display.getDefault().getBounds().height / getItemHeight(tree);
- sash.setWeights(new int[] { 1, 1 });
+ sash.setWeights(weights);
}
// ------------------------------------------------------------------------
*/
public void showFilterDialog() {
if(fTopInput != null) {
+ List<? extends ITimeGraphEntry> allElements = listAllInputs(fTopInput);
fFilterDialog.setInput(fTopInput.toArray(new ITimeGraphEntry[0]));
fFilterDialog.setTitle(Messages.TmfTimeFilterDialog_WINDOW_TITLE);
fFilterDialog.setMessage(Messages.TmfTimeFilterDialog_MESSAGE);
- fFilterDialog.setInitialElementSelections(fFilter.getNonFiltered());
- fFilterDialog.setExpandedElements(fAllInput.toArray());
+ fFilterDialog.setExpandedElements(allElements.toArray());
+ if (fFilter.getFiltered() != null) {
+ ArrayList<? extends ITimeGraphEntry> nonFilteredElements = new ArrayList<ITimeGraphEntry>(allElements);
+ nonFilteredElements.removeAll(fFilter.getFiltered());
+ fFilterDialog.setInitialElementSelections(nonFilteredElements);
+ } else {
+ fFilterDialog.setInitialElementSelections(allElements);
+ }
fFilterDialog.create();
fFilterDialog.open();
// Process selected elements
if (fFilterDialog.getResult() != null) {
fInhibitTreeSelection = true;
- fFilter.setNonFiltered(new ArrayList<Object>(Arrays.asList(fFilterDialog.getResult())));
+ if (fFilterDialog.getResult().length != allElements.size()) {
+ ArrayList<Object> filteredElements = new ArrayList<Object>(allElements);
+ filteredElements.removeAll(Arrays.asList(fFilterDialog.getResult()));
+ fFilter.setFiltered(filteredElements);
+ } else {
+ fFilter.setFiltered(null);
+ }
fTreeViewer.refresh();
fTreeViewer.expandAll();
fTimeGraphViewer.refresh();
// Control
// ------------------------------------------------------------------------
- /* (non-Javadoc)
- * @see org.eclipse.swt.widgets.Control#redraw()
- */
@Override
public void redraw() {
fTimeGraphViewer.getControl().redraw();
*/
public void setInput(ITimeGraphEntry[] input) {
fTopInput = new ArrayList<ITimeGraphEntry>(Arrays.asList(input));
- fAllInput = listAllInputs(fTopInput);
- fFilter.setNonFiltered(new ArrayList<Object>(fAllInput));
+ fFilter.setFiltered(null);
fInhibitTreeSelection = true;
fTreeViewer.setInput(input);
for (SelectionListenerWrapper listenerWrapper : fSelectionListenerMap.values()) {
fTreeViewer.setSelection(new StructuredSelection());
}
fInhibitTreeSelection = false;
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(fTreeViewer.getTree());
+ List<TreeItem> treeItems = getVisibleExpandedItems(fTreeViewer.getTree());
if (treeItems.size() == 0) {
return;
}
// Internal
// ------------------------------------------------------------------------
- private ArrayList<TreeItem> getVisibleExpandedItems(Tree tree) {
+ private List<TreeItem> getVisibleExpandedItems(Tree tree) {
ArrayList<TreeItem> items = new ArrayList<TreeItem>();
for (TreeItem item : tree.getItems()) {
if (item.getData() == FILLER) {
return items;
}
- private ArrayList<TreeItem> getVisibleExpandedItems(TreeItem treeItem) {
+ private List<TreeItem> getVisibleExpandedItems(TreeItem treeItem) {
ArrayList<TreeItem> items = new ArrayList<TreeItem>();
for (TreeItem item : treeItem.getItems()) {
items.add(item);
if (fLinuxItemHeight != 0) {
return fLinuxItemHeight;
}
- ArrayList<TreeItem> treeItems = getVisibleExpandedItems(tree);
+ List<TreeItem> treeItems = getVisibleExpandedItems(tree);
if (treeItems.size() > 1) {
final TreeItem treeItem0 = treeItems.get(0);
final TreeItem treeItem1 = treeItems.get(1);
projects / deliverable / tracecompass.git / blobdiff