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

   1 /**********************************************************************
   2  * Copyright (c) 2016 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  *   Bruno Roy - Initial API and implementation
  11  **********************************************************************/
  12 package org.eclipse.tracecompass.internal.lttng2.control.ui.views.dialogs;
  13
  14 import java.util.ArrayList;
  15 import java.util.HashSet;
  16 import java.util.List;
  17 import java.util.Set;
  18 import java.util.stream.Collectors;
  19
  20 import org.eclipse.jface.dialogs.MessageDialog;
  21 import org.eclipse.jface.viewers.CheckStateChangedEvent;
  22 import org.eclipse.jface.viewers.CheckboxTreeViewer;
  23 import org.eclipse.jface.viewers.ICheckStateListener;
  24 import org.eclipse.jface.viewers.TreeViewer;
  25 import org.eclipse.swt.SWT;
  26 import org.eclipse.swt.custom.CCombo;
  27 import org.eclipse.swt.events.SelectionAdapter;
  28 import org.eclipse.swt.events.SelectionEvent;
  29 import org.eclipse.swt.graphics.Image;
  30 import org.eclipse.swt.layout.GridData;
  31 import org.eclipse.swt.layout.GridLayout;
  32 import org.eclipse.swt.widgets.Button;
  33 import org.eclipse.swt.widgets.Composite;
  34 import org.eclipse.swt.widgets.Group;
  35 import org.eclipse.tracecompass.internal.lttng2.control.core.model.LogLevelType;
  36 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceDomainType;
  37 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceJulLogLevel;
  38 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.messages.Messages;
  39 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.ITraceControlComponent;
  40 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.BaseLoggerComponent;
  41 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TargetNodeComponent;
  42 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceControlContentProvider;
  43 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceControlLabelProvider;
  44 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceProviderGroup;
  45 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.UstProviderComponent;
  46 import org.eclipse.ui.dialogs.FilteredTree;
  47 import org.eclipse.ui.dialogs.PatternFilter;
  48
  49 /**
  50  * A composite for collecting information about JUL events to be enabled.
  51  *
  52  * @author Bruno Roy
  53  */
  54 public class EnableJulEventsComposite extends Composite implements IBaseEnableUstEvents {
  55
  56     // ------------------------------------------------------------------------
  57     // Constants
  58     // ------------------------------------------------------------------------
  59
  60     private enum GroupEnum { LOGGERS }
  61
  62     // ------------------------------------------------------------------------
  63     // Attributes
  64     // ------------------------------------------------------------------------
  65
  66     /**
  67      * The referenced trace provider group containing the JUL providers
  68      * component which contains a list of available tracepoints.
  69      */
  70     private final TraceProviderGroup fProviderGroup;
  71     /**
  72      * A button to enable/disable the loggers group
  73      */
  74     private Button fLoggersActivateButton;
  75     /**
  76      * A tree viewer for displaying and selection of available loggers.
  77      */
  78     private CheckboxTreeViewer fLoggersViewer;
  79     /**
  80      * The flag indicating that loggers are selected.
  81      */
  82     private boolean fIsLoggers;
  83     /**
  84      * The list of loggers to be enabled.
  85      */
  86     private List<String> fLoggers;
  87     /**
  88      * A button to enable/disable the log level group
  89      */
  90     private Button fLogLevelActivateButton;
  91     /**
  92      * A Combo box for selecting the log level.
  93      */
  94     private CCombo fLogLevelCombo;
  95     /**
  96      * A button for selecting the log level (range 0 to level).
  97      */
  98     private Button fLogLevelButton;
  99     /**
 100      * A button for selecting the specified log level only.
 101      */
 102     private Button fLogLevelOnlyButton;
 103     /**
 104      * The flag indicating that all log level are selected.
 105      */
 106     private boolean fIsLogLevel;
 107     /**
 108      * The flag indicating that all loggers (across providers) are selected.
 109      */
 110     private boolean fIsAllLoggers;
 111     /**
 112      * The type of the log level (loglevel or loglevel-only)
 113      */
 114     private LogLevelType fLogLevelType;
 115     /**
 116      * The selected log level.
 117      */
 118     private TraceJulLogLevel fLogLevel;
 119
 120     // ------------------------------------------------------------------------
 121     // Constructors
 122     // ------------------------------------------------------------------------
 123     /**
 124      * Constructor
 125      *
 126      * @param parent
 127      *            a parent composite
 128      * @param style
 129      *            a composite style
 130      * @param providerGroup
 131      *            the trace provider group
 132      */
 133     public EnableJulEventsComposite(Composite parent, int style, TraceProviderGroup providerGroup) {
 134         super(parent, style);
 135         fProviderGroup = providerGroup;
 136     }
 137
 138     // ------------------------------------------------------------------------
 139     // Accessors
 140     // ------------------------------------------------------------------------
 141
 142     @Override
 143     public TraceJulLogLevel getLogLevel() {
 144         return fLogLevel;
 145     }
 146
 147     @Override
 148     public LogLevelType getLogLevelType() {
 149         return fLogLevelType;
 150     }
 151
 152     @Override
 153     public boolean isAllTracePoints() {
 154         return fIsAllLoggers;
 155     }
 156
 157     @Override
 158     public List<String> getEventNames() {
 159         return new ArrayList<>(fLoggers);
 160     }
 161
 162     @Override
 163     public boolean isLogLevel() {
 164         return fIsLogLevel;
 165     }
 166
 167     // ------------------------------------------------------------------------
 168     // Operations
 169     // ------------------------------------------------------------------------
 170
 171     /**
 172      * Create the contents of this event composite
 173      */
 174     public void createContent() {
 175
 176         // Logger group
 177         createLoggersGroup();
 178
 179         // Log Level Group
 180         createLogLevelGroup();
 181
 182         // Set default enablements
 183         setEnablements(GroupEnum.LOGGERS);
 184     }
 185
 186     /**
 187      * Validates the UST composite input data.
 188      *
 189      * @return true if configured data is valid and can be retrieved.
 190      */
 191     public boolean isValid() {
 192
 193         fIsLoggers = fLoggersActivateButton.getSelection();
 194         fIsLogLevel = fLogLevelActivateButton.getSelection();
 195
 196         // Initialize loggers fields
 197         fLoggers = new ArrayList<>();
 198         if (fIsLoggers) {
 199             Set<String> set = new HashSet<>();
 200             Object[] checkedElements = fLoggersViewer.getCheckedElements();
 201             int totalNbEvents = 0;
 202             for (int i = 0; i < checkedElements.length; i++) {
 203                 ITraceControlComponent component = (ITraceControlComponent) checkedElements[i];
 204                 if (component instanceof BaseLoggerComponent) {
 205                     totalNbEvents++;
 206                     if (!set.contains(component.getName())) {
 207                         set.add(component.getName());
 208                         fLoggers.add(component.getName());
 209                     }
 210                 }
 211
 212             }
 213
 214             // verify if all events are selected
 215             int nbJulEvents = 0;
 216             List<ITraceControlComponent> comps = fProviderGroup.getChildren(UstProviderComponent.class);
 217             for (ITraceControlComponent comp : comps) {
 218                 // We want the children of each UST provider
 219                 ITraceControlComponent[] events = comp.getChildren();
 220                 for (ITraceControlComponent event : events) {
 221                     if (event instanceof BaseLoggerComponent) {
 222                         nbJulEvents++;
 223                     }
 224                 }
 225
 226             }
 227             fIsAllLoggers = nbJulEvents == totalNbEvents;
 228         }
 229
 230         // initialize log level event name string
 231         fLogLevelType = LogLevelType.LOGLEVEL_NONE;
 232         if (fIsLogLevel) {
 233             if (fLogLevelButton.getSelection()) {
 234                 fLogLevelType = LogLevelType.LOGLEVEL;
 235             } else if (fLogLevelOnlyButton.getSelection()) {
 236                 fLogLevelType = LogLevelType.LOGLEVEL_ONLY;
 237             }
 238
 239             TraceJulLogLevel[] levels = TraceJulLogLevel.values();
 240             int id = fLogLevelCombo.getSelectionIndex();
 241
 242             if (id < 0) {
 243                 MessageDialog.openError(getShell(),
 244                         Messages.TraceControl_EnableLoggersDialogTitle,
 245                         Messages.TraceControl_InvalidLogLevel);
 246
 247                 return false;
 248             }
 249
 250             if (fLoggers.isEmpty()) {
 251                 MessageDialog.openError(getShell(),
 252                         Messages.TraceControl_EnableLoggersDialogTitle,
 253                         Messages.TraceControl_InvalidLogger);
 254
 255                 return false;
 256             }
 257             fLogLevel = levels[id];
 258         }
 259
 260         // validation successful -> call super.okPressed()
 261         return true;
 262     }
 263
 264     // ------------------------------------------------------------------------
 265     // Helper methods
 266     // ------------------------------------------------------------------------
 267
 268     /**
 269      * Creates loggers group.
 270      */
 271     private void createLoggersGroup() {
 272         // Create the loggers group
 273         Group loggersMainGroup = new Group(this, SWT.SHADOW_NONE);
 274         loggersMainGroup.setText(Messages.TraceControl_EnableEventsLoggerGroupName);
 275         GridLayout layout = new GridLayout(2, false);
 276         loggersMainGroup.setLayout(layout);
 277         GridData data = new GridData(GridData.FILL_BOTH);
 278         loggersMainGroup.setLayoutData(data);
 279
 280         // Create the Select button
 281         Composite buttonComposite = new Composite(loggersMainGroup, SWT.NONE);
 282         layout = new GridLayout(1, true);
 283         buttonComposite.setLayout(layout);
 284         data = new GridData(SWT.BEGINNING, SWT.CENTER, false, true);
 285         buttonComposite.setLayoutData(data);
 286
 287         fLoggersActivateButton = new Button(buttonComposite, SWT.RADIO);
 288         fLoggersActivateButton.setText(Messages.TraceControl_EnableGroupSelectionName);
 289         data = new GridData(GridData.FILL_HORIZONTAL);
 290         fLoggersActivateButton.setLayoutData(data);
 291         fLoggersActivateButton.addSelectionListener(new SelectionAdapter() {
 292             @Override
 293             public void widgetSelected(SelectionEvent e) {
 294                 setEnablements(GroupEnum.LOGGERS);
 295             }
 296         });
 297
 298         // Create the group for the tree
 299         Group loggersGroup = new Group(loggersMainGroup, SWT.SHADOW_NONE);
 300         layout = new GridLayout(1, true);
 301         loggersGroup.setLayout(layout);
 302         data = new GridData(GridData.FILL_BOTH);
 303         loggersGroup.setLayoutData(data);
 304         new FilteredTree(loggersGroup, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER, new PatternFilter(), true) {
 305             @Override
 306             protected TreeViewer doCreateTreeViewer(Composite aparent, int style) {
 307                 fLoggersViewer = new CheckboxTreeViewer(aparent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
 308                 fLoggersViewer.getTree().setToolTipText(Messages.TraceControl_EnableEventsLoggerTreeTooltip);
 309                 fLoggersViewer.setContentProvider(new JulContentProvider());
 310
 311                 fLoggersViewer.setLabelProvider(new JulLabelProvider());
 312                 fLoggersViewer.addCheckStateListener(new JulCheckStateListener());
 313
 314                 fLoggersViewer.setInput(fProviderGroup.getParent());
 315                 fLoggersViewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH));
 316                 return fLoggersViewer;
 317             }
 318         };
 319     }
 320
 321     /**
 322      * Creates log level group.
 323      */
 324     private void createLogLevelGroup() {
 325         Group logLevelMainGroup = new Group(this, SWT.SHADOW_NONE);
 326         logLevelMainGroup.setText(Messages.TraceControl_EnableEventsLogLevelGroupName);
 327         GridLayout layout = new GridLayout(2, false);
 328         logLevelMainGroup.setLayout(layout);
 329         GridData data = new GridData(GridData.FILL_HORIZONTAL);
 330         logLevelMainGroup.setLayoutData(data);
 331
 332         Composite buttonComposite = new Composite(logLevelMainGroup, SWT.NONE);
 333         layout = new GridLayout(1, false);
 334         buttonComposite.setLayout(layout);
 335         data = new GridData(SWT.BEGINNING, SWT.CENTER, false, true);
 336         buttonComposite.setLayoutData(data);
 337
 338         fLogLevelActivateButton = new Button(buttonComposite, SWT.CHECK);
 339         fLogLevelActivateButton.setText(Messages.TraceControl_EnableGroupSelectionName);
 340         fLogLevelActivateButton.setSelection(false);
 341         data = new GridData(GridData.FILL_HORIZONTAL);
 342         fLogLevelActivateButton.setLayoutData(data);
 343         fLogLevelActivateButton.addSelectionListener(new SelectionAdapter() {
 344             @Override
 345             public void widgetSelected(SelectionEvent e) {
 346                 fLogLevelCombo.setEnabled(fLogLevelActivateButton.getSelection());
 347                 fLogLevelButton.setEnabled(fLogLevelActivateButton.getSelection());
 348                 fLogLevelOnlyButton.setEnabled(fLogLevelActivateButton.getSelection());
 349             }
 350         });
 351
 352         Group logLevelGroup = new Group(logLevelMainGroup, SWT.SHADOW_NONE);
 353         layout = new GridLayout(2, true);
 354         logLevelGroup.setLayout(layout);
 355         logLevelGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
 356
 357         fLogLevelButton = new Button(logLevelGroup, SWT.RADIO);
 358         fLogLevelButton.setText(Messages.TraceControl_EnableEventsLogLevelTypeName);
 359         fLogLevelButton.setToolTipText(Messages.TraceControl_EnableEventsLogLevelTypeTooltip);
 360         data = new GridData(GridData.FILL_BOTH);
 361         fLogLevelButton.setLayoutData(data);
 362         fLogLevelButton.setSelection(true);
 363
 364         fLogLevelOnlyButton = new Button(logLevelGroup, SWT.RADIO);
 365         fLogLevelOnlyButton.setText(Messages.TraceControl_EnableEventsLogLevelOnlyTypeName);
 366         fLogLevelOnlyButton.setToolTipText(Messages.TraceControl_EnableEventsLogLevelOnlyTypeTooltip);
 367         data = new GridData(GridData.FILL_BOTH);
 368         fLogLevelButton.setLayoutData(data);
 369
 370         TraceJulLogLevel[] levels = TraceJulLogLevel.values();
 371
 372         String[] levelNames = new String[levels.length - 1];
 373         int k = 0;
 374         for (int i = 0; i < levels.length; i++) {
 375             if (levels[i] != TraceJulLogLevel.LEVEL_UNKNOWN) {
 376                 levelNames[k++] = levels[i].getInName();
 377             }
 378         }
 379
 380         fLogLevelCombo = new CCombo(logLevelGroup, SWT.READ_ONLY);
 381         fLogLevelCombo.setItems(levelNames);
 382         fLogLevelCombo.setToolTipText(Messages.TraceControl_EnableEventsLogLevelTooltip);
 383         data = new GridData(GridData.FILL_HORIZONTAL);
 384         data.horizontalSpan = 4;
 385         fLogLevelCombo.setLayoutData(data);
 386
 387         // By default the combo box and the buttons are not enabled
 388         fLogLevelCombo.setEnabled(false);
 389         fLogLevelButton.setEnabled(false);
 390         fLogLevelOnlyButton.setEnabled(false);
 391
 392     }
 393
 394     /**
 395      * Enable/selects widgets depending on the group specified.
 396      *
 397      * @param group
 398      *            group to enable.
 399      */
 400     private void setEnablements(GroupEnum group) {
 401
 402         // Enable/disable trace point items
 403         fLoggersActivateButton.setSelection(group == GroupEnum.LOGGERS);
 404         fLoggersViewer.getTree().setEnabled(group == GroupEnum.LOGGERS);
 405     }
 406
 407     /**
 408      * Content provider for the loggers tree.
 409      */
 410     public static final class JulContentProvider extends TraceControlContentProvider {
 411         @Override
 412         public Object[] getChildren(Object parentElement) {
 413             if (parentElement instanceof TargetNodeComponent) {
 414                 List<ITraceControlComponent> children = ((ITraceControlComponent) parentElement).getChildren(TraceProviderGroup.class);
 415                 return children.toArray(new ITraceControlComponent[children.size()]);
 416             }
 417             if (parentElement instanceof TraceProviderGroup) {
 418                 List<ITraceControlComponent> ustProviderChildren = ((ITraceControlComponent) parentElement).getChildren(UstProviderComponent.class)
 419                         .stream().filter(comp -> ((UstProviderComponent) comp).getLoggerComponents(TraceDomainType.JUL).size() > 0)
 420                         .collect(Collectors.toList());
 421                 return ustProviderChildren.toArray(new ITraceControlComponent[ustProviderChildren.size()]);
 422             }
 423             if (parentElement instanceof UstProviderComponent) {
 424                 List<ITraceControlComponent> loggers = ((UstProviderComponent) parentElement).getLoggerComponents(TraceDomainType.JUL);
 425                 return loggers.toArray(new ITraceControlComponent[loggers.size()]);
 426             }
 427             return new Object[0];
 428         }
 429     }
 430
 431     /**
 432      * Content label for the loggers tree.
 433      */
 434     public static final class JulLabelProvider extends TraceControlLabelProvider {
 435         @Override
 436         public Image getImage(Object element) {
 437             return null;
 438         }
 439
 440         @Override
 441         public String getText(Object element) {
 442             if ((element != null) && (element instanceof TraceProviderGroup)) {
 443                 return Messages.TraceControl_EnableEventsTreeAllLabel;
 444             }
 445
 446             if ((element != null) && (element instanceof UstProviderComponent)) {
 447                 return Messages.TraceControl_EnableEventsTreeAllLabel + " - " + ((UstProviderComponent)element).getName(); //$NON-NLS-1$
 448             }
 449             return super.getText(element);
 450         }
 451     }
 452
 453     /**
 454      * Check state listener for the loggers tree.
 455      */
 456     public final class JulCheckStateListener implements ICheckStateListener {
 457         @Override
 458         public void checkStateChanged(CheckStateChangedEvent event) {
 459             if (event.getChecked()) {
 460                 if (event.getElement() instanceof TraceProviderGroup) {
 461                     fLoggersViewer.setSubtreeChecked(event.getElement(), true);
 462                 }
 463                 if (event.getElement() instanceof UstProviderComponent) {
 464                     fLoggersViewer.setSubtreeChecked(event.getElement(), true);
 465                 }
 466             } else {
 467                 if (event.getElement() instanceof TraceProviderGroup) {
 468                     fLoggersViewer.setSubtreeChecked(event.getElement(), true);
 469                 }
 470                 if (event.getElement() instanceof UstProviderComponent) {
 471                     ITraceControlComponent component = (ITraceControlComponent) event.getElement();
 472                     fLoggersViewer.setSubtreeChecked(event.getElement(), false);
 473                     fLoggersViewer.setChecked(component.getParent(), false);
 474                 } else {
 475                     ITraceControlComponent component = (ITraceControlComponent) event.getElement();
 476                     fLoggersViewer.setChecked(component.getParent(), false);
 477                     fLoggersViewer.setChecked(component.getParent().getParent(), false);
 478                 }
 479             }
 480         }
 481     }
 482 }