[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / viewers / events / TmfEventsTable.java

/*******************************************************************************\r
 * Copyright (c) 2010 Ericsson\r
 *\r
 * All rights reserved. This program and the accompanying materials are\r
 * made available under the terms of the Eclipse Public License v1.0 which\r
 * accompanies this distribution, and is available at\r
 * http://www.eclipse.org/legal/epl-v10.html\r
 *\r
 * Contributors:\r
 *   Francois Chouinard - Initial API and implementation\r
 *   Patrick Tasse - Factored out from events view\r
 *   Francois Chouinard - Replaced Table by TmfVirtualTable\r
 *   Patrick Tasse - Filter implementation (inspired by www.eclipse.org/mat)\r
 *******************************************************************************/\r
\r
package org.eclipse.linuxtools.tmf.ui.viewers.events;\r
\r
import java.util.ArrayList;\r
import java.util.Arrays;\r
import java.util.HashMap;\r
import java.util.Map;\r
import java.util.Map.Entry;\r
import java.util.regex.Pattern;\r
import java.util.regex.PatternSyntaxException;\r
\r
import org.eclipse.core.resources.IFile;\r
import org.eclipse.core.resources.IMarker;\r
import org.eclipse.core.resources.IResource;\r
import org.eclipse.core.runtime.CoreException;\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.core.runtime.IStatus;\r
import org.eclipse.core.runtime.Status;\r
import org.eclipse.core.runtime.jobs.Job;\r
import org.eclipse.jface.action.Action;\r
import org.eclipse.jface.action.IAction;\r
import org.eclipse.jface.action.IMenuListener;\r
import org.eclipse.jface.action.IMenuManager;\r
import org.eclipse.jface.action.MenuManager;\r
import org.eclipse.jface.action.Separator;\r
import org.eclipse.jface.dialogs.Dialog;\r
import org.eclipse.jface.dialogs.InputDialog;\r
import org.eclipse.jface.dialogs.MessageDialog;\r
import org.eclipse.jface.resource.FontDescriptor;\r
import org.eclipse.jface.resource.JFaceResources;\r
import org.eclipse.jface.resource.LocalResourceManager;\r
import org.eclipse.linuxtools.internal.tmf.ui.Messages;\r
import org.eclipse.linuxtools.internal.tmf.ui.TmfUiPlugin;\r
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;\r
import org.eclipse.linuxtools.tmf.core.component.TmfComponent;\r
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;\r
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;\r
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;\r
import org.eclipse.linuxtools.tmf.core.filter.ITmfFilter;\r
import org.eclipse.linuxtools.tmf.core.filter.model.ITmfFilterTreeNode;\r
import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterAndNode;\r
import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterMatchesNode;\r
import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterNode;\r
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;\r
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;\r
import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentUpdatedSignal;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal;\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\r
import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsCache.CachedEvent;\r
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSetting;\r
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;\r
import org.eclipse.linuxtools.tmf.ui.views.colors.IColorSettingsListener;\r
import org.eclipse.linuxtools.tmf.ui.views.filter.FilterManager;\r
import org.eclipse.linuxtools.tmf.ui.widgets.ColumnData;\r
import org.eclipse.linuxtools.tmf.ui.widgets.TmfRawEventViewer;\r
import org.eclipse.linuxtools.tmf.ui.widgets.TmfVirtualTable;\r
import org.eclipse.swt.SWT;\r
import org.eclipse.swt.custom.SashForm;\r
import org.eclipse.swt.custom.TableEditor;\r
import org.eclipse.swt.events.FocusAdapter;\r
import org.eclipse.swt.events.FocusEvent;\r
import org.eclipse.swt.events.KeyAdapter;\r
import org.eclipse.swt.events.KeyEvent;\r
import org.eclipse.swt.events.MouseAdapter;\r
import org.eclipse.swt.events.MouseEvent;\r
import org.eclipse.swt.events.SelectionAdapter;\r
import org.eclipse.swt.events.SelectionEvent;\r
import org.eclipse.swt.graphics.Color;\r
import org.eclipse.swt.graphics.Font;\r
import org.eclipse.swt.graphics.Image;\r
import org.eclipse.swt.graphics.Point;\r
import org.eclipse.swt.graphics.Rectangle;\r
import org.eclipse.swt.layout.FillLayout;\r
import org.eclipse.swt.layout.GridData;\r
import org.eclipse.swt.layout.GridLayout;\r
import org.eclipse.swt.widgets.Composite;\r
import org.eclipse.swt.widgets.Display;\r
import org.eclipse.swt.widgets.Event;\r
import org.eclipse.swt.widgets.Label;\r
import org.eclipse.swt.widgets.Listener;\r
import org.eclipse.swt.widgets.Menu;\r
import org.eclipse.swt.widgets.MessageBox;\r
import org.eclipse.swt.widgets.Shell;\r
import org.eclipse.swt.widgets.TableColumn;\r
import org.eclipse.swt.widgets.TableItem;\r
import org.eclipse.swt.widgets.Text;\r
import org.eclipse.ui.PlatformUI;\r
import org.eclipse.ui.ide.IGotoMarker;\r
import org.eclipse.ui.themes.ColorUtil;\r
\r
/**\r
 * <b><u>TmfEventsTable</u></b>\r
 */\r
public class TmfEventsTable extends TmfComponent implements IGotoMarker, IColorSettingsListener,\r
        ITmfEventsFilterProvider {\r
\r
    private static final Image BOOKMARK_IMAGE = TmfUiPlugin.getDefault().getImageFromPath(\r
            "icons/elcl16/bookmark_obj.gif"); //$NON-NLS-1$\r
    private static final Image SEARCH_IMAGE = TmfUiPlugin.getDefault().getImageFromPath("icons/elcl16/search.gif"); //$NON-NLS-1$\r
    private static final Image SEARCH_MATCH_IMAGE = TmfUiPlugin.getDefault().getImageFromPath(\r
            "icons/elcl16/search_match.gif"); //$NON-NLS-1$\r
    private static final Image SEARCH_MATCH_BOOKMARK_IMAGE = TmfUiPlugin.getDefault().getImageFromPath(\r
            "icons/elcl16/search_match_bookmark.gif"); //$NON-NLS-1$\r
    private static final Image FILTER_IMAGE = TmfUiPlugin.getDefault()\r
            .getImageFromPath("icons/elcl16/filter_items.gif"); //$NON-NLS-1$\r
    private static final Image STOP_IMAGE = TmfUiPlugin.getDefault().getImageFromPath("icons/elcl16/stop.gif"); //$NON-NLS-1$\r
    private static final String SEARCH_HINT = Messages.TmfEventsTable_SearchHint;\r
    private static final String FILTER_HINT = Messages.TmfEventsTable_FilterHint;\r
    private static final int MAX_CACHE_SIZE = 1000;\r
\r
    public interface Key {\r
        String SEARCH_TXT = "$srch_txt"; //$NON-NLS-1$\r
        String SEARCH_OBJ = "$srch_obj"; //$NON-NLS-1$\r
        String FILTER_TXT = "$fltr_txt"; //$NON-NLS-1$\r
        String FILTER_OBJ = "$fltr_obj"; //$NON-NLS-1$\r
        String TIMESTAMP = "$time"; //$NON-NLS-1$\r
        String RANK = "$rank"; //$NON-NLS-1$\r
        String FIELD_ID = "$field_id"; //$NON-NLS-1$\r
        String BOOKMARK = "$bookmark"; //$NON-NLS-1$\r
    }\r
\r
    public static enum HeaderState {\r
        SEARCH, FILTER\r
    }\r
\r
    interface Direction {\r
        int FORWARD = +1;\r
        int BACKWARD = -1;\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Table data\r
    // ------------------------------------------------------------------------\r
\r
    protected Composite fComposite;\r
    protected SashForm fSashForm;\r
    protected TmfVirtualTable fTable;\r
    protected TmfRawEventViewer fRawViewer;\r
    protected ITmfTrace<?> fTrace;\r
    protected boolean fPackDone = false;\r
    protected HeaderState fHeaderState = HeaderState.SEARCH;\r
    protected long fSelectedRank = 0;\r
\r
    // Filter data\r
    protected long fFilterMatchCount;\r
    protected long fFilterCheckCount;\r
    protected FilterThread fFilterThread;\r
    protected final Object fFilterSyncObj = new Object();\r
    protected SearchThread fSearchThread;\r
    protected final Object fSearchSyncObj = new Object();\r
    protected ArrayList<ITmfEventsFilterListener> fEventsFilterListeners = new ArrayList<ITmfEventsFilterListener>();\r
\r
    // Bookmark map <Rank, MarkerId>\r
    protected Map<Long, Long> fBookmarksMap = new HashMap<Long, Long>();\r
    protected IFile fBookmarksFile;\r
    protected long fPendingGotoRank = -1;\r
\r
    // SWT resources\r
    protected LocalResourceManager fResourceManager = new LocalResourceManager(JFaceResources.getResources());\r
    protected Color fGrayColor;\r
    protected Color fGreenColor;\r
    protected Font fBoldFont;\r
\r
    // Table column names\r
    static private final String[] COLUMN_NAMES = new String[] { Messages.TmfEventsTable_TimestampColumnHeader,\r
            Messages.TmfEventsTable_SourceColumnHeader, Messages.TmfEventsTable_TypeColumnHeader,\r
            Messages.TmfEventsTable_ReferenceColumnHeader, Messages.TmfEventsTable_ContentColumnHeader };\r
\r
    static private ColumnData[] COLUMN_DATA = new ColumnData[] { new ColumnData(COLUMN_NAMES[0], 100, SWT.LEFT),\r
            new ColumnData(COLUMN_NAMES[1], 100, SWT.LEFT), new ColumnData(COLUMN_NAMES[2], 100, SWT.LEFT),\r
            new ColumnData(COLUMN_NAMES[3], 100, SWT.LEFT), new ColumnData(COLUMN_NAMES[4], 100, SWT.LEFT) };\r
\r
    // Event cache\r
    private final TmfEventsCache fCache;\r
    private boolean fCacheUpdateBusy = false;\r
    private boolean fCacheUpdatePending = false;\r
    private boolean fCacheUpdateCompleted = false;\r
    private final Object fCacheUpdateSyncObj = new Object();\r
\r
    private boolean fDisposeOnClose;\r
\r
    // ------------------------------------------------------------------------\r
    // Constructor\r
    // ------------------------------------------------------------------------\r
\r
    public TmfEventsTable(Composite parent, int cacheSize) {\r
        this(parent, cacheSize, COLUMN_DATA);\r
    }\r
\r
    public TmfEventsTable(Composite parent, int cacheSize, ColumnData[] columnData) {\r
        super("TmfEventsTable"); //$NON-NLS-1$\r
\r
        fComposite = new Composite(parent, SWT.NONE);\r
        GridLayout gl = new GridLayout(1, false);\r
        gl.marginHeight = 0;\r
        gl.marginWidth = 0;\r
        gl.verticalSpacing = 0;\r
        fComposite.setLayout(gl);\r
\r
        fSashForm = new SashForm(fComposite, SWT.HORIZONTAL);\r
        fSashForm.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));\r
\r
        // Create a virtual table\r
        final int style = SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE | SWT.FULL_SELECTION;\r
        fTable = new TmfVirtualTable(fSashForm, style);\r
\r
        // Set the table layout\r
        GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);\r
        fTable.setLayoutData(layoutData);\r
\r
        // Some cosmetic enhancements\r
        fTable.setHeaderVisible(true);\r
        fTable.setLinesVisible(true);\r
\r
        // Set the columns\r
        setColumnHeaders(columnData);\r
\r
        // Set the default column field ids if this is not a subclass\r
        if (Arrays.equals(columnData, COLUMN_DATA)) {\r
            fTable.getColumns()[0].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_TIMESTAMP);\r
            fTable.getColumns()[1].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_SOURCE);\r
            fTable.getColumns()[2].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_TYPE);\r
            fTable.getColumns()[3].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_REFERENCE);\r
            fTable.getColumns()[4].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_CONTENT);\r
        }\r
\r
        // Set the frozen row for header row\r
        fTable.setFrozenRowCount(1);\r
\r
        // Create the header row cell editor\r
        createHeaderEditor();\r
\r
        // Handle the table item selection\r
        fTable.addSelectionListener(new SelectionAdapter() {\r
            @Override\r
            public void widgetSelected(SelectionEvent e) {\r
                TableItem[] selection = fTable.getSelection();\r
                if (selection.length > 0) {\r
                    TableItem selectedTableItem = selection[0];\r
                    if (selectedTableItem != null) {\r
                        if (selectedTableItem.getData(Key.RANK) instanceof Long) {\r
                            fSelectedRank = (Long) selectedTableItem.getData(Key.RANK);\r
                            fRawViewer.selectAndReveal((Long) selectedTableItem.getData(Key.RANK));\r
                        }\r
                        if (selectedTableItem.getData(Key.TIMESTAMP) instanceof TmfTimestamp) {\r
                            TmfTimestamp ts = (TmfTimestamp) selectedTableItem.getData(Key.TIMESTAMP);\r
                            broadcast(new TmfTimeSynchSignal(fTable, ts));\r
                        }\r
                    }\r
                }\r
            }\r
        });\r
\r
        cacheSize = Math.max(cacheSize, Display.getDefault().getBounds().height / fTable.getItemHeight());\r
        cacheSize = Math.min(cacheSize, MAX_CACHE_SIZE);\r
        fCache = new TmfEventsCache(cacheSize, this);\r
\r
        // Handle the table item requests\r
        fTable.addListener(SWT.SetData, new Listener() {\r
\r
            @Override\r
            public void handleEvent(Event event) {\r
\r
                final TableItem item = (TableItem) event.item;\r
                int index = event.index - 1; // -1 for the header row\r
\r
                if (event.index == 0) {\r
                    setHeaderRowItemData(item);\r
                    return;\r
                }\r
\r
                if (fTable.getData(Key.FILTER_OBJ) != null) {\r
                    if ((event.index == 1) || (event.index == (fTable.getItemCount() - 1))) {\r
                        setFilterStatusRowItemData(item);\r
                        return;\r
                    }\r
                    index = index - 1; // -1 for top filter status row\r
                }\r
\r
                CachedEvent cachedEvent = fCache.getEvent(index);\r
                if (cachedEvent != null) {\r
                    setItemData(item, cachedEvent.event, cachedEvent.rank);\r
                    return;\r
                }\r
\r
                // Else, fill the cache asynchronously (and off the UI thread)\r
                event.doit = false;\r
            }\r
        });\r
\r
        fTable.addMouseListener(new MouseAdapter() {\r
            @Override\r
            public void mouseDoubleClick(MouseEvent event) {\r
                if (event.button != 1) {\r
                    return;\r
                }\r
                // Identify the selected row\r
                Point point = new Point(event.x, event.y);\r
                TableItem item = fTable.getItem(point);\r
                if (item != null) {\r
                    Rectangle imageBounds = item.getImageBounds(0);\r
                    imageBounds.width = BOOKMARK_IMAGE.getBounds().width;\r
                    if (imageBounds.contains(point)) {\r
                        Long rank = (Long) item.getData(Key.RANK);\r
                        if (rank != null) {\r
                            toggleBookmark(rank);\r
                        }\r
                    }\r
                }\r
            }\r
        });\r
\r
        final Listener bookmarkListener = new Listener () {\r
            Shell tooltipShell = null;\r
            @Override\r
            public void handleEvent(Event event) {\r
                switch (event.type) {\r
                case SWT.MouseHover:\r
                    TableItem item = fTable.getItem(new Point(event.x, event.y));\r
                    if (item == null) {\r
                        return;\r
                    }\r
                    String tooltipText = (String) item.getData(Key.BOOKMARK);\r
                    if (tooltipText == null) {\r
                        return;\r
                    };\r
                    Rectangle bounds = item.getImageBounds(0);\r
                    if (!bounds.contains(event.x,event.y)) {\r
                        return;\r
                    }\r
                    if ((tooltipShell != null) && !tooltipShell.isDisposed()) {\r
                        tooltipShell.dispose();\r
                    }\r
                    tooltipShell = new Shell(fTable.getShell(), SWT.ON_TOP | SWT.NO_FOCUS | SWT.TOOL);\r
                    tooltipShell.setBackground(PlatformUI.getWorkbench().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND));\r
                    FillLayout layout = new FillLayout();\r
                    layout.marginWidth = 2;\r
                    tooltipShell.setLayout(layout);\r
                    Label label = new Label(tooltipShell, SWT.WRAP);\r
                    label.setForeground(PlatformUI.getWorkbench().getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND));\r
                    label.setBackground(PlatformUI.getWorkbench().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND));\r
                    label.setText(tooltipText);\r
                    label.addListener(SWT.MouseExit, this);\r
                    label.addListener(SWT.MouseDown, this);\r
                    label.addListener(SWT.MouseWheel, this);\r
                    Point size = tooltipShell.computeSize(SWT.DEFAULT, SWT.DEFAULT);\r
                    Point pt = fTable.toDisplay(event.x, event.y);\r
                    tooltipShell.setBounds(pt.x, pt.y, size.x, size.y);\r
                    tooltipShell.setVisible(true);\r
                    break;\r
                case SWT.Dispose:\r
                case SWT.KeyDown:\r
                case SWT.MouseMove:\r
                case SWT.MouseExit:\r
                case SWT.MouseDown:\r
                case SWT.MouseWheel:\r
                    if (tooltipShell != null) {\r
                        tooltipShell.dispose();\r
                        tooltipShell = null;\r
                    }\r
                    break;\r
                }\r
            }\r
        };\r
\r
        fTable.addListener(SWT.MouseHover, bookmarkListener);\r
        fTable.addListener(SWT.Dispose, bookmarkListener);\r
        fTable.addListener(SWT.KeyDown, bookmarkListener);\r
        fTable.addListener(SWT.MouseMove, bookmarkListener);\r
        fTable.addListener(SWT.MouseExit, bookmarkListener);\r
        fTable.addListener(SWT.MouseDown, bookmarkListener);\r
        fTable.addListener(SWT.MouseWheel, bookmarkListener);\r
\r
        // Create resources\r
        createResources();\r
\r
        ColorSettingsManager.addColorSettingsListener(this);\r
\r
        fTable.setItemCount(1); // +1 for header row\r
\r
        fRawViewer = new TmfRawEventViewer(fSashForm, SWT.H_SCROLL | SWT.V_SCROLL);\r
\r
        fRawViewer.addSelectionListener(new Listener() {\r
            @Override\r
            public void handleEvent(Event e) {\r
                if (e.data instanceof Long) {\r
                    long rank = (Long) e.data;\r
                    int index = (int) rank;\r
                    if (fTable.getData(Key.FILTER_OBJ) != null) {\r
                        index = fCache.getFilteredEventIndex(rank) + 1; // +1 for top filter status row\r
                    }\r
                    fTable.setSelection(index + 1); // +1 for header row\r
                    fSelectedRank = rank;\r
                } else if (e.data instanceof ITmfLocation<?>) {\r
                    // DOES NOT WORK: rank undefined in context from seekLocation()\r
//                    ITmfLocation<?> location = (ITmfLocation<?>) e.data;\r
//                    TmfContext context = fTrace.seekLocation(location);\r
//                    fTable.setSelection((int) context.getRank());\r
                    return;\r
                } else {\r
                    return;\r
                }\r
                TableItem[] selection = fTable.getSelection();\r
                if ((selection != null) && (selection.length > 0)) {\r
                    TmfTimestamp ts = (TmfTimestamp) fTable.getSelection()[0].getData(Key.TIMESTAMP);\r
                    if (ts != null) {\r
                        broadcast(new TmfTimeSynchSignal(fTable, ts));\r
                    }\r
                }\r
            }\r
        });\r
\r
        fSashForm.setWeights(new int[] { 1, 1 });\r
        fRawViewer.setVisible(false);\r
\r
        createPopupMenu();\r
    }\r
\r
    protected void createPopupMenu() {\r
        final IAction showTableAction = new Action(Messages.TmfEventsTable_ShowTableActionText) {\r
            @Override\r
            public void run() {\r
                fTable.setVisible(true);\r
                fSashForm.layout();\r
            }\r
        };\r
\r
        final IAction hideTableAction = new Action(Messages.TmfEventsTable_HideTableActionText) {\r
            @Override\r
            public void run() {\r
                fTable.setVisible(false);\r
                fSashForm.layout();\r
            }\r
        };\r
\r
        final IAction showRawAction = new Action(Messages.TmfEventsTable_ShowRawActionText) {\r
            @Override\r
            public void run() {\r
                fRawViewer.setVisible(true);\r
                fSashForm.layout();\r
                int index = fTable.getSelectionIndex();\r
                if (index >= +1) { // +1 for header row\r
                    fRawViewer.selectAndReveal(index - 1);\r
                }\r
            }\r
        };\r
\r
        final IAction hideRawAction = new Action(Messages.TmfEventsTable_HideRawActionText) {\r
            @Override\r
            public void run() {\r
                fRawViewer.setVisible(false);\r
                fSashForm.layout();\r
            }\r
        };\r
\r
        final IAction showSearchBarAction = new Action(Messages.TmfEventsTable_ShowSearchBarActionText) {\r
            @Override\r
            public void run() {\r
                fHeaderState = HeaderState.SEARCH;\r
                fTable.refresh();\r
            }\r
        };\r
\r
        final IAction showFilterBarAction = new Action(Messages.TmfEventsTable_ShowFilterBarActionText) {\r
            @Override\r
            public void run() {\r
                fHeaderState = HeaderState.FILTER;\r
                fTable.refresh();\r
            }\r
        };\r
\r
        final IAction clearFiltersAction = new Action(Messages.TmfEventsTable_ClearFiltersActionText) {\r
            @Override\r
            public void run() {\r
                stopFilterThread();\r
                stopSearchThread();\r
                clearFilters();\r
            }\r
        };\r
\r
        class ToggleBookmarkAction extends Action {\r
            long fRank;\r
\r
            public ToggleBookmarkAction(String text, long rank) {\r
                super(text);\r
                fRank = rank;\r
            }\r
\r
            @Override\r
            public void run() {\r
                toggleBookmark(fRank);\r
            }\r
        }\r
\r
        final MenuManager tablePopupMenu = new MenuManager();\r
        tablePopupMenu.setRemoveAllWhenShown(true);\r
        tablePopupMenu.addMenuListener(new IMenuListener() {\r
            @Override\r
            public void menuAboutToShow(IMenuManager manager) {\r
                if (fTable.getSelectionIndex() == 0) {\r
                    // Right-click on header row\r
                    if (fHeaderState == HeaderState.FILTER) {\r
                        tablePopupMenu.add(showSearchBarAction);\r
                    } else {\r
                        tablePopupMenu.add(showFilterBarAction);\r
                    }\r
                    return;\r
                }\r
                Point point = fTable.toControl(Display.getDefault().getCursorLocation());\r
                TableItem item = fTable.getSelection().length > 0 ? fTable.getSelection()[0] : null;\r
                if (item != null) {\r
                    Rectangle imageBounds = item.getImageBounds(0);\r
                    imageBounds.width = BOOKMARK_IMAGE.getBounds().width;\r
                    if (point.x <= (imageBounds.x + imageBounds.width)) {\r
                        // Right-click on left margin\r
                        Long rank = (Long) item.getData(Key.RANK);\r
                        if ((rank != null) && (fBookmarksFile != null)) {\r
                            if (fBookmarksMap.containsKey(rank)) {\r
                                tablePopupMenu.add(new ToggleBookmarkAction(\r
                                        Messages.TmfEventsTable_RemoveBookmarkActionText, rank));\r
                            } else {\r
                                tablePopupMenu.add(new ToggleBookmarkAction(\r
                                        Messages.TmfEventsTable_AddBookmarkActionText, rank));\r
                            }\r
                        }\r
                        return;\r
                    }\r
                }\r
                // Right-click on table\r
                if (fTable.isVisible() && fRawViewer.isVisible()) {\r
                    tablePopupMenu.add(hideTableAction);\r
                    tablePopupMenu.add(hideRawAction);\r
                } else if (!fTable.isVisible()) {\r
                    tablePopupMenu.add(showTableAction);\r
                } else if (!fRawViewer.isVisible()) {\r
                    tablePopupMenu.add(showRawAction);\r
                }\r
                tablePopupMenu.add(new Separator());\r
                tablePopupMenu.add(clearFiltersAction);\r
                ITmfFilterTreeNode[] savedFilters = FilterManager.getSavedFilters();\r
                if (savedFilters.length > 0) {\r
                    MenuManager subMenu = new MenuManager(Messages.TmfEventsTable_ApplyPresetFilterMenuName);\r
                    for (ITmfFilterTreeNode node : savedFilters) {\r
                        if (node instanceof TmfFilterNode) {\r
                            final TmfFilterNode filter = (TmfFilterNode) node;\r
                            subMenu.add(new Action(filter.getFilterName()) {\r
                                @Override\r
                                public void run() {\r
                                    stopFilterThread();\r
                                    fFilterMatchCount = 0;\r
                                    fFilterCheckCount = 0;\r
                                    fCache.applyFilter(filter);\r
                                    fTable.clearAll();\r
                                    fTable.setData(Key.FILTER_OBJ, filter);\r
                                    fTable.setItemCount(3); // +1 for header row, +2 for top and bottom filter status\r
                                                            // rows\r
                                    startFilterThread();\r
                                    fireFilterApplied(filter);\r
                                }\r
                            });\r
                        }\r
                    }\r
                    tablePopupMenu.add(subMenu);\r
                }\r
                appendToTablePopupMenu(tablePopupMenu, item);\r
            }\r
        });\r
\r
        final MenuManager rawViewerPopupMenu = new MenuManager();\r
        rawViewerPopupMenu.setRemoveAllWhenShown(true);\r
        rawViewerPopupMenu.addMenuListener(new IMenuListener() {\r
            @Override\r
            public void menuAboutToShow(IMenuManager manager) {\r
                if (fTable.isVisible() && fRawViewer.isVisible()) {\r
                    rawViewerPopupMenu.add(hideTableAction);\r
                    rawViewerPopupMenu.add(hideRawAction);\r
                } else if (!fTable.isVisible()) {\r
                    rawViewerPopupMenu.add(showTableAction);\r
                } else if (!fRawViewer.isVisible()) {\r
                    rawViewerPopupMenu.add(showRawAction);\r
                }\r
                appendToRawPopupMenu(tablePopupMenu);\r
            }\r
        });\r
\r
        Menu menu = tablePopupMenu.createContextMenu(fTable);\r
        fTable.setMenu(menu);\r
\r
        menu = rawViewerPopupMenu.createContextMenu(fRawViewer);\r
        fRawViewer.setMenu(menu);\r
    }\r
\r
    protected void appendToTablePopupMenu(MenuManager tablePopupMenu, TableItem selectedItem) {\r
        // override to append more actions\r
    }\r
\r
    protected void appendToRawPopupMenu(MenuManager rawViewerPopupMenu) {\r
        // override to append more actions\r
    }\r
\r
    @Override\r
    public void dispose() {\r
        stopSearchThread();\r
        stopFilterThread();\r
        ColorSettingsManager.removeColorSettingsListener(this);\r
        fComposite.dispose();\r
        if ((fTrace != null) && fDisposeOnClose) {\r
            fTrace.dispose();\r
        }\r
        fResourceManager.dispose();\r
        super.dispose();\r
    }\r
\r
    public void setLayoutData(Object layoutData) {\r
        fComposite.setLayoutData(layoutData);\r
    }\r
\r
    public TmfVirtualTable getTable() {\r
        return fTable;\r
    }\r
\r
    /**\r
     * @param columnData\r
     *\r
     * FIXME: Add support for column selection\r
     */\r
    protected void setColumnHeaders(ColumnData[] columnData) {\r
        fTable.setColumnHeaders(columnData);\r
    }\r
\r
    protected void setItemData(TableItem item, ITmfEvent event, long rank) {\r
        ITmfEventField[] fields = extractItemFields(event);\r
        String[] content = new String[fields.length];\r
        for (int i = 0; i < fields.length; i++) {\r
            content[i] = fields[i].getValue() != null ? fields[i].getValue().toString() : ""; //$NON-NLS-1$\r
        }\r
        item.setText(content);\r
        item.setData(Key.TIMESTAMP, new TmfTimestamp(event.getTimestamp()));\r
        item.setData(Key.RANK, rank);\r
\r
        boolean bookmark = false;\r
        Long markerId = fBookmarksMap.get(rank);\r
        if (markerId != null) {\r
            bookmark = true;\r
            try {\r
                IMarker marker = fBookmarksFile.findMarker(markerId);\r
                item.setData(Key.BOOKMARK, marker.getAttribute(IMarker.MESSAGE));\r
            } catch (CoreException e) {\r
                displayException(e);\r
            }\r
        } else {\r
            item.setData(Key.BOOKMARK, null);\r
        }\r
\r
        boolean searchMatch = false;\r
        boolean searchNoMatch = false;\r
        ITmfFilter searchFilter = (ITmfFilter) fTable.getData(Key.SEARCH_OBJ);\r
        if (searchFilter != null) {\r
            if (searchFilter.matches(event)) {\r
                searchMatch = true;\r
            } else {\r
                searchNoMatch = true;\r
            }\r
        }\r
\r
        ColorSetting colorSetting = ColorSettingsManager.getColorSetting(event);\r
        if (searchNoMatch) {\r
            item.setForeground(colorSetting.getDimmedForegroundColor());\r
            item.setBackground(colorSetting.getDimmedBackgroundColor());\r
        } else {\r
            item.setForeground(colorSetting.getForegroundColor());\r
            item.setBackground(colorSetting.getBackgroundColor());\r
        }\r
\r
        if (searchMatch) {\r
            if (bookmark) {\r
                item.setImage(SEARCH_MATCH_BOOKMARK_IMAGE);\r
            } else {\r
                item.setImage(SEARCH_MATCH_IMAGE);\r
            }\r
        } else if (bookmark) {\r
            item.setImage(BOOKMARK_IMAGE);\r
        } else {\r
            item.setImage((Image) null);\r
        }\r
    }\r
\r
    protected void setHeaderRowItemData(TableItem item) {\r
        String txtKey = null;\r
        if (fHeaderState == HeaderState.SEARCH) {\r
            item.setImage(SEARCH_IMAGE);\r
            txtKey = Key.SEARCH_TXT;\r
        } else if (fHeaderState == HeaderState.FILTER) {\r
            item.setImage(FILTER_IMAGE);\r
            txtKey = Key.FILTER_TXT;\r
        }\r
        item.setForeground(fGrayColor);\r
        for (int i = 0; i < fTable.getColumns().length; i++) {\r
            TableColumn column = fTable.getColumns()[i];\r
            String filter = (String) column.getData(txtKey);\r
            if (filter == null) {\r
                if (fHeaderState == HeaderState.SEARCH) {\r
                    item.setText(i, SEARCH_HINT);\r
                } else if (fHeaderState == HeaderState.FILTER) {\r
                    item.setText(i, FILTER_HINT);\r
                }\r
                item.setForeground(i, fGrayColor);\r
                item.setFont(i, fTable.getFont());\r
            } else {\r
                item.setText(i, filter);\r
                item.setForeground(i, fGreenColor);\r
                item.setFont(i, fBoldFont);\r
            }\r
        }\r
    }\r
\r
    protected void setFilterStatusRowItemData(TableItem item) {\r
        for (int i = 0; i < fTable.getColumns().length; i++) {\r
            if (i == 0) {\r
                if ((fTrace == null) || (fFilterCheckCount == fTrace.getNbEvents())) {\r
                    item.setImage(FILTER_IMAGE);\r
                } else {\r
                    item.setImage(STOP_IMAGE);\r
                }\r
                item.setText(0, fFilterMatchCount + "/" + fFilterCheckCount); //$NON-NLS-1$\r
            } else {\r
                item.setText(i, ""); //$NON-NLS-1$\r
            }\r
        }\r
        item.setData(Key.TIMESTAMP, null);\r
        item.setData(Key.RANK, null);\r
        item.setForeground(null);\r
        item.setBackground(null);\r
    }\r
\r
    protected void createHeaderEditor() {\r
        final TableEditor tableEditor = fTable.createTableEditor();\r
        tableEditor.horizontalAlignment = SWT.LEFT;\r
        tableEditor.verticalAlignment = SWT.CENTER;\r
        tableEditor.grabHorizontal = true;\r
        tableEditor.minimumWidth = 50;\r
\r
        // Handle the header row selection\r
        fTable.addMouseListener(new MouseAdapter() {\r
            int columnIndex;\r
            TableColumn column;\r
            TableItem item;\r
\r
            @Override\r
            public void mouseDown(MouseEvent event) {\r
                if (event.button != 1) {\r
                    return;\r
                }\r
                // Identify the selected row\r
                Point point = new Point(event.x, event.y);\r
                item = fTable.getItem(point);\r
\r
                // Header row selected\r
                if ((item != null) && (fTable.indexOf(item) == 0)) {\r
\r
                    // Icon selected\r
                    if (item.getImageBounds(0).contains(point)) {\r
                        if (fHeaderState == HeaderState.SEARCH) {\r
                            fHeaderState = HeaderState.FILTER;\r
                        } else if (fHeaderState == HeaderState.FILTER) {\r
                            fHeaderState = HeaderState.SEARCH;\r
                        }\r
                        fTable.refresh();\r
                        return;\r
                    }\r
\r
                    // Identify the selected column\r
                    columnIndex = -1;\r
                    for (int i = 0; i < fTable.getColumns().length; i++) {\r
                        Rectangle rect = item.getBounds(i);\r
                        if (rect.contains(point)) {\r
                            columnIndex = i;\r
                            break;\r
                        }\r
                    }\r
\r
                    if (columnIndex == -1) {\r
                        return;\r
                    }\r
\r
                    column = fTable.getColumns()[columnIndex];\r
\r
                    String txtKey = null;\r
                    if (fHeaderState == HeaderState.SEARCH) {\r
                        txtKey = Key.SEARCH_TXT;\r
                    } else if (fHeaderState == HeaderState.FILTER) {\r
                        txtKey = Key.FILTER_TXT;\r
                    }\r
\r
                    // The control that will be the editor must be a child of the Table\r
                    final Text newEditor = (Text) fTable.createTableEditorControl(Text.class);\r
                    String headerString = (String) column.getData(txtKey);\r
                    if (headerString != null) {\r
                        newEditor.setText(headerString);\r
                    }\r
                    newEditor.addFocusListener(new FocusAdapter() {\r
                        @Override\r
                        public void focusLost(FocusEvent e) {\r
                            boolean changed = updateHeader(newEditor.getText());\r
                            if (changed) {\r
                                applyHeader();\r
                            }\r
                        }\r
                    });\r
                    newEditor.addKeyListener(new KeyAdapter() {\r
                        @Override\r
                        public void keyPressed(KeyEvent e) {\r
                            if (e.character == SWT.CR) {\r
                                updateHeader(newEditor.getText());\r
                                applyHeader();\r
                            } else if (e.character == SWT.ESC) {\r
                                tableEditor.getEditor().dispose();\r
                            }\r
                        }\r
                    });\r
                    newEditor.selectAll();\r
                    newEditor.setFocus();\r
                    tableEditor.setEditor(newEditor, item, columnIndex);\r
                }\r
            }\r
\r
            /*\r
             * returns true is value was changed\r
             */\r
            private boolean updateHeader(String text) {\r
                String objKey = null;\r
                String txtKey = null;\r
                if (fHeaderState == HeaderState.SEARCH) {\r
                    objKey = Key.SEARCH_OBJ;\r
                    txtKey = Key.SEARCH_TXT;\r
                } else if (fHeaderState == HeaderState.FILTER) {\r
                    objKey = Key.FILTER_OBJ;\r
                    txtKey = Key.FILTER_TXT;\r
                }\r
                if (text.trim().length() > 0) {\r
                    try {\r
                        String regex = TmfFilterMatchesNode.regexFix(text);\r
                        Pattern.compile(regex);\r
                        if (regex.equals(column.getData(txtKey))) {\r
                            tableEditor.getEditor().dispose();\r
                            return false;\r
                        }\r
                        TmfFilterMatchesNode filter = new TmfFilterMatchesNode(null);\r
                        String fieldId = (String) column.getData(Key.FIELD_ID);\r
                        if (fieldId == null) {\r
                            fieldId = column.getText();\r
                        }\r
                        filter.setField(fieldId);\r
                        filter.setRegex(regex);\r
                        column.setData(objKey, filter);\r
                        column.setData(txtKey, regex);\r
                    } catch (PatternSyntaxException ex) {\r
                        tableEditor.getEditor().dispose();\r
                        MessageDialog.openError(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),\r
                                ex.getDescription(), ex.getMessage());\r
                        return false;\r
                    }\r
                } else {\r
                    if (column.getData(txtKey) == null) {\r
                        tableEditor.getEditor().dispose();\r
                        return false;\r
                    }\r
                    column.setData(objKey, null);\r
                    column.setData(txtKey, null);\r
                }\r
                return true;\r
            }\r
\r
            private void applyHeader() {\r
                stopSearchThread();\r
                if (fHeaderState == HeaderState.SEARCH) {\r
                    final TmfFilterAndNode filter = new TmfFilterAndNode(null);\r
                    for (TableColumn column : fTable.getColumns()) {\r
                        Object filterObj = column.getData(Key.SEARCH_OBJ);\r
                        if (filterObj instanceof ITmfFilterTreeNode) {\r
                            filter.addChild((ITmfFilterTreeNode) filterObj);\r
                        }\r
                    }\r
                    if (filter.getChildrenCount() > 0) {\r
                        fTable.setData(Key.SEARCH_OBJ, filter);\r
                        fTable.refresh();\r
                        searchNext();\r
                        fireSearchApplied(filter);\r
                    } else {\r
                        fTable.setData(Key.SEARCH_OBJ, null);\r
                        fTable.refresh();\r
                        fireSearchApplied(null);\r
                    }\r
                } else if (fHeaderState == HeaderState.FILTER) {\r
                    stopFilterThread();\r
                    fFilterMatchCount = 0;\r
                    fFilterCheckCount = 0;\r
                    TmfFilterAndNode filter = new TmfFilterAndNode(null);\r
                    for (TableColumn column : fTable.getColumns()) {\r
                        Object filterObj = column.getData(Key.FILTER_OBJ);\r
                        if (filterObj instanceof ITmfFilterTreeNode) {\r
                            filter.addChild((ITmfFilterTreeNode) filterObj);\r
                        }\r
                    }\r
                    if (filter.getChildrenCount() > 0) {\r
                        fCache.applyFilter(filter);\r
                        fTable.clearAll();\r
                        fTable.setData(Key.FILTER_OBJ, filter);\r
                        fTable.setItemCount(3); // +1 for header row, +2 for top and bottom filter status rows\r
                        startFilterThread();\r
                        fireFilterApplied(filter);\r
                    } else {\r
                        fCache.clearFilter();\r
                        stopFilterThread();\r
                        fTable.clearAll();\r
                        fTable.setData(Key.FILTER_OBJ, null);\r
                        if (fTrace != null) {\r
                            fTable.setItemCount((int) fTrace.getNbEvents() + 1); // +1 for header row\r
                        } else {\r
                            fTable.setItemCount(1); // +1 for header row\r
                        }\r
                        fireFilterApplied(null);\r
                    }\r
                }\r
\r
                tableEditor.getEditor().dispose();\r
            }\r
        });\r
\r
        fTable.addKeyListener(new KeyAdapter() {\r
            @Override\r
            public void keyPressed(KeyEvent e) {\r
                e.doit = false;\r
                if (e.character == SWT.ESC) {\r
                    stopFilterThread();\r
                    stopSearchThread();\r
                    fTable.refresh();\r
                } else if (e.character == SWT.DEL) {\r
                    stopFilterThread();\r
                    stopSearchThread();\r
                    if (fHeaderState == HeaderState.SEARCH) {\r
                        for (TableColumn column : fTable.getColumns()) {\r
                            column.setData(Key.SEARCH_OBJ, null);\r
                            column.setData(Key.SEARCH_TXT, null);\r
                        }\r
                        fTable.setData(Key.SEARCH_OBJ, null);\r
                        fTable.refresh();\r
                        fireSearchApplied(null);\r
                    } else if (fHeaderState == HeaderState.FILTER) {\r
                        clearFilters();\r
                    }\r
                } else if (e.character == SWT.CR) {\r
                    if ((e.stateMask & SWT.SHIFT) == 0) {\r
                        searchNext();\r
                    } else {\r
                        searchPrevious();\r
                    }\r
                }\r
            }\r
        });\r
    }\r
\r
    protected void fireFilterApplied(ITmfFilter filter) {\r
        for (ITmfEventsFilterListener listener : fEventsFilterListeners) {\r
            listener.filterApplied(filter, fTrace);\r
        }\r
    }\r
\r
    protected void fireSearchApplied(ITmfFilter filter) {\r
        for (ITmfEventsFilterListener listener : fEventsFilterListeners) {\r
            listener.searchApplied(filter, fTrace);\r
        }\r
    }\r
\r
    protected void startFilterThread() {\r
        synchronized (fFilterSyncObj) {\r
            if (fFilterThread != null) {\r
                fFilterThread.cancel();\r
            }\r
            final ITmfFilterTreeNode filter = (ITmfFilterTreeNode) fTable.getData(Key.FILTER_OBJ);\r
            fFilterThread = new FilterThread(filter);\r
            fFilterThread.start();\r
        }\r
    }\r
\r
    protected void stopFilterThread() {\r
        synchronized (fFilterSyncObj) {\r
            if (fFilterThread != null) {\r
                fFilterThread.cancel();\r
            }\r
        }\r
    }\r
\r
    protected void clearFilters() {\r
        if (fTable.getData(Key.FILTER_OBJ) == null) {\r
            return;\r
        }\r
        fCache.clearFilter();\r
        fTable.clearAll();\r
        for (TableColumn column : fTable.getColumns()) {\r
            column.setData(Key.FILTER_OBJ, null);\r
            column.setData(Key.FILTER_TXT, null);\r
        }\r
        fTable.setData(Key.FILTER_OBJ, null);\r
        if (fTrace != null) {\r
            fTable.setItemCount((int) fTrace.getNbEvents() + 1); // +1 for header row\r
        } else {\r
            fTable.setItemCount(1); // +1 for header row\r
        }\r
        fFilterMatchCount = 0;\r
        fFilterCheckCount = 0;\r
        if (fSelectedRank >= 0) {\r
            fTable.setSelection((int) fSelectedRank + 1); // +1 for header row\r
        } else {\r
            fTable.setSelection(0);\r
        }\r
        fireFilterApplied(null);\r
    }\r
\r
    protected class FilterThread extends Thread {\r
        private final ITmfFilterTreeNode filter;\r
        private TmfEventRequest<TmfEvent> request;\r
        private boolean refreshBusy = false;\r
        private boolean refreshPending = false;\r
        private final Object syncObj = new Object();\r
\r
        public FilterThread(ITmfFilterTreeNode filter) {\r
            super("Filter Thread"); //$NON-NLS-1$\r
            this.filter = filter;\r
        }\r
\r
        @SuppressWarnings("unchecked")\r
        @Override\r
        public void run() {\r
            if (fTrace == null) {\r
                return;\r
            }\r
            int nbRequested = (int) (fTrace.getNbEvents() - fFilterCheckCount);\r
            if (nbRequested <= 0) {\r
                return;\r
            }\r
            request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.ETERNITY, (int) fFilterCheckCount,\r
                    nbRequested, fTrace.getIndexPageSize(), ExecutionType.BACKGROUND) {\r
                @Override\r
                public void handleData(TmfEvent event) {\r
                    super.handleData(event);\r
                    if (request.isCancelled()) {\r
                        return;\r
                    }\r
                    if (filter.matches(event)) {\r
                        long rank = fFilterCheckCount;\r
                        int index = (int) fFilterMatchCount;\r
                        fFilterMatchCount++;\r
                        fCache.storeEvent(event.clone(), rank, index);\r
                        refreshTable();\r
                    } else if ((fFilterCheckCount % 100) == 0) {\r
                        refreshTable();\r
                    }\r
                    fFilterCheckCount++;\r
                }\r
            };\r
            ((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(request);\r
            try {\r
                request.waitForCompletion();\r
            } catch (InterruptedException e) {\r
            }\r
            refreshTable();\r
        }\r
\r
        public void refreshTable() {\r
            synchronized (syncObj) {\r
                if (refreshBusy) {\r
                    refreshPending = true;\r
                    return;\r
                } else {\r
                    refreshBusy = true;\r
                }\r
            }\r
            Display.getDefault().asyncExec(new Runnable() {\r
                @Override\r
                public void run() {\r
                    if (request.isCancelled()) {\r
                        return;\r
                    }\r
                    if (fTable.isDisposed()) {\r
                        return;\r
                    }\r
                    fTable.setItemCount((int) fFilterMatchCount + 3); // +1 for header row, +2 for top and bottom filter\r
                                                                      // status rows\r
                    fTable.refresh();\r
                    synchronized (syncObj) {\r
                        refreshBusy = false;\r
                        if (refreshPending) {\r
                            refreshPending = false;\r
                            refreshTable();\r
                        }\r
                    }\r
                }\r
            });\r
        }\r
\r
        public void cancel() {\r
            if (request != null) {\r
                request.cancel();\r
            }\r
        }\r
    }\r
\r
    protected void searchNext() {\r
        synchronized (fSearchSyncObj) {\r
            if (fSearchThread != null) {\r
                return;\r
            }\r
            final ITmfFilterTreeNode searchFilter = (ITmfFilterTreeNode) fTable.getData(Key.SEARCH_OBJ);\r
            if (searchFilter == null) {\r
                return;\r
            }\r
            int selectionIndex = fTable.getSelectionIndex();\r
            int startIndex;\r
            if (selectionIndex > 0) {\r
                startIndex = selectionIndex; // -1 for header row, +1 for next event\r
            } else {\r
                // header row is selected, start at top event\r
                startIndex = Math.max(0, fTable.getTopIndex() - 1); // -1 for header row\r
            }\r
            final ITmfFilterTreeNode eventFilter = (ITmfFilterTreeNode) fTable.getData(Key.FILTER_OBJ);\r
            if (eventFilter != null) {\r
                startIndex = Math.max(0, startIndex - 1); // -1 for top filter status row\r
            }\r
            fSearchThread = new SearchThread(searchFilter, eventFilter, startIndex, fSelectedRank, Direction.FORWARD);\r
            fSearchThread.schedule();\r
        }\r
    }\r
\r
    protected void searchPrevious() {\r
        synchronized (fSearchSyncObj) {\r
            if (fSearchThread != null) {\r
                return;\r
            }\r
            final ITmfFilterTreeNode searchFilter = (ITmfFilterTreeNode) fTable.getData(Key.SEARCH_OBJ);\r
            if (searchFilter == null) {\r
                return;\r
            }\r
            int selectionIndex = fTable.getSelectionIndex();\r
            int startIndex;\r
            if (selectionIndex > 0) {\r
                startIndex = selectionIndex - 2; // -1 for header row, -1 for previous event\r
            } else {\r
                // header row is selected, start at precedent of top event\r
                startIndex = fTable.getTopIndex() - 2; // -1 for header row, -1 for previous event\r
            }\r
            final ITmfFilterTreeNode eventFilter = (ITmfFilterTreeNode) fTable.getData(Key.FILTER_OBJ);\r
            if (eventFilter != null) {\r
                startIndex = startIndex - 1; // -1 for top filter status row\r
            }\r
            fSearchThread = new SearchThread(searchFilter, eventFilter, startIndex, fSelectedRank, Direction.BACKWARD);\r
            fSearchThread.schedule();\r
        }\r
    }\r
\r
    protected void stopSearchThread() {\r
        fPendingGotoRank = -1;\r
        synchronized (fSearchSyncObj) {\r
            if (fSearchThread != null) {\r
                fSearchThread.cancel();\r
                fSearchThread = null;\r
            }\r
        }\r
    }\r
\r
    protected class SearchThread extends Job {\r
        protected ITmfFilterTreeNode searchFilter;\r
        protected ITmfFilterTreeNode eventFilter;\r
        protected int startIndex;\r
        protected int direction;\r
        protected long rank;\r
        protected long foundRank = -1;\r
        protected TmfDataRequest<TmfEvent> request;\r
\r
        public SearchThread(ITmfFilterTreeNode searchFilter, ITmfFilterTreeNode eventFilter, int startIndex,\r
                long currentRank, int direction) {\r
            super(Messages.TmfEventsTable_SearchingJobName);\r
            this.searchFilter = searchFilter;\r
            this.eventFilter = eventFilter;\r
            this.startIndex = startIndex;\r
            this.rank = currentRank;\r
            this.direction = direction;\r
        }\r
\r
        @SuppressWarnings("unchecked")\r
        @Override\r
        protected IStatus run(final IProgressMonitor monitor) {\r
            if (fTrace == null) {\r
                return Status.OK_STATUS;\r
            }\r
            final Display display = Display.getDefault();\r
            if (startIndex < 0) {\r
                rank = (int) fTrace.getNbEvents() - 1;\r
            } else if (startIndex >= (fTable.getItemCount() - (eventFilter == null ? 1 : 3))) { // -1 for header row, -2\r
                                                                                              // for top and bottom\r
                                                                                              // filter status rows\r
                rank = 0;\r
            } else {\r
                int idx = startIndex;\r
                while (foundRank == -1) {\r
                    CachedEvent event = fCache.peekEvent(idx);\r
                    if (event == null) {\r
                        break;\r
                    }\r
                    rank = event.rank;\r
                    if (searchFilter.matches(event.event) && ((eventFilter == null) || eventFilter.matches(event.event))) {\r
                        foundRank = event.rank;\r
                        break;\r
                    }\r
                    if (direction == Direction.FORWARD) {\r
                        idx++;\r
                    } else {\r
                        idx--;\r
                    }\r
                }\r
                if (foundRank == -1) {\r
                    if (direction == Direction.FORWARD) {\r
                        rank++;\r
                        if (rank > (fTrace.getNbEvents() - 1)) {\r
                            rank = 0;\r
                        }\r
                    } else {\r
                        rank--;\r
                        if (rank < 0) {\r
                            rank = (int) fTrace.getNbEvents() - 1;\r
                        }\r
                    }\r
                }\r
            }\r
            int startRank = (int) rank;\r
            boolean wrapped = false;\r
            while (!monitor.isCanceled() && (foundRank == -1) && (fTrace != null)) {\r
                int nbRequested = (direction == Direction.FORWARD ? Integer.MAX_VALUE : Math.min((int) rank + 1,\r
                        fTrace.getIndexPageSize()));\r
                if (direction == Direction.BACKWARD) {\r
                    rank = Math.max(0, rank - fTrace.getIndexPageSize() + 1);\r
\r
                }\r
                request = new TmfDataRequest<TmfEvent>(TmfEvent.class, (int) rank, nbRequested) {\r
                    long currentRank = rank;\r
\r
                    @Override\r
                    public void handleData(TmfEvent event) {\r
                        super.handleData(event);\r
                        if (searchFilter.matches(event) && ((eventFilter == null) || eventFilter.matches(event))) {\r
                            foundRank = currentRank;\r
                            if (direction == Direction.FORWARD) {\r
                                done();\r
                                return;\r
                            }\r
                        }\r
                        currentRank++;\r
                    }\r
                };\r
                ((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(request);\r
                try {\r
                    request.waitForCompletion();\r
                    if (request.isCancelled()) {\r
                        return Status.OK_STATUS;\r
                    }\r
                } catch (InterruptedException e) {\r
                    synchronized (fSearchSyncObj) {\r
                        fSearchThread = null;\r
                    }\r
                    return Status.OK_STATUS;\r
                }\r
                if (foundRank == -1) {\r
                    if (direction == Direction.FORWARD) {\r
                        if (rank == 0) {\r
                            synchronized (fSearchSyncObj) {\r
                                fSearchThread = null;\r
                            }\r
                            return Status.OK_STATUS;\r
                        } else {\r
                            nbRequested = (int) rank;\r
                            rank = 0;\r
                            wrapped = true;\r
                        }\r
                    } else {\r
                        rank--;\r
                        if (rank < 0) {\r
                            rank = (int) fTrace.getNbEvents() - 1;\r
                            wrapped = true;\r
                        }\r
                        if ((rank <= startRank) && wrapped) {\r
                            synchronized (fSearchSyncObj) {\r
                                fSearchThread = null;\r
                            }\r
                            return Status.OK_STATUS;\r
                        }\r
                    }\r
                }\r
            }\r
            int index = (int) foundRank;\r
            if (eventFilter != null) {\r
                index = fCache.getFilteredEventIndex(foundRank);\r
            }\r
            final int selection = index + 1 + (eventFilter != null ? +1 : 0); // +1 for header row, +1 for top filter\r
                                                                              // status row\r
\r
            display.asyncExec(new Runnable() {\r
                @Override\r
                public void run() {\r
                    if (monitor.isCanceled()) {\r
                        return;\r
                    }\r
                    if (fTable.isDisposed()) {\r
                        return;\r
                    }\r
                    fTable.setSelection(selection);\r
                    fSelectedRank = foundRank;\r
                    synchronized (fSearchSyncObj) {\r
                        fSearchThread = null;\r
                    }\r
                }\r
            });\r
            return Status.OK_STATUS;\r
        }\r
\r
        @Override\r
        protected void canceling() {\r
            request.cancel();\r
            synchronized (fSearchSyncObj) {\r
                fSearchThread = null;\r
            }\r
        }\r
    }\r
\r
    protected void createResources() {\r
        fGrayColor = fResourceManager.createColor(ColorUtil.blend(fTable.getBackground().getRGB(), fTable\r
                .getForeground().getRGB()));\r
        fGreenColor = fTable.getDisplay().getSystemColor(SWT.COLOR_DARK_GREEN);\r
        fBoldFont = fResourceManager.createFont(FontDescriptor.createFrom(fTable.getFont()).setStyle(SWT.BOLD));\r
    }\r
\r
    protected void packColumns() {\r
        if (fPackDone) {\r
            return;\r
        }\r
        for (TableColumn column : fTable.getColumns()) {\r
            int headerWidth = column.getWidth();\r
            column.pack();\r
            if (column.getWidth() < headerWidth) {\r
                column.setWidth(headerWidth);\r
            }\r
        }\r
        fPackDone = true;\r
    }\r
\r
    /**\r
     * @param event\r
     * @return\r
     *\r
     *         FIXME: Add support for column selection\r
     */\r
    protected ITmfEventField[] extractItemFields(ITmfEvent event) {\r
        ITmfEventField[] fields = new TmfEventField[0];\r
        if (event != null) {\r
            String timestamp = event.getTimestamp().toString();\r
            String source = event.getSource();\r
            String type = event.getType().getName();\r
            String reference = event.getReference();\r
            ITmfEventField content = event.getContent();\r
            String value = (content.getValue() != null) ? content.getValue().toString() : content.toString();\r
            fields = new TmfEventField[] {\r
                     new TmfEventField(ITmfEvent.EVENT_FIELD_TIMESTAMP, timestamp),\r
                     new TmfEventField(ITmfEvent.EVENT_FIELD_SOURCE, source),\r
                     new TmfEventField(ITmfEvent.EVENT_FIELD_TYPE, type),\r
                     new TmfEventField(ITmfEvent.EVENT_FIELD_REFERENCE, reference),\r
                     new TmfEventField(ITmfEvent.EVENT_FIELD_CONTENT, value)\r
                    };\r
        }\r
        return fields;\r
    }\r
\r
    public void setFocus() {\r
        fTable.setFocus();\r
    }\r
\r
    /**\r
     * @param trace\r
     * @param disposeOnClose\r
     *            true if the trace should be disposed when the table is disposed\r
     */\r
    public void setTrace(ITmfTrace<?> trace, boolean disposeOnClose) {\r
        if ((fTrace != null) && fDisposeOnClose) {\r
            fTrace.dispose();\r
        }\r
        fTrace = trace;\r
        fPackDone = false;\r
        fSelectedRank = 0;\r
        fDisposeOnClose = disposeOnClose;\r
\r
        // Perform the updates on the UI thread\r
        fTable.getDisplay().syncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                fTable.removeAll();\r
                fCache.setTrace(fTrace); // Clear the cache\r
                if (fTrace != null) {\r
                    if (!fTable.isDisposed() && (fTrace != null)) {\r
                        if (fTable.getData(Key.FILTER_OBJ) == null) {\r
                            fTable.setItemCount((int) fTrace.getNbEvents() + 1); // +1 for header row\r
                        } else {\r
                            stopFilterThread();\r
                            fFilterMatchCount = 0;\r
                            fFilterCheckCount = 0;\r
                            fTable.setItemCount(3); // +1 for header row, +2 for top and bottom filter status rows\r
                            startFilterThread();\r
                        }\r
                    }\r
                    fRawViewer.setTrace(fTrace);\r
                }\r
            }\r
        });\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Event cache\r
    // ------------------------------------------------------------------------\r
\r
    public void cacheUpdated(final boolean completed) {\r
        synchronized (fCacheUpdateSyncObj) {\r
            if (fCacheUpdateBusy) {\r
                fCacheUpdatePending = true;\r
                fCacheUpdateCompleted = completed;\r
                return;\r
            } else {\r
                fCacheUpdateBusy = true;\r
            }\r
        }\r
        // Event cache is now updated. Perform update on the UI thread\r
        if (!fTable.isDisposed()) {\r
            fTable.getDisplay().asyncExec(new Runnable() {\r
                @Override\r
                public void run() {\r
                    if (!fTable.isDisposed()) {\r
                        fTable.refresh();\r
                        packColumns();\r
                    }\r
                    if (completed) {\r
                        populateCompleted();\r
                    }\r
                    synchronized (fCacheUpdateSyncObj) {\r
                        fCacheUpdateBusy = false;\r
                        if (fCacheUpdatePending) {\r
                            fCacheUpdatePending = false;\r
                            cacheUpdated(fCacheUpdateCompleted);\r
                        }\r
                    }\r
                }\r
            });\r
        }\r
    }\r
\r
    protected void populateCompleted() {\r
        // Nothing by default;\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Bookmark handling\r
    // ------------------------------------------------------------------------\r
\r
    public void addBookmark(IFile bookmarksFile) {\r
        fBookmarksFile = bookmarksFile;\r
        TableItem[] selection = fTable.getSelection();\r
        if (selection.length > 0) {\r
            TableItem tableItem = selection[0];\r
            if (tableItem.getData(Key.RANK) != null) {\r
                StringBuffer defaultMessage = new StringBuffer();\r
                for (int i = 0; i < fTable.getColumns().length; i++) {\r
                    if (i > 0) {\r
                        defaultMessage.append(", "); //$NON-NLS-1$\r
                    }\r
                    defaultMessage.append(tableItem.getText(i));\r
                }\r
                InputDialog dialog = new InputDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),\r
                        Messages.TmfEventsTable_AddBookmarkDialogTitle, Messages.TmfEventsTable_AddBookmarkDialogText,\r
                        defaultMessage.toString(), null);\r
                if (dialog.open() == Dialog.OK) {\r
                    String message = dialog.getValue();\r
                    try {\r
                        IMarker bookmark = bookmarksFile.createMarker(IMarker.BOOKMARK);\r
                        if (bookmark.exists()) {\r
                            bookmark.setAttribute(IMarker.MESSAGE, message.toString());\r
                            long rank = (Long) tableItem.getData(Key.RANK);\r
                            int location = (int) rank;\r
                            bookmark.setAttribute(IMarker.LOCATION, (Integer) location);\r
                            fBookmarksMap.put(rank, bookmark.getId());\r
                            fTable.refresh();\r
                        }\r
                    } catch (CoreException e) {\r
                        displayException(e);\r
                    }\r
                }\r
            }\r
        }\r
\r
    }\r
\r
    public void removeBookmark(IMarker bookmark) {\r
        for (Entry<Long, Long> entry : fBookmarksMap.entrySet()) {\r
            if (entry.getValue().equals(bookmark.getId())) {\r
                fBookmarksMap.remove(entry.getKey());\r
                fTable.refresh();\r
                return;\r
            }\r
        }\r
    }\r
\r
    private void toggleBookmark(long rank) {\r
        if (fBookmarksFile == null) {\r
            return;\r
        }\r
        if (fBookmarksMap.containsKey(rank)) {\r
            Long markerId = fBookmarksMap.remove(rank);\r
            fTable.refresh();\r
            try {\r
                IMarker bookmark = fBookmarksFile.findMarker(markerId);\r
                if (bookmark != null) {\r
                    bookmark.delete();\r
                }\r
            } catch (CoreException e) {\r
                displayException(e);\r
            }\r
        } else {\r
            addBookmark(fBookmarksFile);\r
        }\r
    }\r
\r
    public void refreshBookmarks(IFile bookmarksFile) {\r
        fBookmarksFile = bookmarksFile;\r
        if (bookmarksFile == null) {\r
            fBookmarksMap.clear();\r
            fTable.refresh();\r
            return;\r
        }\r
        try {\r
            fBookmarksMap.clear();\r
            for (IMarker bookmark : bookmarksFile.findMarkers(IMarker.BOOKMARK, false, IResource.DEPTH_ZERO)) {\r
                int location = bookmark.getAttribute(IMarker.LOCATION, -1);\r
                if (location != -1) {\r
                    long rank = location;\r
                    fBookmarksMap.put(rank, bookmark.getId());\r
                }\r
            }\r
            fTable.refresh();\r
        } catch (CoreException e) {\r
            displayException(e);\r
        }\r
    }\r
\r
    @Override\r
    public void gotoMarker(IMarker marker) {\r
        int rank = marker.getAttribute(IMarker.LOCATION, -1);\r
        if (rank != -1) {\r
            int index = rank;\r
            if (fTable.getData(Key.FILTER_OBJ) != null) {\r
                index = fCache.getFilteredEventIndex(rank) + 1; // +1 for top filter status row\r
            } else if (rank >= fTable.getItemCount()) {\r
                fPendingGotoRank = rank;\r
            }\r
            fTable.setSelection(index + 1); // +1 for header row\r
        }\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Listeners\r
    // ------------------------------------------------------------------------\r
\r
    /*\r
     * (non-Javadoc)\r
     *\r
     * @see\r
     * org.eclipse.linuxtools.tmf.ui.views.colors.IColorSettingsListener#colorSettingsChanged(org.eclipse.linuxtools\r
     * .tmf.ui.views.colors.ColorSetting[])\r
     */\r
    @Override\r
    public void colorSettingsChanged(ColorSetting[] colorSettings) {\r
        fTable.refresh();\r
    }\r
\r
    @Override\r
    public void addEventsFilterListener(ITmfEventsFilterListener listener) {\r
        if (!fEventsFilterListeners.contains(listener)) {\r
            fEventsFilterListeners.add(listener);\r
        }\r
    }\r
\r
    @Override\r
    public void removeEventsFilterListener(ITmfEventsFilterListener listener) {\r
        fEventsFilterListeners.remove(listener);\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Signal handlers\r
    // ------------------------------------------------------------------------\r
\r
    @TmfSignalHandler\r
    public void experimentUpdated(TmfExperimentUpdatedSignal signal) {\r
        if ((signal.getExperiment() != fTrace) || fTable.isDisposed()) {\r
            return;\r
        }\r
        // Perform the refresh on the UI thread\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                if (!fTable.isDisposed() && (fTrace != null)) {\r
                    if (fTable.getData(Key.FILTER_OBJ) == null) {\r
                        fTable.setItemCount((int) fTrace.getNbEvents() + 1); // +1 for header row\r
                        if ((fPendingGotoRank != -1) && ((fPendingGotoRank + 1) < fTable.getItemCount())) { // +1 for header row\r
                            fTable.setSelection((int) fPendingGotoRank + 1); // +1 for header row\r
                            fPendingGotoRank = -1;\r
                        }\r
                    } else {\r
                        startFilterThread();\r
                    }\r
                }\r
                if (!fRawViewer.isDisposed() && (fTrace != null)) {\r
                    fRawViewer.refreshEventCount();\r
                }\r
            }\r
        });\r
    }\r
\r
    @TmfSignalHandler\r
    public void traceUpdated(TmfTraceUpdatedSignal signal) {\r
        if ((signal.getTrace() != fTrace) || fTable.isDisposed()) {\r
            return;\r
        }\r
        // Perform the refresh on the UI thread\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                if (!fTable.isDisposed() && (fTrace != null)) {\r
                    if (fTable.getData(Key.FILTER_OBJ) == null) {\r
                        fTable.setItemCount((int) fTrace.getNbEvents() + 1); // +1 for header row\r
                        if ((fPendingGotoRank != -1) && ((fPendingGotoRank + 1) < fTable.getItemCount())) { // +1 for header row\r
                            fTable.setSelection((int) fPendingGotoRank + 1); // +1 for header row\r
                            fPendingGotoRank = -1;\r
                        }\r
                    } else {\r
                        startFilterThread();\r
                    }\r
                }\r
                if (!fRawViewer.isDisposed() && (fTrace != null)) {\r
                    fRawViewer.refreshEventCount();\r
                }\r
            }\r
        });\r
    }\r
\r
    @SuppressWarnings("unchecked")\r
    @TmfSignalHandler\r
    public void currentTimeUpdated(final TmfTimeSynchSignal signal) {\r
        if ((signal.getSource() != fTable) && (fTrace != null) && (!fTable.isDisposed())) {\r
\r
            // Create a request for one event that will be queued after other ongoing requests. When this request is\r
            // completed\r
            // do the work to select the actual event with the timestamp specified in the signal. This procedure\r
            // prevents\r
            // the method fTrace.getRank() from interfering and delaying ongoing requests.\r
            final TmfDataRequest<TmfEvent> subRequest = new TmfDataRequest<TmfEvent>(TmfEvent.class, 0, 1,\r
                    ExecutionType.FOREGROUND) {\r
\r
                TmfTimestamp ts = new TmfTimestamp(signal.getCurrentTime());\r
\r
                @Override\r
                public void handleData(TmfEvent event) {\r
                    super.handleData(event);\r
                }\r
\r
                @Override\r
                public void handleCompleted() {\r
                    super.handleCompleted();\r
                    if (fTrace == null) {\r
                        return;\r
                    }\r
\r
                    // Verify if the event is within the trace range and adjust if necessary\r
                    ITmfTimestamp timestamp = ts;\r
                    if (timestamp.compareTo(fTrace.getStartTime(), true) == -1) {\r
                        timestamp = fTrace.getStartTime();\r
                    }\r
                    if (timestamp.compareTo(fTrace.getEndTime(), true) == 1) {\r
                        timestamp = fTrace.getEndTime();\r
                    }\r
\r
                    // Get the rank of the selected event in the table\r
                    final long rank = fTrace.getRank(timestamp);\r
                    fSelectedRank = rank;\r
\r
                    fTable.getDisplay().asyncExec(new Runnable() {\r
                        @Override\r
                        public void run() {\r
                            // Return if table is disposed\r
                            if (fTable.isDisposed()) {\r
                                return;\r
                            }\r
\r
                            int index = (int) rank;\r
                            if (fTable.isDisposed()) {\r
                                return;\r
                            }\r
                            if (fTable.getData(Key.FILTER_OBJ) != null) {\r
                                index = fCache.getFilteredEventIndex(rank) + 1; // +1 for top filter status row\r
                            }\r
                            fTable.setSelection(index + 1); // +1 for header row\r
                            fRawViewer.selectAndReveal(rank);\r
                        }\r
                    });\r
                }\r
            };\r
\r
            ((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(subRequest);\r
        }\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Error handling\r
    // ------------------------------------------------------------------------\r
\r
    /**\r
     * Display an exception in a message box\r
     *\r
     * @param e the exception\r
     */\r
    private void displayException(Exception e) {\r
        MessageBox mb = new MessageBox(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());\r
        mb.setText(e.getClass().getName());\r
        mb.setMessage(e.getMessage());\r
        mb.open();\r
    }\r
\r
}\r