org.eclipse.linuxtools.lttng2.ui/src/org/eclipse/linuxtools/internal/lttng2/ui/views/control/dialogs/AddContextDialog.java

   1 /**********************************************************************
   2  * Copyright (c) 2012, 2014 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  **********************************************************************/
  12 package org.eclipse.linuxtools.internal.lttng2.ui.views.control.dialogs;
  13
  14 import java.util.ArrayList;
  15 import java.util.Iterator;
  16 import java.util.List;
  17
  18 import org.eclipse.jface.dialogs.Dialog;
  19 import org.eclipse.jface.dialogs.IDialogConstants;
  20 import org.eclipse.jface.viewers.CheckStateChangedEvent;
  21 import org.eclipse.jface.viewers.CheckboxTreeViewer;
  22 import org.eclipse.jface.viewers.ColumnLabelProvider;
  23 import org.eclipse.jface.viewers.ICheckStateListener;
  24 import org.eclipse.jface.viewers.ITreeContentProvider;
  25 import org.eclipse.jface.viewers.Viewer;
  26 import org.eclipse.linuxtools.internal.lttng2.ui.Activator;
  27 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.messages.Messages;
  28 import org.eclipse.swt.SWT;
  29 import org.eclipse.swt.graphics.Point;
  30 import org.eclipse.swt.layout.GridData;
  31 import org.eclipse.swt.layout.GridLayout;
  32 import org.eclipse.swt.widgets.Composite;
  33 import org.eclipse.swt.widgets.Control;
  34 import org.eclipse.swt.widgets.Group;
  35 import org.eclipse.swt.widgets.Shell;
  36
  37 /**
  38  * <p>
  39  * Dialog box for collecting information about contexts to be added to channels/events.
  40  * </p>
  41  *
  42  * @author Bernd Hufmann
  43  */
  44 public class AddContextDialog extends Dialog implements IAddContextDialog  {
  45
  46     // ------------------------------------------------------------------------
  47     // Constants
  48     // ------------------------------------------------------------------------
  49
  50     /**
  51      * The icon file for this dialog box.
  52      */
  53     public static final String ADD_CONTEXT_ICON_FILE = "icons/elcl16/add-context.gif"; //$NON-NLS-1$
  54
  55     // ------------------------------------------------------------------------
  56     // Attributes
  57     // ------------------------------------------------------------------------
  58
  59     /**
  60      * A tree viewer for displaying and selection of available contexts.
  61      */
  62     private CheckboxTreeViewer fContextsViewer;
  63
  64     /**
  65      * A Tree model for the checkbox tree viewer.
  66      */
  67     private final ContextModel fContextModel = new ContextModel();
  68
  69     /**
  70      * The contexts to add.
  71      */
  72     private final List<String> fSelectedContexts = new ArrayList<>();
  73
  74     // ------------------------------------------------------------------------
  75     // Constructors
  76     // ------------------------------------------------------------------------
  77
  78     /**
  79      * Constructor
  80      * @param shell - a shell for the display of the dialog
  81      */
  82     public AddContextDialog(Shell shell) {
  83         super(shell);
  84         setShellStyle(SWT.RESIZE | getShellStyle());
  85     }
  86
  87     // ------------------------------------------------------------------------
  88     // Accessors
  89     // ------------------------------------------------------------------------
  90
  91     @Override
  92     public void setAvalibleContexts(List<String> contexts) {
  93         fContextModel.setAvalibleContexts(contexts);
  94     }
  95
  96     @Override
  97     public List<String> getContexts() {
  98         List<String> ret = new ArrayList<>();
  99         ret.addAll(fSelectedContexts);
 100         return ret;
 101     }
 102
 103     // ------------------------------------------------------------------------
 104     // Operations
 105     // ------------------------------------------------------------------------
 106
 107     @Override
 108     protected void configureShell(Shell newShell) {
 109         super.configureShell(newShell);
 110         newShell.setText(Messages.TraceControl_AddContextDialogTitle);
 111         newShell.setImage(Activator.getDefault().loadIcon(ADD_CONTEXT_ICON_FILE));
 112     }
 113
 114     @Override
 115     protected Control createDialogArea(Composite parent) {
 116
 117         // Main dialog panel
 118         Composite dialogComposite = new Composite(parent, SWT.NONE);
 119         GridLayout layout = new GridLayout(1, true);
 120         dialogComposite.setLayout(layout);
 121         dialogComposite.setLayoutData(new GridData(GridData.FILL_BOTH));
 122
 123         // Contexts list
 124         Group contextGroup = new Group(dialogComposite, SWT.SHADOW_NONE);
 125         contextGroup.setText(Messages.TraceControl_AddContextAvailableContextsLabel);
 126         layout = new GridLayout(1, true);
 127         contextGroup.setLayout(layout);
 128         contextGroup.setLayoutData(new GridData(GridData.FILL_BOTH));
 129
 130         fContextsViewer = new CheckboxTreeViewer(contextGroup, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
 131         fContextsViewer.getTree().setToolTipText(Messages.TraceControl_AddContextAvailableContextsTooltip);
 132
 133         fContextsViewer.setContentProvider(new ContextsContentProvider());
 134         fContextsViewer.setLabelProvider(new ContextsLabelProvider());
 135         fContextsViewer.addCheckStateListener(new ContextCheckListener());
 136         fContextsViewer.setInput(fContextModel);
 137         fContextsViewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH));
 138
 139         getShell().setMinimumSize(new Point(500, 450));
 140
 141         return dialogComposite;
 142     }
 143
 144     @Override
 145     protected void createButtonsForButtonBar(Composite parent) {
 146         createButton(parent, IDialogConstants.CANCEL_ID, "&Cancel", true); //$NON-NLS-1$
 147         createButton(parent, IDialogConstants.OK_ID, "&Ok", true); //$NON-NLS-1$
 148     }
 149
 150     @Override
 151     protected void okPressed() {
 152         fSelectedContexts.clear();
 153
 154         Object[] checkedElements = fContextsViewer.getCheckedElements();
 155         for (int i = 0; i < checkedElements.length; i++) {
 156             IContextModelComponent component = (IContextModelComponent)checkedElements[i];
 157             if (!Messages.TraceControl_AddContextAllLabel.equals(component.getName())) {
 158                 fSelectedContexts.add(component.getName());
 159             }
 160         }
 161
 162         // validation successful -> call super.okPressed()
 163         super.okPressed();
 164     }
 165
 166     // ------------------------------------------------------------------------
 167     // Helper classes and methods
 168     // ------------------------------------------------------------------------
 169     /**
 170      * Content provider for the contexts tree
 171      */
 172     public static final class ContextsContentProvider implements ITreeContentProvider {
 173
 174         @Override
 175         public void dispose() {
 176         }
 177
 178         @Override
 179         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 180         }
 181
 182         @Override
 183         public Object[] getElements(Object inputElement) {
 184             return getChildren(inputElement);
 185         }
 186
 187         @Override
 188         public Object[] getChildren(Object parentElement) {
 189             if (parentElement instanceof IContextModelComponent) {
 190                 return ((IContextModelComponent)parentElement).getChildren();
 191             }
 192             return null;
 193         }
 194
 195         @Override
 196         public Object getParent(Object element) {
 197             if (element instanceof IContextModelComponent) {
 198                 return ((IContextModelComponent)element).getParent();
 199             }
 200             return null;
 201         }
 202
 203         @Override
 204         public boolean hasChildren(Object element) {
 205             if (element instanceof IContextModelComponent) {
 206                 return ((IContextModelComponent)element).hasChildren();
 207             }
 208             return false;
 209         }
 210     }
 211
 212     /**
 213      * Label provider for the contexts tree
 214      */
 215     public static final class ContextsLabelProvider extends ColumnLabelProvider {
 216         @Override
 217         public String getText(Object element) {
 218
 219             if ((element != null) && (element instanceof IContextModelComponent)) {
 220                 return ((IContextModelComponent)element).getName();
 221             }
 222
 223             return "";//$NON-NLS-1$
 224         }
 225     }
 226
 227     /**
 228      * Check state listener for the contexts tree.
 229      */
 230     public final class ContextCheckListener implements ICheckStateListener {
 231         @Override
 232         public void checkStateChanged(CheckStateChangedEvent event) {
 233           if (event.getChecked()) {
 234               if (event.getElement() instanceof AllContexts) {
 235                   fContextsViewer.setSubtreeChecked(event.getElement(), true);
 236               }
 237           } else {
 238               if (event.getElement() instanceof AllContexts) {
 239                   fContextsViewer.setSubtreeChecked(event.getElement(), false);
 240               } else {
 241                   IContextModelComponent component = (IContextModelComponent) event.getElement();
 242                   fContextsViewer.setChecked(component.getParent(), false);
 243               }
 244           }
 245         }
 246     }
 247
 248     /**
 249      * Model for the context tree viewer (root component)
 250      */
 251     public static class ContextModel implements IContextModelComponent {
 252
 253         private final AllContexts fAllContexts;
 254
 255         /**
 256          * Constructor
 257          */
 258         public ContextModel() {
 259             fAllContexts = new AllContexts(this);
 260         }
 261
 262         /**
 263          * Sets the available contexts
 264          *
 265          * @param contexts
 266          *            The contexts to set
 267          */
 268         public void setAvalibleContexts(List<String> contexts) {
 269             fAllContexts.setAvalibleContexts(contexts);
 270         }
 271
 272         @Override
 273         public String getName() {
 274             return "root"; //$NON-NLS-1$
 275         }
 276
 277         @Override
 278         public Object getParent() {
 279             return null;
 280         }
 281
 282         @Override
 283         public Object[] getChildren() {
 284             Object[] ret = new Object[1];
 285             ret[0] = fAllContexts;
 286             return ret;
 287         }
 288
 289         @Override
 290         public boolean hasChildren() {
 291             return true;
 292         }
 293     }
 294
 295     /**
 296      * Model element (to select/deselect) all contexts) for the context tree viewer
 297      */
 298     public static class AllContexts implements IContextModelComponent {
 299         /**
 300          * The available list of contexts.
 301          */
 302         private List<Context> fAvailableContexts;
 303
 304         private final IContextModelComponent fParent;
 305
 306         /**
 307          * Constructor
 308          *
 309          * @param parent
 310          *            The parent component
 311          */
 312         public AllContexts(IContextModelComponent parent) {
 313             fParent = parent;
 314         }
 315
 316         /**
 317          * Sets the available contexts
 318          *
 319          * @param contexts
 320          *            The contexts to set
 321          */
 322         public void setAvalibleContexts(List<String> contexts) {
 323             fAvailableContexts = new ArrayList<>();
 324             if (contexts != null) {
 325                 for (Iterator<String> iterator = contexts.iterator(); iterator.hasNext();) {
 326                     String name = iterator.next();
 327                     fAvailableContexts.add(new Context(this, name));
 328                 }
 329             }
 330         }
 331
 332         @Override
 333         public String getName() {
 334             return Messages.TraceControl_AddContextAllLabel;
 335         }
 336
 337         @Override
 338         public Object[] getChildren() {
 339             return fAvailableContexts.toArray();
 340         }
 341
 342         @Override
 343         public Object getParent() {
 344             return fParent;
 345         }
 346
 347         @Override
 348         public boolean hasChildren() {
 349             return true;
 350         }
 351     }
 352
 353     /**
 354      * Model element (the context) for the context tree viewer
 355      */
 356     public static class Context implements IContextModelComponent {
 357
 358         private final String fContextName;
 359         private final IContextModelComponent fParent;
 360
 361         /**
 362          * Constructor
 363          *
 364          * @param parent
 365          *            The parent component
 366          * @param name
 367          *            The name of this context
 368          */
 369         public Context(IContextModelComponent parent, String name) {
 370             fParent = parent;
 371             fContextName = name;
 372         }
 373
 374         @Override
 375         public String getName() {
 376             return fContextName;
 377         }
 378
 379         @Override
 380         public Object getParent() {
 381             return fParent;
 382         }
 383
 384         @Override
 385         public Object[] getChildren() {
 386             return null;
 387         }
 388
 389         @Override
 390         public boolean hasChildren() {
 391             return false;
 392         }
 393     }
 394
 395     /**
 396      * Interface for the tree model used for the context tree viewer.
 397      */
 398     public interface IContextModelComponent {
 399
 400         /**
 401          * @return The name of this component
 402          */
 403         String getName();
 404
 405         /**
 406          * @return The parent component
 407          */
 408         Object getParent();
 409
 410         /**
 411          * @return The array of children of this component
 412          */
 413         Object[] getChildren();
 414
 415         /**
 416          * @return If this component has children or not
 417          */
 418         boolean hasChildren();
 419     }
 420 }