net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/ui/dialog/CheckedTreeSelectionDialog.java

   1 package net.sourceforge.phpdt.internal.ui.dialog;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.List;
   6
   7 import org.eclipse.core.runtime.IStatus;
   8 import org.eclipse.jface.dialogs.IDialogConstants;
   9 import org.eclipse.jface.viewers.CheckStateChangedEvent;
  10 import org.eclipse.jface.viewers.CheckboxTreeViewer;
  11 import org.eclipse.jface.viewers.ICheckStateListener;
  12 import org.eclipse.jface.viewers.ILabelProvider;
  13 import org.eclipse.jface.viewers.ITreeContentProvider;
  14 import org.eclipse.jface.viewers.ViewerFilter;
  15 import org.eclipse.jface.viewers.ViewerSorter;
  16 import org.eclipse.swt.SWT;
  17 import org.eclipse.swt.custom.BusyIndicator;
  18 import org.eclipse.swt.events.SelectionAdapter;
  19 import org.eclipse.swt.events.SelectionEvent;
  20 import org.eclipse.swt.events.SelectionListener;
  21 import org.eclipse.swt.layout.GridData;
  22 import org.eclipse.swt.layout.GridLayout;
  23 import org.eclipse.swt.widgets.Button;
  24 import org.eclipse.swt.widgets.Composite;
  25 import org.eclipse.swt.widgets.Control;
  26 import org.eclipse.swt.widgets.Label;
  27 import org.eclipse.swt.widgets.Shell;
  28 import org.eclipse.swt.widgets.Tree;
  29 import net.sourceforge.phpdt.internal.ui.viewsupport.ContainerCheckedTreeViewer;
  30
  31 /**
  32  * A class to select elements out of a tree structure.
  33  */
  34 public class CheckedTreeSelectionDialog extends SelectionStatusDialog {
  35
  36         private CheckboxTreeViewer fViewer;
  37
  38         private ILabelProvider fLabelProvider;
  39         private ITreeContentProvider fContentProvider;
  40
  41         private ISelectionValidator fValidator = null;
  42         private ViewerSorter fSorter;
  43         private String fEmptyListMessage = "No entries available";
  44
  45         private IStatus fCurrStatus = new StatusInfo();
  46         private List fFilters;
  47         private Object fInput;
  48         private boolean fIsEmpty;
  49
  50         private int fWidth = 60;
  51         private int fHeight = 18;
  52
  53         private boolean fContainerMode;
  54         private Object[] fExpandedElements;
  55
  56         /**
  57          * Constructs an instance of <code>ElementTreeSelectionDialog</code>.
  58          * @param labelProvider   the label provider to render the entries
  59          * @param contentProvider the content provider to evaluate the tree structure
  60          */
  61         public CheckedTreeSelectionDialog(Shell parent, ILabelProvider labelProvider, ITreeContentProvider contentProvider) {
  62                 super(parent);
  63
  64                 fLabelProvider = labelProvider;
  65                 fContentProvider = contentProvider;
  66
  67                 setResult(new ArrayList(0));
  68                 setStatusLineAboveButtons(true);
  69
  70                 fContainerMode = false;
  71                 fExpandedElements = null;
  72
  73                 int shellStyle = getShellStyle();
  74                 setShellStyle(shellStyle | SWT.MAX | SWT.RESIZE);
  75         }
  76
  77         /**
  78          * If set, the checked /gray state of containers (inner nodes) is derived from the checked state of its
  79          * leaf nodes.
  80          * @param containerMode The containerMode to set
  81          */
  82         public void setContainerMode(boolean containerMode) {
  83                 fContainerMode = containerMode;
  84         }
  85
  86         /**
  87          * Sets the initial selection.
  88          * Convenience method.
  89          * @param selection the initial selection.
  90          */
  91         public void setInitialSelection(Object selection) {
  92                 setInitialSelections(new Object[] { selection });
  93         }
  94
  95         /**
  96          * Sets the message to be displayed if the list is empty.
  97          * @param message the message to be displayed.
  98          */
  99         public void setEmptyListMessage(String message) {
 100                 fEmptyListMessage = message;
 101         }
 102
 103         /**
 104          * Sets the sorter used by the tree viewer.
 105          */
 106         public void setSorter(ViewerSorter sorter) {
 107                 fSorter = sorter;
 108         }
 109
 110         /**
 111          * Adds a filter to the tree viewer.
 112          * @param filter a filter.
 113          */
 114         public void addFilter(ViewerFilter filter) {
 115                 if (fFilters == null)
 116                         fFilters = new ArrayList(4);
 117
 118                 fFilters.add(filter);
 119         }
 120
 121         /**
 122          * Sets an optional validator to check if the selection is valid.
 123          * The validator is invoked whenever the selection changes.
 124          * @param validator the validator to validate the selection.
 125          */
 126         public void setValidator(ISelectionValidator validator) {
 127                 fValidator = validator;
 128         }
 129
 130         /**
 131          * Sets the tree input.
 132          * @param input the tree input.
 133          */
 134         public void setInput(Object input) {
 135                 fInput = input;
 136         }
 137
 138         /**
 139          * Expands the tree
 140          */
 141         public void setExpandedElements(Object[] elements) {
 142                 fExpandedElements = elements;
 143         }
 144
 145         /**
 146          * Sets the size of the tree in unit of characters.
 147          * @param width  the width of the tree.
 148          * @param height the height of the tree.
 149          */
 150         public void setSize(int width, int height) {
 151                 fWidth = width;
 152                 fHeight = height;
 153         }
 154
 155         protected void updateOKStatus() {
 156                 if (!fIsEmpty) {
 157                         if (fValidator != null) {
 158                                 fCurrStatus = fValidator.validate(fViewer.getCheckedElements());
 159                                 updateStatus(fCurrStatus);
 160                         } else if (!fCurrStatus.isOK()) {
 161                                 fCurrStatus = new StatusInfo();
 162                         }
 163                 } else {
 164                         fCurrStatus = new StatusInfo(IStatus.ERROR, fEmptyListMessage);
 165                 }
 166                 updateStatus(fCurrStatus);
 167         }
 168
 169         /*
 170          * @see Window#open()
 171          */
 172         public int open() {
 173                 fIsEmpty = evaluateIfTreeEmpty(fInput);
 174                 BusyIndicator.showWhile(null, new Runnable() {
 175                         public void run() {
 176                                 access$superOpen();
 177                         }
 178                 });
 179
 180                 return getReturnCode();
 181         }
 182
 183         private void access$superOpen() {
 184                 super.open();
 185         }
 186
 187         /**
 188          * Handles cancel button pressed event.
 189          */
 190         protected void cancelPressed() {
 191                 setResult(null);
 192                 super.cancelPressed();
 193         }
 194
 195         /*
 196          * @see SelectionStatusDialog#computeResult()
 197          */
 198         protected void computeResult() {
 199                 setResult(Arrays.asList(fViewer.getCheckedElements()));
 200         }
 201
 202         /*
 203          * @see Window#create()
 204          */
 205         public void create() {
 206                 super.create();
 207
 208                 List initialSelections = getInitialSelections();
 209                 if (initialSelections != null) {
 210                         fViewer.setCheckedElements(initialSelections.toArray());
 211                 }
 212
 213                 if (fExpandedElements != null) {
 214                         fViewer.setExpandedElements(fExpandedElements);
 215                 }
 216
 217                 updateOKStatus();
 218         }
 219
 220         /*
 221          * @see Dialog#createDialogArea(Composite)
 222          */
 223         protected Control createDialogArea(Composite parent) {
 224                 Composite composite = (Composite) super.createDialogArea(parent);
 225
 226                 Label messageLabel = createMessageArea(composite);
 227                 Control treeWidget = createTreeViewer(composite);
 228                 Control buttonComposite = createSelectionButtons(composite);
 229
 230                 GridData data = new GridData(GridData.FILL_BOTH);
 231                 data.widthHint = convertWidthInCharsToPixels(fWidth);
 232                 data.heightHint = convertHeightInCharsToPixels(fHeight);
 233                 treeWidget.setLayoutData(data);
 234
 235                 if (fIsEmpty) {
 236                         messageLabel.setEnabled(false);
 237                         treeWidget.setEnabled(false);
 238                         buttonComposite.setEnabled(false);
 239                 }
 240
 241                 return composite;
 242         }
 243
 244         private Tree createTreeViewer(Composite parent) {
 245                 if (fContainerMode) {
 246                         fViewer = new ContainerCheckedTreeViewer(parent, SWT.BORDER);
 247                 } else {
 248                         fViewer = new CheckboxTreeViewer(parent, SWT.BORDER);
 249                 }
 250
 251                 fViewer.setContentProvider(fContentProvider);
 252                 fViewer.setLabelProvider(fLabelProvider);
 253                 fViewer.addCheckStateListener(new ICheckStateListener() {
 254                         public void checkStateChanged(CheckStateChangedEvent event) {
 255                                 updateOKStatus();
 256                         }
 257                 });
 258
 259                 fViewer.setSorter(fSorter);
 260                 if (fFilters != null) {
 261                         for (int i = 0; i != fFilters.size(); i++)
 262                                 fViewer.addFilter((ViewerFilter) fFilters.get(i));
 263                 }
 264
 265                 fViewer.setInput(fInput);
 266
 267                 return fViewer.getTree();
 268         }
 269
 270         /**
 271          * Add the selection and deselection buttons to the dialog.
 272          * @param composite org.eclipse.swt.widgets.Composite
 273          */
 274         private Composite createSelectionButtons(Composite composite) {
 275
 276                 Composite buttonComposite = new Composite(composite, SWT.RIGHT);
 277                 GridLayout layout = new GridLayout();
 278                 layout.numColumns = 2;
 279                 buttonComposite.setLayout(layout);
 280                 GridData data = new GridData(GridData.HORIZONTAL_ALIGN_END | GridData.GRAB_HORIZONTAL);
 281                 data.grabExcessHorizontalSpace = true;
 282                 composite.setData(data);
 283
 284                 Button selectButton = createButton(buttonComposite, IDialogConstants.SELECT_ALL_ID, "Select &All", false);
 285
 286                 SelectionListener listener = new SelectionAdapter() {
 287                         public void widgetSelected(SelectionEvent e) {
 288                                 fViewer.setCheckedElements(fContentProvider.getElements(fInput));
 289                                 updateOKStatus();
 290                         }
 291                 };
 292                 selectButton.addSelectionListener(listener);
 293
 294                 Button deselectButton = createButton(buttonComposite, IDialogConstants.DESELECT_ALL_ID, "&Deselect All", false);
 295
 296                 listener = new SelectionAdapter() {
 297                         public void widgetSelected(SelectionEvent e) {
 298                                 fViewer.setCheckedElements(new Object[0]);
 299                                 updateOKStatus();
 300                         }
 301                 };
 302                 deselectButton.addSelectionListener(listener);
 303                 return buttonComposite;
 304         }
 305
 306         private boolean evaluateIfTreeEmpty(Object input) {
 307                 Object[] elements = fContentProvider.getElements(input);
 308                 if (elements.length > 0) {
 309                         if (fFilters != null) {
 310                                 for (int i = 0; i < fFilters.size(); i++) {
 311                                         ViewerFilter curr = (ViewerFilter) fFilters.get(i);
 312                                         elements = curr.filter(fViewer, input, elements);
 313                                 }
 314                         }
 315                 }
 316                 return elements.length == 0;
 317         }
 318
 319 }