net.sourceforge.phpeclipse.externaltools/src/net/sourceforge/phpdt/externaltools/internal/ui/TreeAndListGroup.java

   1 package net.sourceforge.phpdt.externaltools.internal.ui;
   2
   3 /**********************************************************************
   4 Copyright (c) 2002 IBM Corp. and others. All rights reserved.
   5 This file is made available under the terms of the Common Public License v1.0
   6 which accompanies this distribution, and is available at
   7 http://www.eclipse.org/legal/cpl-v10.html
   8 **********************************************************************/
   9
  10 import java.util.Collection;
  11 import java.util.HashSet;
  12 import java.util.Iterator;
  13
  14 import org.eclipse.jface.viewers.ILabelProvider;
  15 import org.eclipse.jface.viewers.ISelection;
  16 import org.eclipse.jface.viewers.ISelectionChangedListener;
  17 import org.eclipse.jface.viewers.IStructuredContentProvider;
  18 import org.eclipse.jface.viewers.IStructuredSelection;
  19 import org.eclipse.jface.viewers.ITreeContentProvider;
  20 import org.eclipse.jface.viewers.SelectionChangedEvent;
  21 import org.eclipse.jface.viewers.StructuredSelection;
  22 import org.eclipse.jface.viewers.TableViewer;
  23 import org.eclipse.jface.viewers.TreeViewer;
  24 import org.eclipse.jface.viewers.ViewerSorter;
  25 import org.eclipse.swt.SWT;
  26 import org.eclipse.swt.layout.GridData;
  27 import org.eclipse.swt.layout.GridLayout;
  28 import org.eclipse.swt.widgets.Composite;
  29 import org.eclipse.swt.widgets.Table;
  30 import org.eclipse.swt.widgets.Tree;
  31
  32 /**
  33  * This class was derived from org.eclipse.ui.internal.misc.CheckboxTreeAndListGroup
  34  *
  35  */
  36 public class TreeAndListGroup implements ISelectionChangedListener {
  37         private Object root;
  38         private Object currentTreeSelection;
  39         private Collection listeners = new HashSet();
  40
  41         private ITreeContentProvider treeContentProvider;
  42         private IStructuredContentProvider listContentProvider;
  43         private ILabelProvider treeLabelProvider;
  44         private ILabelProvider listLabelProvider;
  45
  46         // widgets
  47         private TreeViewer treeViewer;
  48         private TableViewer listViewer;
  49         private boolean allowMultiselection= false;
  50
  51         /**
  52          *      Create an instance of this class.  Use this constructor if you wish to specify
  53          *      the width and/or height of the combined widget (to only hardcode one of the
  54          *      sizing dimensions, specify the other dimension's value as -1)
  55          *
  56          *      @param parent org.eclipse.swt.widgets.Composite
  57          *      @param style int
  58          *  @param rootObject java.lang.Object
  59          *      @param childPropertyName java.lang.String
  60          *      @param parentPropertyName java.lang.String
  61          *      @param listPropertyName java.lang.String
  62          *      @param width int
  63          *      @param height int
  64          */
  65         public TreeAndListGroup(Composite parent, Object rootObject, ITreeContentProvider treeContentProvider, ILabelProvider treeLabelProvider, IStructuredContentProvider listContentProvider, ILabelProvider listLabelProvider, int style, int width, int height) {
  66
  67                 root = rootObject;
  68                 this.treeContentProvider = treeContentProvider;
  69                 this.listContentProvider = listContentProvider;
  70                 this.treeLabelProvider = treeLabelProvider;
  71                 this.listLabelProvider = listLabelProvider;
  72                 createContents(parent, width, height, style);
  73         }
  74         /**
  75          * This method must be called just before this window becomes visible.
  76          */
  77         public void aboutToOpen() {
  78                 currentTreeSelection = null;
  79
  80                 //select the first element in the list
  81                 Object[] elements = treeContentProvider.getElements(root);
  82                 Object primary = elements.length > 0 ? elements[0] : null;
  83                 if (primary != null) {
  84                         treeViewer.setSelection(new StructuredSelection(primary));
  85                 }
  86                 treeViewer.getControl().setFocus();
  87         }
  88         /**
  89          *      Add the passed listener to collection of clients
  90          *      that listen for changes to list viewer selection state
  91          *
  92          *      @param listener ISelectionChangedListener
  93          */
  94         public void addSelectionChangedListener(ISelectionChangedListener listener) {
  95                 listeners.add(listener);
  96         }
  97
  98         /**
  99          *      Notify                          all checked state listeners that the passed element
 100          *has had its checked state changed to the passed state
 101                  */
 102         protected void notifySelectionListeners(SelectionChangedEvent event) {
 103                 Iterator listenersEnum = listeners.iterator();
 104                 while (listenersEnum.hasNext()) {
 105                          ((ISelectionChangedListener) listenersEnum.next()).selectionChanged(event);
 106                 }
 107         }
 108
 109         /**
 110          *      Lay out and initialize self's visual components.
 111          *
 112          *      @param parent org.eclipse.swt.widgets.Composite
 113          *      @param width int
 114          *      @param height int
 115          */
 116         protected void createContents(Composite parent, int width, int height, int style) {
 117                 // group pane
 118                 Composite composite = new Composite(parent, style);
 119                 composite.setFont(parent.getFont());
 120                 GridLayout layout = new GridLayout();
 121                 layout.numColumns = 2;
 122                 layout.makeColumnsEqualWidth = true;
 123                 layout.marginHeight = 0;
 124                 layout.marginWidth = 0;
 125                 composite.setLayout(layout);
 126                 composite.setLayoutData(new GridData(GridData.FILL_BOTH));
 127
 128                 createTreeViewer(composite, width / 2, height);
 129                 createListViewer(composite, width / 2, height);
 130
 131                 initialize();
 132         }
 133         /**
 134          *      Create this group's list viewer.
 135          */
 136         protected void createListViewer(Composite parent, int width, int height) {
 137                 int style;
 138                 if (allowMultiselection) {
 139                         style= SWT.MULTI;
 140                 } else {
 141                         style= SWT.SINGLE;
 142                 }
 143                 listViewer = new TableViewer(parent, SWT.BORDER | style);
 144                 GridData data = new GridData(GridData.FILL_BOTH);
 145                 data.widthHint = width;
 146                 data.heightHint = height;
 147                 listViewer.getTable().setLayoutData(data);
 148                 listViewer.getTable().setFont(parent.getFont());
 149                 listViewer.setContentProvider(listContentProvider);
 150                 listViewer.setLabelProvider(listLabelProvider);
 151                 listViewer.addSelectionChangedListener(new ISelectionChangedListener() {
 152                         public void selectionChanged(SelectionChangedEvent event) {
 153                                 notifySelectionListeners(event);
 154                         }
 155                 });
 156         }
 157         /**
 158          *      Create this group's tree viewer.
 159          */
 160         protected void createTreeViewer(Composite parent, int width, int height) {
 161                 Tree tree = new Tree(parent, SWT.BORDER);
 162                 GridData data = new GridData(GridData.FILL_BOTH);
 163                 data.widthHint = width;
 164                 data.heightHint = height;
 165                 tree.setLayoutData(data);
 166                 tree.setFont(parent.getFont());
 167
 168                 treeViewer = new TreeViewer(tree);
 169                 treeViewer.setContentProvider(treeContentProvider);
 170                 treeViewer.setLabelProvider(treeLabelProvider);
 171                 treeViewer.addSelectionChangedListener(this);
 172         }
 173
 174         public Table getListTable() {
 175                 return listViewer.getTable();
 176         }
 177
 178         public IStructuredSelection getListTableSelection() {
 179                 ISelection selection=  this.listViewer.getSelection();
 180                 if (selection instanceof IStructuredSelection) {
 181                         return (IStructuredSelection)selection;
 182                 } else {
 183                         return StructuredSelection.EMPTY;
 184                 }
 185         }
 186
 187         protected void initialListItem(Object element) {
 188                 Object parent = treeContentProvider.getParent(element);
 189                 selectAndRevealFolder(parent);
 190         }
 191
 192         public void selectAndRevealFolder(Object treeElement) {
 193                 treeViewer.reveal(treeElement);
 194                 IStructuredSelection selection = new StructuredSelection(treeElement);
 195                 treeViewer.setSelection(selection);
 196         }
 197
 198         public void selectAndRevealFile(Object treeElement) {
 199                 listViewer.reveal(treeElement);
 200                 IStructuredSelection selection = new StructuredSelection(treeElement);
 201                 listViewer.setSelection(selection);
 202         }
 203
 204         /**
 205          *      Initialize this group's viewers after they have been laid out.
 206          */
 207         protected void initialize() {
 208                 treeViewer.setInput(root);
 209         }
 210
 211         /**
 212          *      Handle the selection of an item in the tree viewer
 213          *
 214          *      @param selection ISelection
 215          */
 216         public void selectionChanged(SelectionChangedEvent event) {
 217                 IStructuredSelection selection = (IStructuredSelection) event.getSelection();
 218                 Object selectedElement = selection.getFirstElement();
 219                 if (selectedElement == null) {
 220                         currentTreeSelection = null;
 221                         listViewer.setInput(currentTreeSelection);
 222                         return;
 223                 }
 224
 225                 // ie.- if not an item deselection
 226                 if (selectedElement != currentTreeSelection) {
 227                         listViewer.setInput(selectedElement);
 228                 }
 229
 230                 currentTreeSelection = selectedElement;
 231         }
 232         /**
 233          *      Set the list viewer's providers to those passed
 234          *
 235          *      @param contentProvider ITreeContentProvider
 236          *      @param labelProvider ILabelProvider
 237          */
 238         public void setListProviders(IStructuredContentProvider contentProvider, ILabelProvider labelProvider) {
 239                 listViewer.setContentProvider(contentProvider);
 240                 listViewer.setLabelProvider(labelProvider);
 241         }
 242         /**
 243          *      Set the sorter that is to be applied to self's list viewer
 244          */
 245         public void setListSorter(ViewerSorter sorter) {
 246                 listViewer.setSorter(sorter);
 247         }
 248         /**
 249          * Set the root of the widget to be new Root. Regenerate all of the tables and lists from this
 250          * value.
 251          * @param newRoot
 252          */
 253         public void setRoot(Object newRoot) {
 254                 this.root = newRoot;
 255                 initialize();
 256         }
 257
 258         /**
 259          *      Set the tree viewer's providers to those passed
 260          *
 261          *      @param contentProvider ITreeContentProvider
 262          *      @param labelProvider ILabelProvider
 263          */
 264         public void setTreeProviders(ITreeContentProvider contentProvider, ILabelProvider labelProvider) {
 265                 treeViewer.setContentProvider(contentProvider);
 266                 treeViewer.setLabelProvider(labelProvider);
 267         }
 268         /**
 269          *      Set the sorter that is to be applied to self's tree viewer
 270          */
 271         public void setTreeSorter(ViewerSorter sorter) {
 272                 treeViewer.setSorter(sorter);
 273         }
 274
 275         /**
 276          * Set the focus on to the list widget.
 277          */
 278         public void setFocus() {
 279
 280                 this.treeViewer.getTree().setFocus();
 281         }
 282
 283         public void setAllowMultiselection(boolean allowMultiselection) {
 284                 this.allowMultiselection= allowMultiselection;
 285
 286         }
 287 }