org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/editors/TmfEventsEditor.java

   1 /*******************************************************************************
   2  * Copyright (c) 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  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.editors;
  14
  15 import java.io.FileNotFoundException;
  16 import java.lang.reflect.Constructor;
  17 import java.lang.reflect.InvocationTargetException;
  18 import java.util.List;
  19
  20 import org.eclipse.core.resources.IFile;
  21 import org.eclipse.core.resources.IMarker;
  22 import org.eclipse.core.resources.IMarkerDelta;
  23 import org.eclipse.core.resources.IResource;
  24 import org.eclipse.core.resources.IResourceChangeEvent;
  25 import org.eclipse.core.resources.IResourceChangeListener;
  26 import org.eclipse.core.resources.IResourceDelta;
  27 import org.eclipse.core.resources.ResourcesPlugin;
  28 import org.eclipse.core.runtime.CoreException;
  29 import org.eclipse.core.runtime.IConfigurationElement;
  30 import org.eclipse.core.runtime.IProgressMonitor;
  31 import org.eclipse.core.runtime.InvalidRegistryObjectException;
  32 import org.eclipse.core.runtime.Platform;
  33 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomEventsTable;
  34 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomTxtTrace;
  35 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomXmlTrace;
  36 import org.eclipse.linuxtools.internal.tmf.ui.project.handlers.Messages;
  37 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  38 import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
  39 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  40 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
  41 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  42 import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
  43 import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
  44 import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
  45 import org.eclipse.linuxtools.tmf.ui.project.model.TmfNavigatorContentProvider;
  46 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
  47 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;
  48 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
  49 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceType;
  50 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;
  51 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
  52 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceParserUpdatedSignal;
  53 import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsTable;
  54 import org.eclipse.swt.widgets.Composite;
  55 import org.eclipse.swt.widgets.Display;
  56 import org.eclipse.ui.IEditorInput;
  57 import org.eclipse.ui.IEditorPart;
  58 import org.eclipse.ui.IEditorSite;
  59 import org.eclipse.ui.IFileEditorInput;
  60 import org.eclipse.ui.IPropertyListener;
  61 import org.eclipse.ui.IReusableEditor;
  62 import org.eclipse.ui.PartInitException;
  63 import org.eclipse.ui.ide.IGotoMarker;
  64 import org.eclipse.ui.part.FileEditorInput;
  65 import org.osgi.framework.Bundle;
  66
  67 /**
  68  * <b><u>TmfEventsEditor</u></b>
  69  */
  70 public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener {
  71
  72     public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.events"; //$NON-NLS-1$
  73
  74     private TmfEventsTable fEventsTable;
  75     private IFile fFile;
  76     @SuppressWarnings("rawtypes")
  77     private ITmfTrace fTrace;
  78     private Composite fParent;
  79
  80     @Override
  81     public void doSave(IProgressMonitor monitor) {
  82     }
  83
  84     @Override
  85     public void doSaveAs() {
  86     }
  87
  88     @SuppressWarnings({ "unchecked", "rawtypes" })
  89     @Override
  90     public void init(IEditorSite site, IEditorInput input) throws PartInitException {
  91         if (input instanceof TmfEditorInput) {
  92             fFile = ((TmfEditorInput) input).getFile();
  93             fTrace = ((TmfEditorInput) input).getTrace();
  94             input = new FileEditorInput(fFile);
  95         } else if (input instanceof IFileEditorInput) {
  96             fFile = ((IFileEditorInput) input).getFile();
  97             if (fFile == null) {
  98                 throw new PartInitException("Invalid IFileEditorInput: " + input); //$NON-NLS-1$
  99             }
 100             try {
 101                 String traceTypeId = fFile.getPersistentProperty(TmfTraceElement.TRACETYPE);
 102                 if (traceTypeId == null) {
 103                     throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 104                 }
 105                 if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {
 106                     // Special case: experiment bookmark resource
 107                     TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 108                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 109                     TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 110                     if (project == null) {
 111                         throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
 112                     }
 113                     for (ITmfProjectModelElement projectElement : project.getExperimentsFolder().getChildren()) {
 114                         String traceName = fFile.getParent().getName();
 115                         if (projectElement.getName().equals(traceName)) {
 116                             TmfExperimentElement experimentElement = (TmfExperimentElement) projectElement;
 117                             // Instantiate the experiment's traces
 118                             List<TmfTraceElement> traceEntries = experimentElement.getTraces();
 119                             int nbTraces = traceEntries.size();
 120                             int cacheSize = Integer.MAX_VALUE;
 121                             ITmfTrace<?>[] traces = new ITmfTrace[nbTraces];
 122                             for (int i = 0; i < nbTraces; i++) {
 123                                 TmfTraceElement traceElement = traceEntries.get(i);
 124                                 ITmfTrace trace = traceElement.instantiateTrace();
 125                                 TmfEvent traceEvent = traceElement.instantiateEvent();
 126                                 if (trace == null || traceEvent == null) {
 127                                     for (int j = 0; j < i; j++) {
 128                                         traces[j].dispose();
 129                                     }
 130                                     throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
 131                                 }
 132                                 try {
 133                                     trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass());
 134                                 } catch (FileNotFoundException e) {
 135                                 }
 136                                 trace.setResource(traceElement.getResource());
 137                                 cacheSize = Math.min(cacheSize, trace.getIndexPageSize());
 138                                 traces[i] = trace;
 139                             }
 140                             TmfExperiment experiment = new TmfExperiment(TmfEvent.class, experimentElement.getName(), traces, cacheSize);
 141                             experiment.setBookmarksFile(fFile);
 142                             fTrace = experiment;
 143                             experiment.initTrace(null, null, null);
 144                             experiment.indexTrace(true);
 145                             break;
 146                         }
 147                     }
 148                 } else if (traceTypeId.equals(TmfTrace.class.getCanonicalName())) {
 149                     // Special case: trace bookmark resource
 150                     TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 151                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 152                     TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 153                     for (ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
 154                         String traceName = fFile.getParent().getName();
 155                         if (projectElement.getName().equals(traceName)) {
 156                             TmfTraceElement traceElement = (TmfTraceElement) projectElement;
 157                             // Instantiate the trace
 158                             ITmfTrace trace = traceElement.instantiateTrace();
 159                             TmfEvent traceEvent = traceElement.instantiateEvent();
 160                             if (trace == null || traceEvent == null) {
 161                                 throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 162                             }
 163                             try {
 164                                 trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass());
 165                                 trace.indexTrace(false);
 166                             } catch (FileNotFoundException e) {
 167                             }
 168                             trace.setResource(traceElement.getResource());
 169                             fTrace = trace;
 170                             break;
 171                         }
 172                     }
 173                 } else {
 174                     TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 175                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 176                     TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 177                     for (ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
 178                         if (projectElement.getResource().equals(fFile)) {
 179                             TmfTraceElement traceElement = (TmfTraceElement) projectElement;
 180                             // Instantiate the trace
 181                             ITmfTrace trace = traceElement.instantiateTrace();
 182                             TmfEvent traceEvent = traceElement.instantiateEvent();
 183                             if (trace == null || traceEvent == null) {
 184                                 throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 185                             }
 186                             try {
 187                                 trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass());
 188                                 trace.indexTrace(false);
 189                             } catch (FileNotFoundException e) {
 190                             }
 191                             if (trace instanceof TmfTrace) {
 192                                 ((TmfTrace) trace).setResource(traceElement.getResource());
 193                             }
 194                             fTrace = trace;
 195                             break;
 196                         }
 197                     }
 198                 }
 199             } catch (InvalidRegistryObjectException e) {
 200                 e.printStackTrace();
 201             } catch (PartInitException e) {
 202                 throw e;
 203             } catch (CoreException e) {
 204                 e.printStackTrace();
 205             }
 206         } else {
 207             throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
 208         }
 209         if (fTrace == null) {
 210             throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
 211         }
 212         super.setSite(site);
 213         super.setInput(input);
 214     }
 215
 216     @Override
 217     public boolean isDirty() {
 218         return false;
 219     }
 220
 221     @Override
 222     public boolean isSaveAsAllowed() {
 223         return false;
 224     }
 225
 226     @Override
 227     public void setInput(IEditorInput input) {
 228         super.setInput(input);
 229         firePropertyChange(IEditorPart.PROP_INPUT);
 230     }
 231
 232     @Override
 233         public void propertyChanged(Object source, int propId) {
 234         if (propId == IEditorPart.PROP_INPUT) {
 235             broadcast(new TmfTraceClosedSignal(this, fTrace));
 236             fFile = ((TmfEditorInput) getEditorInput()).getFile();
 237             fTrace = ((TmfEditorInput) getEditorInput()).getTrace();
 238             super.setInput(new FileEditorInput(fFile));
 239             fEventsTable.dispose();
 240             if (fTrace != null) {
 241                 fEventsTable = createEventsTable(fParent, fTrace.getIndexPageSize());
 242                 fEventsTable.setTrace(fTrace, true);
 243                 fEventsTable.refreshBookmarks(fFile);
 244                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 245             } else {
 246                 fEventsTable = new TmfEventsTable(fParent, 0);
 247             }
 248             fParent.layout();
 249         }
 250     }
 251
 252     @Override
 253     public void createPartControl(Composite parent) {
 254         fParent = parent;
 255         if (fTrace != null) {
 256             setPartName(fTrace.getName());
 257             fEventsTable = createEventsTable(parent, fTrace.getIndexPageSize());
 258             fEventsTable.setTrace(fTrace, true);
 259             fEventsTable.refreshBookmarks(fFile);
 260             broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 261         } else {
 262             setPartName(getEditorInput().getName());
 263             fEventsTable = new TmfEventsTable(parent, 0);
 264         }
 265         addPropertyListener(this);
 266         ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
 267     }
 268
 269     @Override
 270     public void dispose() {
 271         ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
 272         removePropertyListener(this);
 273         if (fTrace != null) {
 274             broadcast(new TmfTraceClosedSignal(this, fTrace));
 275         }
 276         if (fEventsTable != null) {
 277             fEventsTable.dispose();
 278         }
 279         super.dispose();
 280     }
 281
 282     protected TmfEventsTable createEventsTable(Composite parent, int cacheSize) {
 283         TmfEventsTable eventsTable = getEventsTable(parent, cacheSize);
 284         if (eventsTable == null) {
 285             eventsTable = new TmfEventsTable(parent, cacheSize);
 286         }
 287         return eventsTable;
 288     }
 289
 290     private TmfEventsTable getEventsTable(Composite parent, int cacheSize) {
 291         if (fTrace instanceof TmfExperiment) {
 292             return getExperimentEventsTable((TmfExperiment<?>) fTrace, parent, cacheSize);
 293         }
 294         TmfEventsTable eventsTable = null;
 295         try {
 296             if (fTrace.getResource() == null) {
 297                 return null;
 298             }
 299             String traceType = fTrace.getResource().getPersistentProperty(TmfTraceElement.TRACETYPE);
 300             if (traceType == null) {
 301                 return null;
 302             }
 303             if (traceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
 304                 return new CustomEventsTable(((CustomTxtTrace) fTrace).getDefinition(), parent, cacheSize);
 305             }
 306             if (traceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
 307                 return new CustomEventsTable(((CustomXmlTrace) fTrace).getDefinition(), parent, cacheSize);
 308             }
 309             for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 310                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(traceType)) {
 311                     IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 312                     if (eventsTableTypeCE.length != 1) {
 313                         break;
 314                     }
 315                     String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 316                     if (eventsTableType == null || eventsTableType.length() == 0) {
 317                         break;
 318                     }
 319                     Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 320                     Class<?> c = bundle.loadClass(eventsTableType);
 321                     Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 322                     Constructor<?> constructor = c.getConstructor(constructorArgs);
 323                     Object[] args = new Object[] { parent, cacheSize };
 324                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 325                     break;
 326                 }
 327             }
 328         } catch (InvalidRegistryObjectException e) {
 329             e.printStackTrace();
 330         } catch (CoreException e) {
 331             e.printStackTrace();
 332         } catch (ClassNotFoundException e) {
 333             e.printStackTrace();
 334         } catch (SecurityException e) {
 335             e.printStackTrace();
 336         } catch (NoSuchMethodException e) {
 337             e.printStackTrace();
 338         } catch (IllegalArgumentException e) {
 339             e.printStackTrace();
 340         } catch (InstantiationException e) {
 341             e.printStackTrace();
 342         } catch (IllegalAccessException e) {
 343             e.printStackTrace();
 344         } catch (InvocationTargetException e) {
 345             e.printStackTrace();
 346         }
 347         return eventsTable;
 348     }
 349
 350     /**
 351      * Get the events table for an experiment.
 352      * If all traces in the experiment are of the same type,
 353      * use the extension point specified event table
 354      * @param experiment the experiment
 355      * @param parent the parent Composite
 356      * @param cacheSize the event table cache size
 357      * @return an events table of the appropriate type
 358      */
 359     private TmfEventsTable getExperimentEventsTable(TmfExperiment<?> experiment, Composite parent, int cacheSize) {
 360         TmfEventsTable eventsTable = null;
 361         String commonTraceType = null;
 362         try {
 363             for (ITmfTrace<?> trace : experiment.getTraces()) {
 364                 IResource resource = trace.getResource();
 365                 if (resource == null) {
 366                     return null;
 367                 }
 368                 String traceType = resource.getPersistentProperty(TmfTraceElement.TRACETYPE);
 369                 if (commonTraceType != null && !commonTraceType.equals(traceType)) {
 370                     return null;
 371                 }
 372                 commonTraceType = traceType;
 373             }
 374             if (commonTraceType == null) {
 375                 return null;
 376             }
 377             if (commonTraceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
 378                 return new CustomEventsTable(((CustomTxtTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
 379             }
 380             if (commonTraceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
 381                 return new CustomEventsTable(((CustomXmlTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
 382             }
 383             for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 384                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(commonTraceType)) {
 385                     IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 386                     if (eventsTableTypeCE.length != 1) {
 387                         break;
 388                     }
 389                     String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 390                     if (eventsTableType == null || eventsTableType.length() == 0) {
 391                         break;
 392                     }
 393                     Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 394                     Class<?> c = bundle.loadClass(eventsTableType);
 395                     Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 396                     Constructor<?> constructor = c.getConstructor(constructorArgs);
 397                     Object[] args = new Object[] { parent, cacheSize };
 398                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 399                     break;
 400                 }
 401             }
 402         } catch (CoreException e) {
 403             e.printStackTrace();
 404         } catch (InvalidRegistryObjectException e) {
 405             e.printStackTrace();
 406         } catch (SecurityException e) {
 407             e.printStackTrace();
 408         } catch (IllegalArgumentException e) {
 409             e.printStackTrace();
 410         } catch (ClassNotFoundException e) {
 411             e.printStackTrace();
 412         } catch (NoSuchMethodException e) {
 413             e.printStackTrace();
 414         } catch (InstantiationException e) {
 415             e.printStackTrace();
 416         } catch (IllegalAccessException e) {
 417             e.printStackTrace();
 418         } catch (InvocationTargetException e) {
 419             e.printStackTrace();
 420         }
 421         return eventsTable;
 422     }
 423
 424     @Override
 425         public ITmfTrace<?> getTrace() {
 426         return fTrace;
 427     }
 428
 429     @Override
 430     public IFile getBookmarksFile() {
 431         return fFile;
 432     }
 433
 434     @Override
 435     public void setFocus() {
 436         fEventsTable.setFocus();
 437         if (fTrace != null) {
 438             broadcast(new TmfTraceSelectedSignal(this, fTrace));
 439         }
 440     }
 441
 442     @Override
 443     @SuppressWarnings("rawtypes")
 444     public Object getAdapter(Class adapter) {
 445         if (IGotoMarker.class.equals(adapter)) {
 446                 return fEventsTable;
 447         }
 448         return super.getAdapter(adapter);
 449     }
 450
 451     @Override
 452     public void resourceChanged(IResourceChangeEvent event) {
 453         for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
 454             if (delta.getResource().equals(fFile)) {
 455                 if (delta.getKind() == IResourceDelta.REMOVED) {
 456                     final IMarker bookmark = delta.getMarker();
 457                     Display.getDefault().asyncExec(new Runnable() {
 458                         @Override
 459                         public void run() {
 460                             fEventsTable.removeBookmark(bookmark);
 461                         }
 462                     });
 463                 } else if (delta.getKind() == IResourceDelta.CHANGED) {
 464                     Display.getDefault().asyncExec(new Runnable() {
 465                         @Override
 466                         public void run() {
 467                             fEventsTable.getTable().refresh();
 468                         }
 469                     });
 470                 }
 471             }
 472         }
 473     }
 474
 475     // ------------------------------------------------------------------------
 476     // Global commands
 477     // ------------------------------------------------------------------------
 478
 479     public void addBookmark() {
 480         fEventsTable.addBookmark(fFile);
 481     }
 482
 483
 484     // ------------------------------------------------------------------------
 485     // Signal handlers
 486     // ------------------------------------------------------------------------
 487
 488     @SuppressWarnings("unchecked")
 489     @TmfSignalHandler
 490     public void traceParserUpdated(TmfTraceParserUpdatedSignal signal) {
 491         if (signal.getTraceResource().equals(fFile)) {
 492             broadcast(new TmfTraceClosedSignal(this, fTrace));
 493             try {
 494                 String name = fTrace.getName();
 495                 fTrace = null;
 496                 String traceTypeId = fFile.getPersistentProperty(TmfTraceElement.TRACETYPE);
 497                 if (traceTypeId != null) {
 498                     for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 499                         if (traceTypeId.equals(ce.getAttribute(TmfTraceType.ID_ATTR))) {
 500                             fTrace = (ITmfTrace<?>) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
 501                             TmfEvent event = (TmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
 502                             String path = fFile.getLocationURI().getPath();
 503                             fTrace.initTrace(name, path, event.getClass());
 504                             fTrace.indexTrace(false);
 505                             break;
 506                         }
 507                     }
 508                 }
 509             } catch (InvalidRegistryObjectException e) {
 510                 e.printStackTrace();
 511             } catch (FileNotFoundException e) {
 512                 e.printStackTrace();
 513             } catch (CoreException e) {
 514                 e.printStackTrace();
 515             }
 516             fEventsTable.dispose();
 517             if (fTrace != null) {
 518                 fEventsTable = createEventsTable(fParent, fTrace.getIndexPageSize());
 519                 fEventsTable.setTrace(fTrace, true);
 520                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 521             } else {
 522                 fEventsTable = new TmfEventsTable(fParent, 0);
 523             }
 524             fParent.layout();
 525         }
 526     }
 527
 528     @TmfSignalHandler
 529     public void traceSelected(TmfTraceSelectedSignal signal) {
 530         if (signal.getSource() != this && signal.getTrace().equals(fTrace)) {
 531             getSite().getPage().bringToTop(this);
 532         }
 533     }
 534
 535 }