org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/TmfEventsView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Francois Chouinard - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.views;
  14
  15 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  16 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  17 import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
  18 import org.eclipse.linuxtools.tmf.experiment.TmfExperimentSelectedSignal;
  19 import org.eclipse.linuxtools.tmf.experiment.TmfExperimentUpdatedSignal;
  20 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
  21 import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
  22 import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;
  23 import org.eclipse.swt.SWT;
  24 import org.eclipse.swt.events.SelectionAdapter;
  25 import org.eclipse.swt.events.SelectionEvent;
  26 import org.eclipse.swt.layout.GridData;
  27 import org.eclipse.swt.widgets.Composite;
  28 import org.eclipse.swt.widgets.Event;
  29 import org.eclipse.swt.widgets.Listener;
  30 import org.eclipse.swt.widgets.Table;
  31 import org.eclipse.swt.widgets.TableColumn;
  32 import org.eclipse.swt.widgets.TableItem;
  33
  34 /**
  35  * <b><u>TmfEventsView</u></b>
  36  * <p>
  37  *
  38  * TODO: Implement me. Please.
  39  * TODO: Handle column selection, sort, ... generically (nothing less...)
  40  * TODO: Implement hide/display columns
  41  */
  42 public class TmfEventsView extends TmfView {
  43
  44     public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.events";
  45
  46     private TmfExperiment<TmfEvent> fExperiment;
  47     private String fTitlePrefix;
  48
  49         // ------------------------------------------------------------------------
  50     // Table data
  51         // ------------------------------------------------------------------------
  52
  53     private Table fTable;
  54
  55     // Table column names
  56     private final String TIMESTAMP_COLUMN = "Timestamp";
  57     private final String SOURCE_COLUMN    = "Source";
  58     private final String TYPE_COLUMN      = "Type";
  59     private final String REFERENCE_COLUMN = "File";
  60     private final String CONTENT_COLUMN   = "Content";
  61     private final String[] columnProperties =  new String[] {
  62         TIMESTAMP_COLUMN,
  63         SOURCE_COLUMN,
  64         TYPE_COLUMN,
  65         REFERENCE_COLUMN,
  66         CONTENT_COLUMN
  67     };
  68
  69     // Column data
  70     private class ColumnData {
  71         public final String header;
  72         public final int    width;
  73         public final int    alignment;
  74
  75         public ColumnData(String h, int w, int a) {
  76             header = h;
  77             width = w;
  78             alignment = a;
  79         }
  80     };
  81
  82     private ColumnData[] columnData = new ColumnData[] {
  83         new ColumnData(columnProperties[0], 100, SWT.LEFT),
  84         new ColumnData(columnProperties[1], 100, SWT.LEFT),
  85         new ColumnData(columnProperties[2], 100, SWT.LEFT),
  86         new ColumnData(columnProperties[3], 100, SWT.LEFT),
  87         new ColumnData(columnProperties[4], 100, SWT.LEFT)
  88     };
  89
  90         // ------------------------------------------------------------------------
  91     // Event cache
  92         // ------------------------------------------------------------------------
  93
  94         private static final int DEFAULT_CACHE_SIZE = 1000;
  95     private final int fCacheSize;
  96     private TmfEvent[] cache = new TmfEvent[1];
  97     private int cacheStartIndex = 0;
  98     private int cacheEndIndex = 0;
  99
 100         // ------------------------------------------------------------------------
 101     // Constructor
 102         // ------------------------------------------------------------------------
 103
 104     public TmfEventsView(int cacheSize) {
 105         super("TmfEventsView");
 106         fCacheSize = cacheSize;
 107     }
 108
 109     public TmfEventsView() {
 110         this(DEFAULT_CACHE_SIZE);
 111     }
 112
 113         // ------------------------------------------------------------------------
 114     // ViewPart
 115         // ------------------------------------------------------------------------
 116
 117     @SuppressWarnings("unchecked")
 118         @Override
 119         public void createPartControl(Composite parent) {
 120
 121         // Create a virtual table
 122         // TODO: change SINGLE to MULTI line selection and adjust the selection listener
 123         final int style = SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.VIRTUAL;
 124         fTable = new Table(parent, style);
 125
 126         // Set the table layout
 127         GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
 128         fTable.setLayoutData(layoutData);
 129
 130         // Some cosmetic enhancements
 131         fTable.setHeaderVisible(true);
 132         fTable.setLinesVisible(true);
 133
 134         // Set the columns
 135         createColumnHeaders(fTable);
 136
 137         // Handle the table item requests
 138         fTable.addSelectionListener(new SelectionAdapter() {
 139
 140                 @Override
 141                         public void widgetSelected(SelectionEvent e) {
 142                                 TmfTimestamp ts = (TmfTimestamp) fTable.getSelection()[0].getData();
 143                                 broadcast(new TmfTimeSynchSignal(fTable, ts));
 144                         }
 145         });
 146
 147         // Handle the table item requests
 148         fTable.addListener(SWT.SetData, new Listener() {
 149
 150                         public void handleEvent(Event event) {
 151
 152                         TableItem item = (TableItem) event.item;
 153                                 final int index = fTable.indexOf(item);
 154
 155                                 // Note: this works because handleEvent() is called once for each row, in sequence
 156                                 if ((index >= cacheStartIndex ) && (index < cacheEndIndex)) {
 157                                         int i = index - cacheStartIndex;
 158                                         item.setText(extractItemFields(cache[i]));
 159                                         item.setData(new TmfTimestamp(cache[i].getTimestamp()));
 160                                         return;
 161                                 }
 162
 163                                 TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, index, fCacheSize) {
 164                                         @Override
 165                                         public void handleData() {
 166                                                 TmfEvent[] tmpEvent = getData();
 167                                                 if ((tmpEvent != null) && (tmpEvent.length > 0)) {
 168                                                         cache = tmpEvent;
 169                                                         cacheStartIndex = index;
 170                                                         cacheEndIndex = index + tmpEvent.length;
 171                                                 }
 172                                         }
 173                                 };
 174                                 fExperiment.sendRequest(request);
 175                         try {
 176                                         request.waitForCompletion();
 177                                 } catch (InterruptedException e) {
 178                                         e.printStackTrace();
 179                                 }
 180
 181                                 if (cache[0] != null && cacheStartIndex == index) {
 182                                         item.setText(extractItemFields(cache[0]));
 183                                         item.setData(new TmfTimestamp(cache[0].getTimestamp()));
 184                                 }
 185
 186                         }
 187         });
 188
 189         fTable.setItemCount(0);
 190         fTitlePrefix = getTitle();
 191
 192         // If an experiment is already selected, update the table
 193         fExperiment = (TmfExperiment<TmfEvent>) TmfExperiment.getCurrentExperiment();
 194         if (fExperiment != null) {
 195                 experimentSelected(new TmfExperimentSelectedSignal<TmfEvent>(fTable, fExperiment));
 196         }
 197     }
 198
 199         /**
 200          * @param table
 201          *
 202          * FIXME: Add support for column selection
 203          */
 204         protected void createColumnHeaders(Table table) {
 205         for (int i = 0; i < columnData.length; i++) {
 206             TableColumn column = new TableColumn(table, columnData[i].alignment, i);
 207             column.setText(columnData[i].header);
 208             column.setWidth(columnData[i].width);
 209         }
 210         }
 211
 212         /**
 213          * @param event
 214          * @return
 215          *
 216          * FIXME: Add support for column selection
 217          */
 218         protected String[] extractItemFields(TmfEvent event) {
 219         String[] fields = new String[0];
 220         if (event != null) {
 221             fields = new String[] {
 222                                 new Long(event.getTimestamp().getValue()).toString(),
 223                                 event.getSource().getSourceId().toString(),
 224                                 event.getType().getTypeId().toString(),
 225                                 event.getReference().getReference().toString(),
 226                                 event.getContent().toString()
 227             };
 228                 }
 229                 return fields;
 230         }
 231
 232     /* (non-Javadoc)
 233      * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 234      */
 235     @Override
 236         public void setFocus() {
 237     }
 238
 239     /* (non-Javadoc)
 240      * @see java.lang.Object#toString()
 241      */
 242     @Override
 243         public String toString() {
 244         return "[TmfEventsView]";
 245     }
 246
 247         // ------------------------------------------------------------------------
 248     // Signal handlers
 249         // ------------------------------------------------------------------------
 250
 251         @SuppressWarnings("unchecked")
 252         @TmfSignalHandler
 253     public void experimentSelected(TmfExperimentSelectedSignal<TmfEvent> signal) {
 254                 // Update the trace reference
 255         fExperiment = (TmfExperiment<TmfEvent>) signal.getExperiment();
 256         setPartName(fTitlePrefix + " - " + fExperiment.getName());
 257
 258         // Perform the updates on the UI thread
 259         fTable.getDisplay().asyncExec(new Runnable() {
 260                 public void run() {
 261                         // TODO: Potentially long operation. Add some feedback for the user
 262                         fTable.setSelection(0);
 263                 fTable.clearAll();
 264                                 cacheStartIndex = cacheEndIndex = 0;    // Clear the cache
 265                 fTable.setItemCount((int) fExperiment.getNbEvents());
 266                 }
 267         });
 268     }
 269
 270         @TmfSignalHandler
 271     public void experimentUpdated(TmfExperimentUpdatedSignal signal) {
 272         // Perform the refresh on the UI thread
 273         fTable.getDisplay().asyncExec(new Runnable() {
 274                         public void run() {
 275                                 if (!fTable.isDisposed() && fExperiment != null) {
 276                                 fTable.setItemCount((int) fExperiment.getNbEvents());
 277                                 }
 278                         }
 279         });
 280     }
 281
 282 //    @TmfSignalHandler
 283 //    public void currentTimeUpdated(TmfTimeSynchSignal signal) {
 284 //      if (signal.getSource() != fTable && fExperiment != null) {
 285 //              final int index = (int) fExperiment.getRank(signal.getCurrentTime());
 286 //            // Perform the updates on the UI thread
 287 //            fTable.getDisplay().asyncExec(new Runnable() {
 288 //              public void run() {
 289 //                      fTable.setSelection(index);
 290 //                      // The timestamp might not correspond to an actual event
 291 //                      // and the selection will point to the next experiment event.
 292 //                      // But we would like to display both the event before and
 293 //                      // after the selected timestamp.
 294 //                      // This works fine by default except when the selected event
 295 //                      // is the top displayed event. The following ensures that we
 296 //                      // always see both events.
 297 //                      if ((index > 0) && (index == fTable.getTopIndex())) {
 298 //                              fTable.setTopIndex(index - 1);
 299 //                      }
 300 //              }
 301 //            });
 302 //      }
 303 //    }
 304
 305 }