Fix for Bug337914

[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
 *******************************************************************************/\r
\r
package org.eclipse.linuxtools.tmf.ui.viewers.events;\r
\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.linuxtools.tmf.component.ITmfDataProvider;\r
import org.eclipse.linuxtools.tmf.component.TmfComponent;\r
import org.eclipse.linuxtools.tmf.event.TmfEvent;\r
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;\r
import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;\r
import org.eclipse.linuxtools.tmf.request.ITmfDataRequest.ExecutionType;\r
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;\r
import org.eclipse.linuxtools.tmf.signal.TmfExperimentUpdatedSignal;\r
import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal;\r
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;\r
import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;\r
import org.eclipse.linuxtools.tmf.signal.TmfTraceUpdatedSignal;\r
import org.eclipse.linuxtools.tmf.trace.ITmfTrace;\r
import org.eclipse.linuxtools.tmf.ui.TmfUiPlugin;\r
import org.eclipse.linuxtools.tmf.ui.widgets.ColumnData;\r
import org.eclipse.linuxtools.tmf.ui.widgets.TmfVirtualTable;\r
import org.eclipse.swt.SWT;\r
import org.eclipse.swt.events.SelectionAdapter;\r
import org.eclipse.swt.events.SelectionEvent;\r
import org.eclipse.swt.layout.GridData;\r
import org.eclipse.swt.widgets.Composite;\r
import org.eclipse.swt.widgets.Event;\r
import org.eclipse.swt.widgets.Listener;\r
import org.eclipse.swt.widgets.TableColumn;\r
import org.eclipse.swt.widgets.TableItem;\r
\r
/**\r
 * <b><u>TmfEventsTable</u></b>\r
 */\r
public class TmfEventsTable extends TmfComponent {\r
\r
    // ------------------------------------------------------------------------\r
    // Table data\r
    // ------------------------------------------------------------------------\r
\r
    protected TmfVirtualTable fTable;\r
    protected ITmfTrace fTrace;\r
    protected boolean fPackDone = false;\r
\r
    // Table column names\r
    static private final String[] COLUMN_NAMES =  new String[] {\r
        Messages.TmfEventsTable_TimestampColumnHeader,\r
        Messages.TmfEventsTable_SourceColumnHeader,\r
        Messages.TmfEventsTable_TypeColumnHeader,\r
        Messages.TmfEventsTable_ReferenceColumnHeader,\r
        Messages.TmfEventsTable_ContentColumnHeader\r
    };\r
\r
    static private ColumnData[] COLUMN_DATA = new ColumnData[] {\r
        new ColumnData(COLUMN_NAMES[0], 100, SWT.LEFT),\r
        new ColumnData(COLUMN_NAMES[1], 100, SWT.LEFT),\r
        new ColumnData(COLUMN_NAMES[2], 100, SWT.LEFT),\r
        new ColumnData(COLUMN_NAMES[3], 100, SWT.LEFT),\r
        new ColumnData(COLUMN_NAMES[4], 100, SWT.LEFT)\r
    };\r
\r
    // ------------------------------------------------------------------------\r
    // Event cache\r
    // ------------------------------------------------------------------------\r
\r
    private final int  fCacheSize;\r
    private TmfEvent[] fCache;\r
    private int fCacheStartIndex = 0;\r
    private int fCacheEndIndex   = 0;\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
        fCacheSize = cacheSize;\r
        fCache = new TmfEvent[fCacheSize];\r
        \r
        // Create a virtual table\r
        final int style = SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER;\r
        fTable = new TmfVirtualTable(parent, 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
        // Handle the table item requests \r
        fTable.addSelectionListener(new SelectionAdapter() {\r
            @Override\r
            public void widgetSelected(SelectionEvent e) {\r
                TmfTimestamp ts = (TmfTimestamp) fTable.getSelection()[0].getData();\r
                broadcast(new TmfTimeSynchSignal(fTable, ts));\r
            }\r
        });\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
                final int index = fTable.indexOf(item);\r
\r
                // If available, return the cached data  \r
                if ((index >= fCacheStartIndex) && (index < fCacheEndIndex)) {\r
                    int i = index - fCacheStartIndex;\r
                    item.setText(extractItemFields(fCache[i]));\r
                    item.setData(new TmfTimestamp(fCache[i].getTimestamp()));\r
                    return;\r
                }\r
\r
                // Else, fill the cache asynchronously (and off the UI thread)\r
                populateCache(index);\r
            }\r
        });\r
\r
        fTable.setItemCount(0);\r
    }\r
\r
    @Override\r
	public void dispose() {\r
        fTable.dispose();\r
        if (fTrace != null && fDisposeOnClose) {\r
            fTrace.dispose();\r
        }\r
        super.dispose();\r
    }\r
\r
    public TmfVirtualTable getTable() {\r
        return fTable;\r
    }\r
    \r
    /**\r
     * @param table\r
     * \r
     * FIXME: Add support for column selection\r
     */\r
    protected void setColumnHeaders(ColumnData[] columnData) {\r
    	fTable.setColumnHeaders(columnData);\r
    }\r
\r
    protected void packColumns() {\r
        if (fPackDone) return;\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 String[] extractItemFields(TmfEvent event) {\r
        String[] fields = new String[0];\r
        if (event != null) {\r
            fields = new String[] {\r
                new Long(event.getTimestamp().getValue()).toString(),       \r
                event.getSource().getSourceId().toString(),\r
                event.getType().getTypeId().toString(),\r
                event.getReference().getReference().toString(),\r
                event.getContent().toString()\r
            };\r
        }\r
        return fields;\r
    }\r
\r
    public void setFocus() {\r
        fTable.setFocus();\r
    }\r
\r
    /**\r
     * @param trace\r
     * @param disposeOnClose 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
        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.setSelection(0);\r
                fTable.removeAll();\r
                fCacheStartIndex = fCacheEndIndex = 0; // Clear the cache\r
                \r
                if (!fTable.isDisposed() && fTrace != null) {\r
                    //int nbEvents = (int) fTrace.getNbEvents();\r
                    //fTable.setItemCount((nbEvents > 100) ? nbEvents : 100);\r
                    fTable.setItemCount((int) fTrace.getNbEvents());\r
                }\r
            }\r
        });\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Signal handlers\r
    // ------------------------------------------------------------------------\r
    \r
    @TmfSignalHandler\r
    public void experimentUpdated(TmfExperimentUpdatedSignal signal) {\r
        if ((signal.getExperiment() != fTrace) || fTable.isDisposed()) return;\r
        // Perform the refresh on the UI thread\r
        fTable.getDisplay().asyncExec(new Runnable() {\r
            @Override\r
			public void run() {\r
                if (!fTable.isDisposed() && fTrace != null) {\r
                    fTable.setItemCount((int) fTrace.getNbEvents());\r
                    fTable.refresh();\r
                }\r
            }\r
        });\r
    }\r
    \r
    @TmfSignalHandler\r
    public void traceUpdated(TmfTraceUpdatedSignal signal) {\r
        if ((signal.getTrace() != fTrace ) || fTable.isDisposed()) return;\r
        // Perform the refresh on the UI thread\r
        fTable.getDisplay().asyncExec(new Runnable() {\r
            @Override\r
			public void run() {\r
                if (!fTable.isDisposed() && fTrace != null) {\r
                    //int nbEvents = (int) fTrace.getNbEvents();\r
                    //fTable.setItemCount((nbEvents > 100) ? nbEvents : 100);\r
                    fTable.setItemCount((int) fTrace.getNbEvents());\r
                }\r
            }\r
        });\r
    }\r
\r
    private boolean fRefreshPending = false;\r
    @TmfSignalHandler\r
    public synchronized void rangeSynched(TmfRangeSynchSignal signal) {\r
        if (!fRefreshPending && !fTable.isDisposed()) {\r
            // Perform the refresh on the UI thread\r
            fRefreshPending = true;\r
            fTable.getDisplay().asyncExec(new Runnable() {\r
                @Override\r
				public void run() {\r
                    fRefreshPending = false;\r
                    if (!fTable.isDisposed() && fTrace != null) {\r
                        fTable.setItemCount((int) fTrace.getNbEvents());\r
                    }\r
                }\r
            });\r
        }\r
    }\r
    \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 completed \r
    		// do the work to select the actual event with the timestamp specified in the signal. This procedure prevents \r
    		// the method fTrace.getRank() from interfering and delaying ongoing requests.\r
    		final TmfDataRequest<TmfEvent> subRequest = new TmfDataRequest<TmfEvent>(TmfEvent.class, 0, 1, ExecutionType.FOREGROUND) {\r
\r
    			@Override\r
    			public void handleData(TmfEvent event) {\r
    				super.handleData(event);\r
    			}\r
\r
    			@Override\r
    			public void handleCompleted() {\r
\r
    				// Verify if event is within the trace range\r
    				final TmfTimestamp timestamp[] = new TmfTimestamp[1];\r
    				timestamp[0] = signal.getCurrentTime();\r
    				if (timestamp[0].compareTo(fTrace.getStartTime(), true) == -1) {\r
    					timestamp[0] = fTrace.getStartTime();\r
    				}\r
    				if (timestamp[0].compareTo(fTrace.getEndTime(), true) == 1) {\r
    					timestamp[0] = fTrace.getEndTime();\r
    				}\r
\r
    				// Get the rank for the event selection in the table\r
    				final int index = (int) fTrace.getRank(timestamp[0]);\r
\r
    				fTable.getDisplay().asyncExec(new Runnable() {\r
    					@Override\r
                        public void run() {\r
    						// Return if table is disposed\r
    						if (fTable.isDisposed()) return;\r
\r
    						fTable.setSelection(index);\r
\r
    						// If index is in cache, then notify about updated selection. \r
    						// Otherwise it's done after fetching the relevant events from the trace\r
    						if ((index >= fCacheStartIndex) && (index < fCacheEndIndex)) {\r
    							// Use the timestamp in signal to broadcast to avoid moving the selection\r
    							// at the source of the signal\r
    							fTable.notifyUpdatedSelection(timestamp[0]);\r
    						}\r
\r
    						// The timestamp might not correspond to an actual event\r
    						// and the selection will point to the next experiment event.\r
    						// But we would like to display both the event before and\r
    						// after the selected timestamp.\r
    						// This works fine by default except when the selected event\r
    						// is the top displayed event. The following ensures that we\r
    						// always see both events.\r
    						if ((index > 0) && (index == fTable.getTopIndex())) {\r
    							fTable.setTopIndex(index - 1);\r
    						}\r
    					}\r
    				});\r
    				super.handleCompleted();\r
    			}\r
    		};\r
\r
    		@SuppressWarnings("unchecked")\r
            TmfExperiment<TmfEvent> experiment = (TmfExperiment<TmfEvent>)TmfExperiment.getCurrentExperiment();\r
    		if (experiment != null) {\r
    			experiment.sendRequest(subRequest);\r
    		}\r
    	}\r
	}\r
\r
    // ------------------------------------------------------------------------\r
    // Event cache population\r
    // ------------------------------------------------------------------------\r
    \r
    // The event fetching job\r
    private Job job;\r
    private synchronized void populateCache(final int index) {\r
\r
        /* Check if the current job will fetch the requested event:\r
         * 1. The job must exist\r
         * 2. It must be running (i.e. not completed)\r
         * 3. The requested index must be within the cache range\r
         * \r
         * If the job meets these conditions, we simply exit.\r
         * Otherwise, we create a new job but we might have to cancel\r
         * an existing job for an obsolete range.\r
         */\r
        if (job != null) {\r
            if (job.getState() != Job.NONE) {\r
                if (index >= fCacheStartIndex && index < (fCacheStartIndex + fCacheSize)) {\r
                    return;\r
                }\r
                // The new index is out of the requested range\r
                // Kill the job and start a new one\r
                job.cancel();\r
            }\r
        }\r
        \r
        fCacheStartIndex = index;\r
        fCacheEndIndex   = index;\r
\r
        job = new Job("Fetching Events") { //$NON-NLS-1$\r
            @Override\r
            @SuppressWarnings("unchecked")\r
            protected IStatus run(final IProgressMonitor monitor) {\r
\r
                TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, index, fCacheSize) {\r
                    private int count = 0;\r
                    @Override\r
                    public void handleData(TmfEvent event) {\r
                        // If the job is canceled, cancel the request so waitForCompletion() will unlock\r
                        if (monitor.isCanceled()) {\r
                            cancel();\r
                            return;\r
                        }\r
                        super.handleData(event);\r
                        if (event != null) {\r
                            fCache[count++] = event.clone();\r
                            fCacheEndIndex++;   // TODO: Need to protect this??\r
                        }\r
                    }\r
                };\r
\r
                ((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(request);\r
                try {\r
                    request.waitForCompletion();\r
                } catch (InterruptedException e) {\r
                    e.printStackTrace();\r
                }\r
\r
                // Event cache is now updated. Perform update on the UI thread\r
                if (!fTable.isDisposed() && !monitor.isCanceled()) {\r
                    fTable.getDisplay().asyncExec(new Runnable() {\r
                        @Override\r
                        public void run() {\r
                            if (!fTable.isDisposed()) {\r
                                fTable.refresh();\r
                                fTable.notifyUpdatedSelection();\r
                            }\r
                        }\r
                    });\r
                }\r
                \r
                // Flag the UI thread that the cache is ready\r
                if (monitor.isCanceled()) {\r
                    return new Status(IStatus.CANCEL, TmfUiPlugin.PLUGIN_ID, "Canceled"); //$NON-NLS-1$\r
                }\r
                else {\r
                    return new Status(IStatus.OK, TmfUiPlugin.PLUGIN_ID, "Completed"); //$NON-NLS-1$\r
                }\r
            }\r
        };\r
        job.setPriority(Job.SHORT);\r
        job.schedule();\r
    }\r
}\r