lttng/org.eclipse.tracecompass.lttng2.control.ui/src/org/eclipse/tracecompass/internal/lttng2/control/ui/views/dialogs/EnableUstEventsComposite.java

   1 /**********************************************************************
   2  * Copyright (c) 2012, 2015 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  *   Bernd Hufmann - Initial API and implementation
  11  *   Bernd Hufmann - Updated for support of LTTng Tools 2.1
  12  *   Marc-Andre Laperle - Add filtering textbox
  13  **********************************************************************/
  14 package org.eclipse.tracecompass.internal.lttng2.control.ui.views.dialogs;
  15
  16 import java.util.ArrayList;
  17 import java.util.Arrays;
  18 import java.util.HashSet;
  19 import java.util.List;
  20 import java.util.Set;
  21
  22 import org.eclipse.jface.dialogs.MessageDialog;
  23 import org.eclipse.jface.viewers.CheckStateChangedEvent;
  24 import org.eclipse.jface.viewers.CheckboxTreeViewer;
  25 import org.eclipse.jface.viewers.ICheckStateListener;
  26 import org.eclipse.jface.viewers.TreeViewer;
  27 import org.eclipse.swt.SWT;
  28 import org.eclipse.swt.custom.CCombo;
  29 import org.eclipse.swt.events.SelectionAdapter;
  30 import org.eclipse.swt.events.SelectionEvent;
  31 import org.eclipse.swt.graphics.Image;
  32 import org.eclipse.swt.layout.GridData;
  33 import org.eclipse.swt.layout.GridLayout;
  34 import org.eclipse.swt.widgets.Button;
  35 import org.eclipse.swt.widgets.Composite;
  36 import org.eclipse.swt.widgets.Group;
  37 import org.eclipse.swt.widgets.Label;
  38 import org.eclipse.swt.widgets.Text;
  39 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceDomainType;
  40 import org.eclipse.tracecompass.internal.lttng2.control.core.model.LogLevelType;
  41 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceLogLevel;
  42 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.messages.Messages;
  43 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.ITraceControlComponent;
  44 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.BaseEventComponent;
  45 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TargetNodeComponent;
  46 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceControlContentProvider;
  47 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceControlLabelProvider;
  48 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceProviderGroup;
  49 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.UstProviderComponent;
  50 import org.eclipse.ui.dialogs.FilteredTree;
  51 import org.eclipse.ui.dialogs.PatternFilter;
  52
  53 /**
  54  * <p>
  55  * A composite for collecting information about UST events to be enabled.
  56  * </p>
  57  *
  58  * @author Bernd Hufmann
  59  */
  60 public class EnableUstEventsComposite extends Composite implements IEnableUstEvents  {
  61
  62     // ------------------------------------------------------------------------
  63     // Constants
  64     // ------------------------------------------------------------------------
  65
  66     private enum GroupEnum { TRACEPOINTS, WILDCARD, LOGLEVEL }
  67
  68     // ------------------------------------------------------------------------
  69     // Attributes
  70     // ------------------------------------------------------------------------
  71
  72     /**
  73      * A button to enable/disable the tracepoints group
  74      */
  75     private Button fTracepointsActivateButton;
  76     /**
  77      * A tree viewer for diplaying and selection of available tracepoints.
  78      */
  79     private CheckboxTreeViewer fTracepointsViewer;
  80     /**
  81      * A button to enable/disable the wildcard group
  82      */
  83     private Button fWildcardActivateButton;
  84     /**
  85      * A Text field for the event's wildcard.
  86      */
  87     private Text fWildcardText;
  88     /**
  89      * A button to enable/disable the log level group
  90      */
  91     private Button fLogLevelActivateButton;
  92     /**
  93      * A Text field for the event name for the log level enablement.
  94      */
  95     private Text fLogLevelEventNameText;
  96     /**
  97      * A Combo box for selecting the log level.
  98      */
  99     private CCombo fLogLevelCombo;
 100     /**
 101      * A button for selecting the log level (range 0 to level).
 102      */
 103     private Button fLogLevelButton;
 104     /**
 105      * A button for selecting the specified log level only.
 106      */
 107     private Button fLogLevelOnlyButton;
 108     /**
 109      * The filter text
 110      */
 111     private Text fFilterText;
 112
 113     /**
 114      * The referenced trace provider group containing the UST providers
 115      * component which contains a list of available tracepoints.
 116      */
 117     private final TraceProviderGroup fProviderGroup;
 118     /**
 119      * The flag indicating that tracepoints are selected.
 120      */
 121     private boolean fIsTracepoints;
 122     /**
 123      * The flag indicating that all tracepoints (across providers) are selected.
 124      */
 125     private boolean fIsAllTracepoints;
 126     /**
 127      * The list of tracepoints to be enabled.
 128      */
 129     private List<String> fSelectedEvents;
 130     /**
 131      * The flag indicating that all wildcard are selected..
 132      */
 133     private boolean fIsWildcard;
 134     /**
 135      * The wildcard if wildcard is selected.
 136      */
 137     private String fWildcard;
 138     /**
 139      * The flag indicating that all log level are selected.
 140      */
 141     private boolean fIsLogLevel;
 142     /**
 143      * The type of the log level (loglevel or loglevel-only)
 144      */
 145     private LogLevelType fLogLevelType;
 146     /**
 147      * The actual selected log level.
 148      */
 149     private TraceLogLevel fLogLevel;
 150     /**
 151      * The filter expression
 152      */
 153     private String fFilterExpression;
 154     /**
 155     * A button to enable/disable the exclusion of event(s).
 156     */
 157     private Button fExcludedEventsButton;
 158     /**
 159     * A Text field for the excluded event(s).
 160     */
 161     private Text fExcludedEventsText;
 162     /**
 163      * A list of event(s) to be excluded.
 164      */
 165     private List<String> fExcludedEvents;
 166     /**
 167      * The flag indicating that excluded event(s) are selected.
 168      */
 169     private boolean fIsExcludedEvents;
 170
 171     // ------------------------------------------------------------------------
 172     // Constructors
 173     // ------------------------------------------------------------------------
 174     /**
 175      * Constructor
 176      * @param parent - a parent composite
 177      * @param style - a composite style
 178      * @param providerGroup - the trace provider group
 179      */
 180     public EnableUstEventsComposite(Composite parent, int style, TraceProviderGroup providerGroup) {
 181         super(parent, style);
 182         fProviderGroup = providerGroup;
 183     }
 184
 185     // ------------------------------------------------------------------------
 186     // Accessors
 187     // ------------------------------------------------------------------------
 188
 189     @Override
 190     public boolean isTracepoints() {
 191         return fIsTracepoints;
 192     }
 193
 194     @Override
 195     public boolean isAllTracePoints() {
 196         return fIsAllTracepoints;
 197     }
 198
 199     @Override
 200     public List<String> getEventNames() {
 201         return new ArrayList<>(fSelectedEvents);
 202     }
 203
 204     @Override
 205     public boolean isWildcard() {
 206         return fIsWildcard;
 207     }
 208
 209     @Override
 210     public String getWildcard() {
 211         return fWildcard;
 212     }
 213
 214     @Override
 215     public boolean isLogLevel() {
 216         return fIsLogLevel;
 217     }
 218
 219     @Override
 220     public LogLevelType getLogLevelType() {
 221         return fLogLevelType;
 222     }
 223
 224     @Override
 225     public TraceLogLevel getLogLevel() {
 226         return fLogLevel;
 227     }
 228
 229     @Override
 230     public String getFilterExpression() {
 231         return fFilterExpression;
 232     }
 233
 234     @Override
 235     public List<String> getExcludedEvents(){
 236         return fExcludedEvents;
 237     }
 238
 239     // ------------------------------------------------------------------------
 240     // Operations
 241     // ------------------------------------------------------------------------
 242
 243     /**
 244      * Create the contents of this event composite
 245      */
 246     public void createContent() {
 247
 248         // Tracepoints Group
 249         createTracepointsGroup();
 250
 251         // Wildcard Group
 252         createWildCardGroup();
 253
 254         // Exclude event(s)
 255         createExcludeGroup();
 256
 257         // Log Level Group
 258         createLogLevelGroup();
 259
 260         // Filter Group
 261         createFilterGroup();
 262
 263         // Set default enablements
 264         setEnablements(GroupEnum.TRACEPOINTS);
 265     }
 266
 267     /**
 268      * Validates the UST composite input data.
 269      *
 270      * @return true if configured data is valid and can be retrieved.
 271      */
 272     public boolean isValid() {
 273
 274         fIsTracepoints = fTracepointsActivateButton.getSelection();
 275         fIsWildcard = fWildcardActivateButton.getSelection();
 276         fIsLogLevel = fLogLevelActivateButton.getSelection();
 277         fIsExcludedEvents = fExcludedEventsButton.getSelection();
 278
 279         // initialize tracepoint fields
 280         fIsAllTracepoints = false;
 281         fSelectedEvents = new ArrayList<>();
 282         if (fIsTracepoints) {
 283             Set<String> set = new HashSet<>();
 284             Object[] checkedElements = fTracepointsViewer.getCheckedElements();
 285             int totalNbEvents = 0;
 286             for (int i = 0; i < checkedElements.length; i++) {
 287                 ITraceControlComponent component = (ITraceControlComponent) checkedElements[i];
 288                 if (component instanceof BaseEventComponent) {
 289                     totalNbEvents++;
 290                     if (!set.contains(component.getName())) {
 291                         set.add(component.getName());
 292                         fSelectedEvents.add(component.getName());
 293                     }
 294                 }
 295
 296             }
 297
 298             // verify if all events are selected
 299             int nbUstEvents = 0;
 300             List<ITraceControlComponent> comps = fProviderGroup.getChildren(UstProviderComponent.class);
 301             for (ITraceControlComponent comp : comps) {
 302                 List<ITraceControlComponent> children = comp.getChildren(BaseEventComponent.class);
 303                 nbUstEvents = children.size();
 304             }
 305             fIsAllTracepoints = (nbUstEvents == totalNbEvents);
 306         }
 307
 308         // Get the list of event(s) to exclude
 309         fExcludedEvents = null;
 310         if (fIsExcludedEvents) {
 311             String tmpExcludedEvent = fExcludedEventsText.getText();
 312             if (tmpExcludedEvent.trim().isEmpty()) {
 313                 MessageDialog.openError(getShell(),
 314                         Messages.TraceControl_EnableEventsDialogTitle,
 315                         Messages.TraceControl_InvalidExcludedEventsError);
 316
 317                 return false;
 318             }
 319             // Format the text to a List<String>
 320             // Removing all non visible characters
 321             tmpExcludedEvent = tmpExcludedEvent.replaceAll("\\s", ""); //$NON-NLS-1$ //$NON-NLS-2$
 322             // Splitting the different events that are separated by commas
 323             fExcludedEvents = Arrays.asList(tmpExcludedEvent.split(",")); //$NON-NLS-1$
 324         }
 325
 326
 327         // initialize log level event name string
 328         // We are using the fSelectedEvents for the loglevels
 329         fLogLevelType = LogLevelType.LOGLEVEL_NONE;
 330
 331         if (fIsLogLevel) {
 332             if (fLogLevelButton.getSelection()) {
 333                 fLogLevelType = LogLevelType.LOGLEVEL;
 334             } else if (fLogLevelOnlyButton.getSelection()) {
 335                 fLogLevelType = LogLevelType.LOGLEVEL_ONLY;
 336             }
 337
 338             String temp = fLogLevelEventNameText.getText();
 339             // TODO : Add support for comma separated list of events
 340             if (temp.trim().isEmpty() ||
 341                 (!temp.matches("^[\\s]{0,}$") && !temp.matches("^[a-zA-Z0-9\\-\\_]{1,}$"))) { //$NON-NLS-1$ //$NON-NLS-2$
 342                 MessageDialog.openError(getShell(),
 343                         Messages.TraceControl_EnableEventsDialogTitle,
 344                         Messages.TraceControl_InvalidLogLevelEventNameError + " (" + temp + ") \n");  //$NON-NLS-1$ //$NON-NLS-2$
 345
 346                 return false;
 347             }
 348
 349             // Format the String into a List<String>
 350             fSelectedEvents = Arrays.asList(temp.trim().split(",")); //$NON-NLS-1$
 351
 352             TraceLogLevel[] levels = TraceLogLevel.values();
 353             int id = fLogLevelCombo.getSelectionIndex();
 354
 355             if (id < 0) {
 356                 MessageDialog.openError(getShell(),
 357                         Messages.TraceControl_EnableEventsDialogTitle,
 358                         Messages.TraceControl_InvalidLogLevel + " (" + temp + ") \n");  //$NON-NLS-1$ //$NON-NLS-2$
 359
 360                 return false;
 361             }
 362             fLogLevel = levels[id];
 363         }
 364
 365         // initialize wildcard with null
 366         fWildcard = null;
 367         if (fIsWildcard) {
 368             String tempWildcard = fWildcardText.getText();
 369             if (tempWildcard.trim().isEmpty() ||
 370                 (!tempWildcard.matches("^[\\s]{0,}$") && !tempWildcard.matches("^[a-zA-Z0-9\\-\\_\\*\\\\\\']{1,}$"))) { //$NON-NLS-1$ //$NON-NLS-2$
 371                 MessageDialog.openError(getShell(),
 372                         Messages.TraceControl_EnableEventsDialogTitle,
 373                         Messages.TraceControl_InvalidWildcardError + " (" + tempWildcard + ") \n");  //$NON-NLS-1$ //$NON-NLS-2$
 374
 375                 return false;
 376             }
 377
 378             fWildcard = tempWildcard;
 379         }
 380
 381         // initialize filter with null
 382         fFilterExpression = null;
 383         if (fProviderGroup.isEventFilteringSupported(TraceDomainType.UST)) {
 384             String tempFilter = fFilterText.getText();
 385
 386             if(!tempFilter.trim().isEmpty()) {
 387                 fFilterExpression = tempFilter;
 388             }
 389         }
 390
 391         // validation successful -> call super.okPressed()
 392         return true;
 393     }
 394
 395     // ------------------------------------------------------------------------
 396     // Helper methods
 397     // ------------------------------------------------------------------------
 398
 399     /**
 400      * Creates tracepoints group.
 401      */
 402     private void createTracepointsGroup() {
 403         Group tpMainGroup = new Group(this, SWT.SHADOW_NONE);
 404         tpMainGroup.setText(Messages.TraceControl_EnableEventsTracepointGroupName);
 405         GridLayout layout = new GridLayout(2, false);
 406         tpMainGroup.setLayout(layout);
 407         GridData data = new GridData(GridData.FILL_BOTH);
 408         tpMainGroup.setLayoutData(data);
 409
 410         Composite buttonComposite = new Composite(tpMainGroup, SWT.NONE);
 411         layout = new GridLayout(1, true);
 412         buttonComposite.setLayout(layout);
 413         data = new GridData(SWT.BEGINNING, SWT.CENTER, false, true);
 414         buttonComposite.setLayoutData(data);
 415
 416         fTracepointsActivateButton = new Button(buttonComposite, SWT.RADIO);
 417         fTracepointsActivateButton.setText(Messages.TraceControl_EnableGroupSelectionName);
 418         data = new GridData(GridData.FILL_HORIZONTAL);
 419         fTracepointsActivateButton.setLayoutData(data);
 420         fTracepointsActivateButton.addSelectionListener(new SelectionAdapter() {
 421             @Override
 422             public void widgetSelected(SelectionEvent e) {
 423                 setEnablements(GroupEnum.TRACEPOINTS);
 424             }
 425         });
 426
 427         Group tpGroup = new Group(tpMainGroup, SWT.SHADOW_NONE);
 428         layout = new GridLayout(1, true);
 429         tpGroup.setLayout(layout);
 430         data = new GridData(GridData.FILL_BOTH);
 431         tpGroup.setLayoutData(data);
 432         new FilteredTree(tpGroup, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER, new PatternFilter(), true) {
 433             @Override
 434             protected TreeViewer doCreateTreeViewer(Composite aparent, int style) {
 435                 fTracepointsViewer = new CheckboxTreeViewer(aparent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
 436                 fTracepointsViewer.getTree().setToolTipText(Messages.TraceControl_EnableEventsTracepointTreeTooltip);
 437                 fTracepointsViewer.setContentProvider(new UstContentProvider());
 438
 439                 fTracepointsViewer.setLabelProvider(new UstLabelProvider());
 440                 fTracepointsViewer.addCheckStateListener(new UstCheckStateListener());
 441
 442                 fTracepointsViewer.setInput(fProviderGroup.getParent());
 443                 fTracepointsViewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH));
 444                 return fTracepointsViewer;
 445             }
 446         };
 447     }
 448
 449     /**
 450      * Creates wildcard group.
 451      */
 452     private void createWildCardGroup() {
 453         Group wildcardMainGroup = new Group(this, SWT.SHADOW_NONE);
 454         wildcardMainGroup.setText(Messages.TraceControl_EnableEventsWildcardGroupName);
 455         GridLayout layout = new GridLayout(2, false);
 456         wildcardMainGroup.setLayout(layout);
 457         GridData data = new GridData(GridData.FILL_HORIZONTAL);
 458         wildcardMainGroup.setLayoutData(data);
 459
 460         Composite buttonComposite = new Composite(wildcardMainGroup, SWT.NONE);
 461         layout = new GridLayout(1, false);
 462         buttonComposite.setLayout(layout);
 463         data = new GridData(SWT.BEGINNING, SWT.CENTER, false, true);
 464         buttonComposite.setLayoutData(data);
 465
 466         fWildcardActivateButton = new Button(buttonComposite, SWT.RADIO);
 467         fWildcardActivateButton.setText(Messages.TraceControl_EnableGroupSelectionName);
 468         fWildcardActivateButton.setSelection(false);
 469         data = new GridData(GridData.FILL_HORIZONTAL);
 470         fWildcardActivateButton.setLayoutData(data);
 471         fWildcardActivateButton.addSelectionListener(new SelectionAdapter() {
 472             @Override
 473             public void widgetSelected(SelectionEvent e) {
 474                 setEnablements(GroupEnum.WILDCARD);
 475             }
 476         });
 477
 478         Group wildcardGroup = new Group(wildcardMainGroup, SWT.SHADOW_NONE);
 479         layout = new GridLayout(3, true);
 480         wildcardGroup.setLayout(layout);
 481         data = new GridData(GridData.FILL_HORIZONTAL);
 482         wildcardGroup.setLayoutData(data);
 483
 484         Label wildcardLabel = new Label(wildcardGroup, SWT.LEFT);
 485         wildcardLabel.setText(Messages.TraceControl_EnableEventsWildcardLabel);
 486         data = new GridData(GridData.FILL_HORIZONTAL);
 487         data.horizontalSpan = 1;
 488         wildcardLabel.setLayoutData(data);
 489
 490         fWildcardText = new Text(wildcardGroup, SWT.LEFT);
 491         fWildcardText.setToolTipText(Messages.TraceControl_EnableEventsWildcardTooltip);
 492         data = new GridData(GridData.FILL_HORIZONTAL);
 493         data.horizontalSpan = 2;
 494         fWildcardText.setLayoutData(data);
 495     }
 496
 497     /**
 498      * Creates exclude events group.
 499      */
 500     private void createExcludeGroup() {
 501         Group excludedEventMainGroup = new Group(this, SWT.SHADOW_NONE);
 502         excludedEventMainGroup.setText(Messages.TraceControl_EnableEventsExcludedEventGroupName);
 503         GridLayout layout = new GridLayout(2, false);
 504         excludedEventMainGroup.setLayout(layout);
 505         GridData data = new GridData(GridData.FILL_HORIZONTAL);
 506         excludedEventMainGroup.setLayoutData(data);
 507
 508         Composite buttonComposite = new Composite(excludedEventMainGroup, SWT.NONE);
 509         layout = new GridLayout(1, false);
 510         buttonComposite.setLayout(layout);
 511         data = new GridData(SWT.BEGINNING, SWT.CENTER, false, true);
 512         buttonComposite.setLayoutData(data);
 513
 514         fExcludedEventsButton = new Button(buttonComposite, SWT.CHECK);
 515         fExcludedEventsButton.setText(Messages.TraceControl_EnableGroupSelectionName);
 516         fExcludedEventsButton.setSelection(false);
 517
 518         data = new GridData(GridData.FILL_HORIZONTAL);
 519         fExcludedEventsButton.setLayoutData(data);
 520
 521         fExcludedEventsButton.addSelectionListener(new SelectionAdapter() {
 522             @Override
 523             public void widgetSelected(SelectionEvent e) {
 524                 fExcludedEventsText.setEnabled(fExcludedEventsButton.getSelection());
 525             }
 526         });
 527
 528         Group excludedEventGroup = new Group(excludedEventMainGroup, SWT.SHADOW_NONE);
 529         layout = new GridLayout(3, true);
 530         excludedEventGroup.setLayout(layout);
 531         data = new GridData(GridData.FILL_HORIZONTAL);
 532         excludedEventGroup.setLayoutData(data);
 533
 534         Label excludedEventLabel = new Label(excludedEventGroup, SWT.LEFT);
 535         excludedEventLabel.setText(Messages.TraceControl_EnableEventsExcludedEventLabel);
 536
 537         data.horizontalSpan = 1;
 538         excludedEventLabel.setLayoutData(data);
 539
 540         fExcludedEventsText = new Text(excludedEventGroup, SWT.LEFT);
 541         fExcludedEventsText.setToolTipText(Messages.TraceControl_EnableEventsExcludedEventTooltip);
 542         data = new GridData(GridData.FILL_HORIZONTAL);
 543         data.horizontalSpan = 2;
 544         fExcludedEventsText.setLayoutData(data);
 545         fExcludedEventsText.setEnabled(false);
 546     }
 547
 548
 549     /**
 550      * Creates log level group.
 551      */
 552     private void createLogLevelGroup() {
 553         Group logLevelMainGroup = new Group(this, SWT.SHADOW_NONE);
 554         logLevelMainGroup.setText(Messages.TraceControl_EnableEventsLogLevelGroupName);
 555         GridLayout layout = new GridLayout(2, false);
 556         logLevelMainGroup.setLayout(layout);
 557         GridData data = new GridData(GridData.FILL_HORIZONTAL);
 558         logLevelMainGroup.setLayoutData(data);
 559
 560         Composite buttonComposite = new Composite(logLevelMainGroup, SWT.NONE);
 561         layout = new GridLayout(1, false);
 562         buttonComposite.setLayout(layout);
 563         data = new GridData(SWT.BEGINNING, SWT.CENTER, false, true);
 564         buttonComposite.setLayoutData(data);
 565
 566         fLogLevelActivateButton = new Button(buttonComposite, SWT.RADIO);
 567         fLogLevelActivateButton.setText(Messages.TraceControl_EnableGroupSelectionName);
 568         fLogLevelActivateButton.setSelection(false);
 569         data = new GridData(GridData.FILL_HORIZONTAL);
 570         fLogLevelActivateButton.setLayoutData(data);
 571         fLogLevelActivateButton.addSelectionListener(new SelectionAdapter() {
 572             @Override
 573             public void widgetSelected(SelectionEvent e) {
 574                 setEnablements(GroupEnum.LOGLEVEL);
 575             }
 576         });
 577
 578         Group logLevelGroup = new Group(logLevelMainGroup, SWT.SHADOW_NONE);
 579         layout = new GridLayout(3, true);
 580         logLevelGroup.setLayout(layout);
 581         logLevelGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
 582
 583         Label logLevelEventNameLabel = new Label(logLevelGroup, SWT.LEFT);
 584         logLevelEventNameLabel.setText(Messages.TraceControl_EnableEventsEventNameLabel);
 585
 586         data = new GridData(GridData.FILL_BOTH);
 587         data.horizontalSpan = 1;
 588         logLevelEventNameLabel.setLayoutData(data);
 589
 590         fLogLevelEventNameText = new Text(logLevelGroup, SWT.LEFT);
 591         fLogLevelEventNameText.setToolTipText(Messages.TraceControl_EnableEventsLoglevelEventNameTooltip);
 592         data = new GridData(GridData.FILL_BOTH);
 593         data.horizontalSpan = 2;
 594         fLogLevelEventNameText.setLayoutData(data);
 595
 596         fLogLevelButton = new Button(logLevelGroup, SWT.RADIO);
 597         fLogLevelButton.setText(Messages.TraceControl_EnableEventsLogLevelTypeName);
 598         fLogLevelButton.setToolTipText(Messages.TraceControl_EnableEventsLogLevelTypeTooltip);
 599         data = new GridData(GridData.FILL_BOTH);
 600         fLogLevelButton.setLayoutData(data);
 601         fLogLevelButton.setSelection(true);
 602
 603         fLogLevelOnlyButton = new Button(logLevelGroup, SWT.RADIO);
 604         fLogLevelOnlyButton.setText(Messages.TraceControl_EnableEventsLogLevelOnlyTypeName);
 605         fLogLevelOnlyButton.setToolTipText(Messages.TraceControl_EnableEventsLogLevelOnlyTypeTooltip);
 606         data = new GridData(GridData.FILL_BOTH);
 607         fLogLevelButton.setLayoutData(data);
 608
 609         TraceLogLevel[] levels = TraceLogLevel.values();
 610
 611         String[] levelNames = new String[levels.length - 1];
 612         int k = 0;
 613         for (int i = 0; i < levels.length; i++) {
 614             if (levels[i] != TraceLogLevel.LEVEL_UNKNOWN) {
 615                 levelNames[k++] = levels[i].getInName();
 616             }
 617         }
 618
 619         fLogLevelCombo = new CCombo(logLevelGroup, SWT.READ_ONLY);
 620         fLogLevelCombo.setItems(levelNames);
 621         fLogLevelCombo.setToolTipText(Messages.TraceControl_EnableEventsLogLevelTooltip);
 622         data = new GridData(GridData.FILL_HORIZONTAL);
 623         data.horizontalSpan = 4;
 624         fLogLevelCombo.setLayoutData(data);
 625     }
 626
 627     void createFilterGroup() {
 628         if (fProviderGroup.isEventFilteringSupported(TraceDomainType.UST)) {
 629             Group filterMainGroup = new Group(this, SWT.SHADOW_NONE);
 630             filterMainGroup.setText(Messages.TraceControl_EnableEventsFilterGroupName);
 631             GridLayout layout = new GridLayout(3, false);
 632             filterMainGroup.setLayout(layout);
 633             GridData data = new GridData(GridData.FILL_HORIZONTAL);
 634             filterMainGroup.setLayoutData(data);
 635
 636             fFilterText = new Text(filterMainGroup, SWT.LEFT);
 637             fFilterText.setToolTipText(Messages.TraceControl_EnableEventsFilterTooltip);
 638             data = new GridData(GridData.FILL_HORIZONTAL);
 639             fFilterText.setLayoutData(data);
 640         }
 641     }
 642
 643     /**
 644      * Enable/selects widgets depending on the group specified.
 645      * @param group - group to enable.
 646      */
 647     private void setEnablements(GroupEnum group) {
 648
 649         // Enable/disable trace point items
 650         fTracepointsActivateButton.setSelection(group == GroupEnum.TRACEPOINTS);
 651         fTracepointsViewer.getTree().setEnabled(group == GroupEnum.TRACEPOINTS);
 652
 653         // Enable/disable wildcard items
 654         fWildcardActivateButton.setSelection(group == GroupEnum.WILDCARD);
 655         fWildcardText.setEnabled(group == GroupEnum.WILDCARD);
 656
 657         // Enable/disable log level items
 658         fLogLevelActivateButton.setSelection(group == GroupEnum.LOGLEVEL);
 659         fLogLevelEventNameText.setEnabled(group == GroupEnum.LOGLEVEL);
 660         fLogLevelCombo.setEnabled(group == GroupEnum.LOGLEVEL);
 661         fLogLevelButton.setEnabled(group == GroupEnum.LOGLEVEL);
 662         fLogLevelOnlyButton.setEnabled(group == GroupEnum.LOGLEVEL);
 663     }
 664
 665     // ------------------------------------------------------------------------
 666     // Local classes
 667     // ------------------------------------------------------------------------
 668     /**
 669      * Content provider for the tracepoints tree.
 670      */
 671     public static final class UstContentProvider extends TraceControlContentProvider {
 672         @Override
 673         public Object[] getChildren(Object parentElement) {
 674             if (parentElement instanceof TargetNodeComponent) {
 675                 List<ITraceControlComponent> children = ((ITraceControlComponent)parentElement).getChildren(TraceProviderGroup.class);
 676                 return children.toArray(new ITraceControlComponent[children.size()]);
 677             }
 678             if (parentElement instanceof TraceProviderGroup) {
 679                 List<ITraceControlComponent> children = ((ITraceControlComponent)parentElement).getChildren(UstProviderComponent.class);
 680                 return children.toArray(new ITraceControlComponent[children.size()]);
 681             }
 682             if (parentElement instanceof UstProviderComponent) {
 683                 List<ITraceControlComponent> events = ((UstProviderComponent) parentElement).getChildren(BaseEventComponent.class);
 684                 return events.toArray(new BaseEventComponent[events.size()]);
 685             }
 686
 687             return new Object[0];
 688         }
 689     }
 690
 691     /**
 692      * Content label for the tracepoints tree.
 693      */
 694     public static final class UstLabelProvider extends TraceControlLabelProvider {
 695         @Override
 696         public Image getImage(Object element) {
 697             return null;
 698         }
 699         @Override
 700         public String getText(Object element) {
 701             if ((element != null) && (element instanceof TraceProviderGroup)) {
 702                 return Messages.TraceControl_EnableEventsTreeAllLabel;
 703             }
 704
 705             if ((element != null) && (element instanceof UstProviderComponent)) {
 706                 return Messages.TraceControl_EnableEventsTreeAllLabel + " - " + ((UstProviderComponent)element).getName(); //$NON-NLS-1$
 707             }
 708             return super.getText(element);
 709         }
 710     }
 711
 712     /**
 713      * Check state listener for the tracepoints tree.
 714      */
 715     public final class UstCheckStateListener implements ICheckStateListener {
 716         @Override
 717         public void checkStateChanged(CheckStateChangedEvent event) {
 718             if (event.getChecked()) {
 719                 if (event.getElement() instanceof TraceProviderGroup) {
 720                     fTracepointsViewer.setSubtreeChecked(event.getElement(), true);
 721                 }
 722                 if (event.getElement() instanceof UstProviderComponent) {
 723                     fTracepointsViewer.setSubtreeChecked(event.getElement(), true);
 724                 }
 725             } else {
 726                 if (event.getElement() instanceof TraceProviderGroup) {
 727                     fTracepointsViewer.setSubtreeChecked(event.getElement(), true);
 728                 }
 729                 if (event.getElement() instanceof UstProviderComponent) {
 730                     ITraceControlComponent component = (ITraceControlComponent) event.getElement();
 731                     fTracepointsViewer.setSubtreeChecked(event.getElement(), false);
 732                     fTracepointsViewer.setChecked(component.getParent(), false);
 733                 } else {
 734                     ITraceControlComponent component = (ITraceControlComponent) event.getElement();
 735                     fTracepointsViewer.setChecked(component.getParent(), false);
 736                     fTracepointsViewer.setChecked(component.getParent().getParent(), false);
 737                 }
 738             }
 739         }
 740     }
 741 }