net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/phpeditor/JavaOutlinePage.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpeclipse.phpeditor;
  12
  13 import java.util.Enumeration;
  14 import java.util.Hashtable;
  15 import java.util.List;
  16 import java.util.Vector;
  17
  18 import net.sourceforge.phpdt.core.ElementChangedEvent;
  19 import net.sourceforge.phpdt.core.ICompilationUnit;
  20 import net.sourceforge.phpdt.core.IElementChangedListener;
  21 import net.sourceforge.phpdt.core.IJavaElement;
  22 import net.sourceforge.phpdt.core.IJavaElementDelta;
  23 import net.sourceforge.phpdt.core.IMember;
  24 import net.sourceforge.phpdt.core.IParent;
  25 import net.sourceforge.phpdt.core.ISourceRange;
  26 import net.sourceforge.phpdt.core.ISourceReference;
  27 import net.sourceforge.phpdt.core.IType;
  28 import net.sourceforge.phpdt.core.JavaCore;
  29 import net.sourceforge.phpdt.core.JavaModelException;
  30 import net.sourceforge.phpdt.internal.ui.PHPUiImages;
  31 import net.sourceforge.phpdt.internal.ui.actions.AbstractToggleLinkingAction;
  32 import net.sourceforge.phpdt.internal.ui.actions.CompositeActionGroup;
  33 import net.sourceforge.phpdt.internal.ui.dnd.JdtViewerDragAdapter;
  34 import net.sourceforge.phpdt.internal.ui.dnd.TransferDragSourceListener;
  35 import net.sourceforge.phpdt.internal.ui.packageview.SelectionTransferDragAdapter;
  36 import net.sourceforge.phpdt.internal.ui.viewsupport.AppearanceAwareLabelProvider;
  37 import net.sourceforge.phpdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
  38 import net.sourceforge.phpdt.internal.ui.viewsupport.JavaElementLabels;
  39 import net.sourceforge.phpdt.internal.ui.viewsupport.StatusBarUpdater;
  40 import net.sourceforge.phpdt.ui.JavaElementSorter;
  41 import net.sourceforge.phpdt.ui.JavaUI;
  42 import net.sourceforge.phpdt.ui.PreferenceConstants;
  43 import net.sourceforge.phpdt.ui.ProblemsLabelDecorator.ProblemsLabelChangedEvent;
  44 import net.sourceforge.phpdt.ui.actions.GenerateActionGroup;
  45 import net.sourceforge.phpdt.ui.actions.MemberFilterActionGroup;
  46 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  47
  48 import org.eclipse.core.resources.IResource;
  49 import org.eclipse.core.runtime.IAdaptable;
  50 import org.eclipse.jface.action.Action;
  51 import org.eclipse.jface.action.IAction;
  52 import org.eclipse.jface.action.IMenuListener;
  53 import org.eclipse.jface.action.IMenuManager;
  54 import org.eclipse.jface.action.IStatusLineManager;
  55 import org.eclipse.jface.action.IToolBarManager;
  56 import org.eclipse.jface.action.MenuManager;
  57 import org.eclipse.jface.action.Separator;
  58 import org.eclipse.jface.preference.IPreferenceStore;
  59 import org.eclipse.jface.text.Assert;
  60 import org.eclipse.jface.text.ITextSelection;
  61 import org.eclipse.jface.util.IPropertyChangeListener;
  62 import org.eclipse.jface.util.ListenerList;
  63 import org.eclipse.jface.util.PropertyChangeEvent;
  64 import org.eclipse.jface.viewers.IBaseLabelProvider;
  65 import org.eclipse.jface.viewers.IPostSelectionProvider;
  66 import org.eclipse.jface.viewers.ISelection;
  67 import org.eclipse.jface.viewers.ISelectionChangedListener;
  68 import org.eclipse.jface.viewers.IStructuredSelection;
  69 import org.eclipse.jface.viewers.ITreeContentProvider;
  70 import org.eclipse.jface.viewers.LabelProviderChangedEvent;
  71 import org.eclipse.jface.viewers.SelectionChangedEvent;
  72 import org.eclipse.jface.viewers.StructuredSelection;
  73 import org.eclipse.jface.viewers.TreeViewer;
  74 import org.eclipse.jface.viewers.Viewer;
  75 import org.eclipse.jface.viewers.ViewerFilter;
  76 import org.eclipse.swt.SWT;
  77 import org.eclipse.swt.custom.BusyIndicator;
  78 import org.eclipse.swt.dnd.DND;
  79 import org.eclipse.swt.dnd.Transfer;
  80 import org.eclipse.swt.events.KeyEvent;
  81 import org.eclipse.swt.widgets.Composite;
  82 import org.eclipse.swt.widgets.Control;
  83 import org.eclipse.swt.widgets.Display;
  84 import org.eclipse.swt.widgets.Item;
  85 import org.eclipse.swt.widgets.Menu;
  86 import org.eclipse.swt.widgets.Tree;
  87 import org.eclipse.swt.widgets.Widget;
  88 import org.eclipse.ui.IActionBars;
  89 import org.eclipse.ui.actions.ActionContext;
  90 import org.eclipse.ui.actions.ActionGroup;
  91 import org.eclipse.ui.model.IWorkbenchAdapter;
  92 import org.eclipse.ui.model.WorkbenchAdapter;
  93 import org.eclipse.ui.part.IPageSite;
  94 import org.eclipse.ui.part.IShowInSource;
  95 import org.eclipse.ui.part.IShowInTarget;
  96 import org.eclipse.ui.part.IShowInTargetList;
  97 import org.eclipse.ui.part.Page;
  98 import org.eclipse.ui.part.ShowInContext;
  99 import org.eclipse.ui.texteditor.ITextEditorActionConstants;
 100 import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
 101 import org.eclipse.ui.texteditor.IUpdate;
 102 import org.eclipse.ui.texteditor.TextEditorAction;
 103 import org.eclipse.ui.texteditor.TextOperationAction;
 104 import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
 105 import org.eclipse.ui.views.navigator.LocalSelectionTransfer;
 106
 107 /**
 108  * The content outline page of the Java editor. The viewer implements a proprietary update mechanism based on Java model deltas. It
 109  * does not react on domain changes. It is specified to show the content of ICompilationUnits and IClassFiles. Pulishes its context
 110  * menu under <code>JavaPlugin.getDefault().getPluginId() + ".outline"</code>.
 111  */
 112 public class JavaOutlinePage extends Page implements IContentOutlinePage, IAdaptable, IPostSelectionProvider {
 113
 114   static Object[] NO_CHILDREN = new Object[0];
 115
 116   /**
 117    * The element change listener of the java outline viewer.
 118    *
 119    * @see IElementChangedListener
 120    */
 121   class ElementChangedListener implements IElementChangedListener {
 122
 123     public void elementChanged(final ElementChangedEvent e) {
 124
 125       if (getControl() == null)
 126         return;
 127
 128       Display d = getControl().getDisplay();
 129       if (d != null) {
 130         d.asyncExec(new Runnable() {
 131           public void run() {
 132             ICompilationUnit cu = (ICompilationUnit) fInput;
 133             IJavaElement base = cu;
 134             if (fTopLevelTypeOnly) {
 135               base = getMainType(cu);
 136               if (base == null) {
 137                 if (fOutlineViewer != null)
 138                   fOutlineViewer.refresh(true);
 139                 return;
 140               }
 141             }
 142             IJavaElementDelta delta = findElement(base, e.getDelta());
 143             if (delta != null && fOutlineViewer != null) {
 144               fOutlineViewer.reconcile(delta);
 145             }
 146           }
 147         });
 148       }
 149     }
 150
 151     protected IJavaElementDelta findElement(IJavaElement unit, IJavaElementDelta delta) {
 152
 153       if (delta == null || unit == null)
 154         return null;
 155
 156       IJavaElement element = delta.getElement();
 157
 158       if (unit.equals(element))
 159         return delta;
 160
 161       if (element.getElementType() > IJavaElement.CLASS_FILE)
 162         return null;
 163
 164       IJavaElementDelta[] children = delta.getAffectedChildren();
 165       if (children == null || children.length == 0)
 166         return null;
 167
 168       for (int i = 0; i < children.length; i++) {
 169         IJavaElementDelta d = findElement(unit, children[i]);
 170         if (d != null)
 171           return d;
 172       }
 173
 174       return null;
 175     }
 176   };
 177
 178   static class NoClassElement extends WorkbenchAdapter implements IAdaptable {
 179     /*
 180      * @see java.lang.Object#toString()
 181      */
 182     public String toString() {
 183       return PHPEditorMessages.getString("JavaOutlinePage.error.NoTopLevelType"); //$NON-NLS-1$
 184     }
 185
 186     /*
 187      * @see org.eclipse.core.runtime.IAdaptable#getAdapter(Class)
 188      */
 189     public Object getAdapter(Class clas) {
 190       if (clas == IWorkbenchAdapter.class)
 191         return this;
 192       return null;
 193     }
 194   }
 195
 196   /**
 197    * Content provider for the children of an ICompilationUnit or an IClassFile
 198    *
 199    * @see ITreeContentProvider
 200    */
 201   class ChildrenProvider implements ITreeContentProvider {
 202
 203     private Object[] NO_CLASS = new Object[] { new NoClassElement() };
 204
 205     private ElementChangedListener fListener;
 206
 207     protected boolean matches(IJavaElement element) {
 208       if (element.getElementType() == IJavaElement.METHOD) {
 209         String name = element.getElementName();
 210         return (name != null && name.indexOf('<') >= 0);
 211       }
 212       return false;
 213     }
 214
 215     protected IJavaElement[] filter(IJavaElement[] children) {
 216       boolean initializers = false;
 217       for (int i = 0; i < children.length; i++) {
 218         if (matches(children[i])) {
 219           initializers = true;
 220           break;
 221         }
 222       }
 223
 224       if (!initializers)
 225         return children;
 226
 227       Vector v = new Vector();
 228       for (int i = 0; i < children.length; i++) {
 229         if (matches(children[i]))
 230           continue;
 231         v.addElement(children[i]);
 232       }
 233
 234       IJavaElement[] result = new IJavaElement[v.size()];
 235       v.copyInto(result);
 236       return result;
 237     }
 238
 239     public Object[] getChildren(Object parent) {
 240       if (parent instanceof IParent) {
 241         IParent c = (IParent) parent;
 242         try {
 243           return filter(c.getChildren());
 244         } catch (JavaModelException x) {
 245           PHPeclipsePlugin.log(x);
 246         }
 247       }
 248       return NO_CHILDREN;
 249     }
 250
 251     public Object[] getElements(Object parent) {
 252       if (fTopLevelTypeOnly) {
 253         if (parent instanceof ICompilationUnit) {
 254           try {
 255             IType type = getMainType((ICompilationUnit) parent);
 256             return type != null ? type.getChildren() : NO_CLASS;
 257           } catch (JavaModelException e) {
 258             PHPeclipsePlugin.log(e);
 259           }
 260         }
 261         //                                              else if (parent instanceof IClassFile) {
 262         //                                                      try {
 263         //                                                              IType type= getMainType((IClassFile) parent);
 264         //                                                              return type != null ? type.getChildren() : NO_CLASS;
 265         //                                                      } catch (JavaModelException e) {
 266         //                                                              JavaPlugin.log(e);
 267         //                                                      }
 268         //                                              }
 269       }
 270       return getChildren(parent);
 271     }
 272
 273     public Object getParent(Object child) {
 274       if (child instanceof IJavaElement) {
 275         IJavaElement e = (IJavaElement) child;
 276         return e.getParent();
 277       }
 278       return null;
 279     }
 280
 281     public boolean hasChildren(Object parent) {
 282       if (parent instanceof IParent) {
 283         IParent c = (IParent) parent;
 284         try {
 285           IJavaElement[] children = filter(c.getChildren());
 286           return (children != null && children.length > 0);
 287         } catch (JavaModelException x) {
 288           PHPeclipsePlugin.log(x);
 289         }
 290       }
 291       return false;
 292     }
 293
 294     public boolean isDeleted(Object o) {
 295       return false;
 296     }
 297
 298     public void dispose() {
 299       if (fListener != null) {
 300         JavaCore.removeElementChangedListener(fListener);
 301         fListener = null;
 302       }
 303     }
 304
 305     /*
 306      * @see IContentProvider#inputChanged(Viewer, Object, Object)
 307      */
 308     public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 309       boolean isCU = (newInput instanceof ICompilationUnit);
 310
 311       if (isCU && fListener == null) {
 312         fListener = new ElementChangedListener();
 313         JavaCore.addElementChangedListener(fListener);
 314       } else if (!isCU && fListener != null) {
 315         JavaCore.removeElementChangedListener(fListener);
 316         fListener = null;
 317       }
 318     }
 319   };
 320
 321   class JavaOutlineViewer extends TreeViewer {
 322
 323     /**
 324      * Indicates an item which has been reused. At the point of its reuse it has been expanded. This field is used to communicate
 325      * between <code>internalExpandToLevel</code> and <code>reuseTreeItem</code>.
 326      */
 327     private Item fReusedExpandedItem;
 328
 329     private boolean fReorderedMembers;
 330     private boolean fForceFireSelectionChanged;
 331
 332     public JavaOutlineViewer(Tree tree) {
 333       super(tree);
 334       setAutoExpandLevel(ALL_LEVELS);
 335     }
 336
 337     /**
 338          * Investigates the given element change event and if affected
 339          * incrementally updates the Java outline.
 340          *
 341          * @param delta the Java element delta used to reconcile the Java outline
 342          */
 343         public void reconcile(IJavaElementDelta delta) {
 344                 fReorderedMembers= false;
 345                 fForceFireSelectionChanged= false;
 346                 if (getSorter() == null) {
 347                         if (fTopLevelTypeOnly
 348                                 && delta.getElement() instanceof IType
 349                                 && (delta.getKind() & IJavaElementDelta.ADDED) != 0)
 350                         {
 351                                 refresh(true);
 352
 353                         } else {
 354                                 Widget w= findItem(fInput);
 355                                 if (w != null && !w.isDisposed())
 356                                         update(w, delta);
 357                                 if (fForceFireSelectionChanged)
 358                                         fireSelectionChanged(new SelectionChangedEvent(getSite().getSelectionProvider(), this.getSelection()));
 359                                 if (fReorderedMembers) {
 360                                         refresh(false);
 361                                         fReorderedMembers= false;
 362                         }
 363                         }
 364                 } else {
 365                         // just for now
 366                         refresh(true);
 367                 }
 368         }
 369 //    public void reconcile(IJavaElementDelta delta) {
 370 //      fReorderedMembers = false;
 371 //      if (getSorter() == null) {
 372 //        if (fTopLevelTypeOnly && delta.getElement() instanceof IType && (delta.getKind() & IJavaElementDelta.ADDED) != 0) {
 373 //          refresh(true);
 374 //
 375 //        } else {
 376 //          Widget w = findItem(fInput);
 377 //          if (w != null && !w.isDisposed())
 378 //            update(w, delta);
 379 //          if (fReorderedMembers) {
 380 //            refresh(false);
 381 //            fReorderedMembers = false;
 382 //          }
 383 //        }
 384 //      } else {
 385 //        // just for now
 386 //        refresh(true);
 387 //      }
 388 //    }
 389
 390     /*
 391      * @see TreeViewer#internalExpandToLevel
 392      */
 393     protected void internalExpandToLevel(Widget node, int level) {
 394       if (node instanceof Item) {
 395         Item i = (Item) node;
 396         if (i.getData() instanceof IJavaElement) {
 397           IJavaElement je = (IJavaElement) i.getData();
 398           if (je.getElementType() == IJavaElement.IMPORT_CONTAINER || isInnerType(je)) {
 399             if (i != fReusedExpandedItem) {
 400               setExpanded(i, false);
 401               return;
 402             }
 403           }
 404         }
 405       }
 406       super.internalExpandToLevel(node, level);
 407     }
 408
 409     protected void reuseTreeItem(Item item, Object element) {
 410
 411       // remove children
 412       Item[] c = getChildren(item);
 413       if (c != null && c.length > 0) {
 414
 415         if (getExpanded(item))
 416           fReusedExpandedItem = item;
 417
 418         for (int k = 0; k < c.length; k++) {
 419           if (c[k].getData() != null)
 420             disassociate(c[k]);
 421           c[k].dispose();
 422         }
 423       }
 424
 425       updateItem(item, element);
 426       updatePlus(item, element);
 427       internalExpandToLevel(item, ALL_LEVELS);
 428
 429       fReusedExpandedItem = null;
 430       fForceFireSelectionChanged= true;
 431     }
 432
 433     protected boolean mustUpdateParent(IJavaElementDelta delta, IJavaElement element) {
 434 //      if (element instanceof IMethod) {
 435 //        if ((delta.getKind() & IJavaElementDelta.ADDED) != 0) {
 436 //          try {
 437 //            return ((IMethod) element).isMainMethod();
 438 //          } catch (JavaModelException e) {
 439 //            PHPeclipsePlugin.log(e.getStatus());
 440 //          }
 441 //        }
 442 //        return "main".equals(element.getElementName()); //$NON-NLS-1$
 443 //      }
 444       return false;
 445     }
 446     /*
 447          * @see org.eclipse.jface.viewers.AbstractTreeViewer#isExpandable(java.lang.Object)
 448          */
 449         public boolean isExpandable(Object element) {
 450                 if (hasFilters()) {
 451                         return getFilteredChildren(element).length > 0;
 452                 }
 453                 return super.isExpandable(element);
 454         }
 455     protected ISourceRange getSourceRange(IJavaElement element) throws JavaModelException {
 456       if (element instanceof IMember)// && !(element instanceof IInitializer))
 457         return ((IMember) element).getNameRange();
 458       if (element instanceof ISourceReference)
 459         return ((ISourceReference) element).getSourceRange();
 460       return null;
 461     }
 462
 463     protected boolean overlaps(ISourceRange range, int start, int end) {
 464       return start <= (range.getOffset() + range.getLength() - 1) && range.getOffset() <= end;
 465     }
 466
 467     protected boolean filtered(IJavaElement parent, IJavaElement child) {
 468
 469       Object[] result = new Object[] { child };
 470       ViewerFilter[] filters = getFilters();
 471       for (int i = 0; i < filters.length; i++) {
 472         result = filters[i].filter(this, parent, result);
 473         if (result.length == 0)
 474           return true;
 475       }
 476
 477       return false;
 478     }
 479
 480     protected void update(Widget w, IJavaElementDelta delta) {
 481
 482       Item item;
 483
 484       IJavaElement parent = delta.getElement();
 485       IJavaElementDelta[] affected = delta.getAffectedChildren();
 486       Item[] children = getChildren(w);
 487
 488       boolean doUpdateParent = false;
 489       boolean doUpdateParentsPlus = false;
 490
 491       Vector deletions = new Vector();
 492       Vector additions = new Vector();
 493
 494       for (int i = 0; i < affected.length; i++) {
 495         IJavaElementDelta affectedDelta = affected[i];
 496         IJavaElement affectedElement = affectedDelta.getElement();
 497         int status = affected[i].getKind();
 498
 499         // find tree item with affected element
 500         int j;
 501         for (j = 0; j < children.length; j++)
 502           if (affectedElement.equals(children[j].getData()))
 503             break;
 504
 505         if (j == children.length) {
 506           //        remove from collapsed parent
 507           if ((status & IJavaElementDelta.REMOVED) != 0) {
 508             doUpdateParentsPlus = true;
 509             continue;
 510           }
 511           // addition
 512           if ((status & IJavaElementDelta.CHANGED) != 0 && (affectedDelta.getFlags() & IJavaElementDelta.F_MODIFIERS) != 0
 513               && !filtered(parent, affectedElement)) {
 514             additions.addElement(affectedDelta);
 515           }
 516           continue;
 517         }
 518
 519         item = children[j];
 520
 521         // removed
 522         if ((status & IJavaElementDelta.REMOVED) != 0) {
 523           deletions.addElement(item);
 524           doUpdateParent = doUpdateParent || mustUpdateParent(affectedDelta, affectedElement);
 525
 526           // changed
 527         } else if ((status & IJavaElementDelta.CHANGED) != 0) {
 528           int change = affectedDelta.getFlags();
 529           doUpdateParent = doUpdateParent || mustUpdateParent(affectedDelta, affectedElement);
 530
 531           if ((change & IJavaElementDelta.F_MODIFIERS) != 0) {
 532             if (filtered(parent, affectedElement))
 533               deletions.addElement(item);
 534             else
 535               updateItem(item, affectedElement);
 536           }
 537
 538           if ((change & IJavaElementDelta.F_CONTENT) != 0)
 539             updateItem(item, affectedElement);
 540
 541           if ((change & IJavaElementDelta.F_CHILDREN) != 0)
 542             update(item, affectedDelta);
 543
 544           if ((change & IJavaElementDelta.F_REORDER) != 0)
 545             fReorderedMembers = true;
 546         }
 547       }
 548
 549       // find all elements to add
 550       IJavaElementDelta[] add = delta.getAddedChildren();
 551       if (additions.size() > 0) {
 552         IJavaElementDelta[] tmp = new IJavaElementDelta[add.length + additions.size()];
 553         System.arraycopy(add, 0, tmp, 0, add.length);
 554         for (int i = 0; i < additions.size(); i++)
 555           tmp[i + add.length] = (IJavaElementDelta) additions.elementAt(i);
 556         add = tmp;
 557       }
 558
 559       // add at the right position
 560       go2: for (int i = 0; i < add.length; i++) {
 561
 562         try {
 563
 564           IJavaElement e = add[i].getElement();
 565           if (filtered(parent, e))
 566             continue go2;
 567
 568           doUpdateParent = doUpdateParent || mustUpdateParent(add[i], e);
 569           ISourceRange rng = getSourceRange(e);
 570           int start = rng.getOffset();
 571           int end = start + rng.getLength() - 1;
 572
 573           Item last = null;
 574           item = null;
 575           children = getChildren(w);
 576
 577           for (int j = 0; j < children.length; j++) {
 578             item = children[j];
 579             IJavaElement r = (IJavaElement) item.getData();
 580
 581             if (r == null) {
 582               // parent node collapsed and not be opened before -> do nothing
 583               continue go2;
 584             }
 585
 586             try {
 587               rng = getSourceRange(r);
 588               if (overlaps(rng, start, end)) {
 589
 590                 // be tolerant if the delta is not correct, or if
 591                 // the tree has been updated other than by a delta
 592                 reuseTreeItem(item, e);
 593                 continue go2;
 594
 595               } else if (rng.getOffset() > start) {
 596
 597                 if (last != null && deletions.contains(last)) {
 598                   // reuse item
 599                   deletions.removeElement(last);
 600                   reuseTreeItem(last, (Object) e);
 601                 } else {
 602                   // nothing to reuse
 603                   createTreeItem(w, (Object) e, j);
 604                 }
 605                 continue go2;
 606               }
 607
 608             } catch (JavaModelException x) {
 609               // stumbled over deleted element
 610             }
 611
 612             last = item;
 613           }
 614
 615           // add at the end of the list
 616           if (last != null && deletions.contains(last)) {
 617             // reuse item
 618             deletions.removeElement(last);
 619             reuseTreeItem(last, e);
 620           } else {
 621             // nothing to reuse
 622             createTreeItem(w, e, -1);
 623           }
 624
 625         } catch (JavaModelException x) {
 626           // the element to be added is not present -> don't add it
 627         }
 628       }
 629
 630       // remove items which haven't been reused
 631       Enumeration e = deletions.elements();
 632       while (e.hasMoreElements()) {
 633         item = (Item) e.nextElement();
 634         disassociate(item);
 635         item.dispose();
 636       }
 637
 638       if (doUpdateParent)
 639         updateItem(w, delta.getElement());
 640       if (!doUpdateParent && doUpdateParentsPlus && w instanceof Item)
 641         updatePlus((Item) w, delta.getElement());
 642     }
 643
 644     /*
 645      * @see ContentViewer#handleLabelProviderChanged(LabelProviderChangedEvent)
 646      */
 647     protected void handleLabelProviderChanged(LabelProviderChangedEvent event) {
 648       Object input = getInput();
 649       if (event instanceof ProblemsLabelChangedEvent) {
 650         ProblemsLabelChangedEvent e = (ProblemsLabelChangedEvent) event;
 651         if (e.isMarkerChange() && input instanceof ICompilationUnit) {
 652           return; // marker changes can be ignored
 653         }
 654       }
 655       // look if the underlying resource changed
 656       Object[] changed = event.getElements();
 657       if (changed != null) {
 658         IResource resource = getUnderlyingResource();
 659         if (resource != null) {
 660           for (int i = 0; i < changed.length; i++) {
 661             if (changed[i] != null && changed[i].equals(resource)) {
 662               // change event to a full refresh
 663               event = new LabelProviderChangedEvent((IBaseLabelProvider) event.getSource());
 664               break;
 665             }
 666           }
 667         }
 668       }
 669       super.handleLabelProviderChanged(event);
 670     }
 671
 672     private IResource getUnderlyingResource() {
 673       Object input = getInput();
 674       if (input instanceof ICompilationUnit) {
 675         ICompilationUnit cu = (ICompilationUnit) input;
 676         if (cu.isWorkingCopy()) {
 677           return cu.getOriginalElement().getResource();
 678         } else {
 679           return cu.getResource();
 680         }
 681       }
 682       //                                        else if (input instanceof IClassFile) {
 683       //                                                return ((IClassFile) input).getResource();
 684       //                                        }
 685       return null;
 686     }
 687
 688   };
 689
 690   class LexicalSortingAction extends Action {
 691
 692     private JavaElementSorter fSorter = new JavaElementSorter();
 693
 694     public LexicalSortingAction() {
 695       super();
 696       //                                        WorkbenchHelp.setHelp(this, IJavaHelpContextIds.LEXICAL_SORTING_OUTLINE_ACTION);
 697       setText(PHPEditorMessages.getString("JavaOutlinePage.Sort.label")); //$NON-NLS-1$
 698       PHPUiImages.setLocalImageDescriptors(this, "alphab_sort_co.gif"); //$NON-NLS-1$
 699       setToolTipText(PHPEditorMessages.getString("JavaOutlinePage.Sort.tooltip")); //$NON-NLS-1$
 700       setDescription(PHPEditorMessages.getString("JavaOutlinePage.Sort.description")); //$NON-NLS-1$
 701
 702       boolean checked = PHPeclipsePlugin.getDefault().getPreferenceStore().getBoolean("LexicalSortingAction.isChecked"); //$NON-NLS-1$
 703       valueChanged(checked, false);
 704     }
 705
 706     public void run() {
 707       valueChanged(isChecked(), true);
 708     }
 709
 710     private void valueChanged(final boolean on, boolean store) {
 711       setChecked(on);
 712       BusyIndicator.showWhile(fOutlineViewer.getControl().getDisplay(), new Runnable() {
 713         public void run() {
 714           fOutlineViewer.setSorter(on ? fSorter : null);
 715         }
 716       });
 717
 718       if (store)
 719         PHPeclipsePlugin.getDefault().getPreferenceStore().setValue("LexicalSortingAction.isChecked", on); //$NON-NLS-1$
 720     }
 721   };
 722
 723   class ClassOnlyAction extends Action {
 724
 725     public ClassOnlyAction() {
 726       super();
 727       //                                WorkbenchHelp.setHelp(this, IJavaHelpContextIds.GO_INTO_TOP_LEVEL_TYPE_ACTION);
 728       setText(PHPEditorMessages.getString("JavaOutlinePage.GoIntoTopLevelType.label")); //$NON-NLS-1$
 729       setToolTipText(PHPEditorMessages.getString("JavaOutlinePage.GoIntoTopLevelType.tooltip")); //$NON-NLS-1$
 730       setDescription(PHPEditorMessages.getString("JavaOutlinePage.GoIntoTopLevelType.description")); //$NON-NLS-1$
 731       PHPUiImages.setLocalImageDescriptors(this, "gointo_toplevel_type.gif"); //$NON-NLS-1$
 732
 733       IPreferenceStore preferenceStore = PHPeclipsePlugin.getDefault().getPreferenceStore();
 734       boolean showclass = preferenceStore.getBoolean("GoIntoTopLevelTypeAction.isChecked"); //$NON-NLS-1$
 735       setTopLevelTypeOnly(showclass);
 736     }
 737
 738     /*
 739      * @see org.eclipse.jface.action.Action#run()
 740      */
 741     public void run() {
 742       setTopLevelTypeOnly(!fTopLevelTypeOnly);
 743     }
 744
 745     private void setTopLevelTypeOnly(boolean show) {
 746       fTopLevelTypeOnly = show;
 747       setChecked(show);
 748       fOutlineViewer.refresh(false);
 749
 750       IPreferenceStore preferenceStore = PHPeclipsePlugin.getDefault().getPreferenceStore();
 751       preferenceStore.setValue("GoIntoTopLevelTypeAction.isChecked", show); //$NON-NLS-1$
 752     }
 753   };
 754
 755   /**
 756    * This action toggles whether this Java Outline page links its selection to the active editor.
 757    *
 758    * @since 3.0
 759    */
 760   public class ToggleLinkingAction extends AbstractToggleLinkingAction {
 761
 762     JavaOutlinePage fJavaOutlinePage;
 763
 764     /**
 765      * Constructs a new action.
 766      *
 767      * @param outlinePage
 768      *          the Java outline page
 769      */
 770     public ToggleLinkingAction(JavaOutlinePage outlinePage) {
 771       boolean isLinkingEnabled = PreferenceConstants.getPreferenceStore().getBoolean(
 772           PreferenceConstants.EDITOR_SYNC_OUTLINE_ON_CURSOR_MOVE);
 773       setChecked(isLinkingEnabled);
 774       fJavaOutlinePage = outlinePage;
 775     }
 776
 777     /**
 778      * Runs the action.
 779      */
 780     public void run() {
 781       PreferenceConstants.getPreferenceStore().setValue(PreferenceConstants.EDITOR_SYNC_OUTLINE_ON_CURSOR_MOVE, isChecked());
 782       if (isChecked() && fEditor != null)
 783         fEditor.synchronizeOutlinePage(fEditor.computeHighlightRangeSourceReference(), false);
 784     }
 785
 786   }
 787
 788   /** A flag to show contents of top level type only */
 789   private boolean fTopLevelTypeOnly;
 790
 791   private IJavaElement fInput;
 792
 793   private String fContextMenuID;
 794
 795   private Menu fMenu;
 796
 797   private JavaOutlineViewer fOutlineViewer;
 798
 799   private PHPEditor fEditor;
 800
 801   private MemberFilterActionGroup fMemberFilterActionGroup;
 802
 803   private ListenerList fSelectionChangedListeners = new ListenerList();
 804
 805   private ListenerList fPostSelectionChangedListeners = new ListenerList();
 806
 807   private Hashtable fActions = new Hashtable();
 808
 809   private TogglePresentationAction fTogglePresentation;
 810
 811   private GotoErrorAction fPreviousError;
 812
 813   private GotoErrorAction fNextError;
 814
 815   private TextEditorAction fShowJavadoc;
 816
 817   private TextOperationAction fUndo;
 818
 819   private TextOperationAction fRedo;
 820
 821   private ToggleLinkingAction fToggleLinkingAction;
 822
 823   private CompositeActionGroup fActionGroups;
 824
 825   //    private CCPActionGroup fCCPActionGroup;
 826
 827   private IPropertyChangeListener fPropertyChangeListener;
 828   /**
 829          * Custom filter action group.
 830          * @since 3.0
 831          */
 832 //  private CustomFiltersActionGroup fCustomFiltersActionGroup;
 833
 834   public JavaOutlinePage(String contextMenuID, PHPEditor editor) {
 835     super();
 836
 837     Assert.isNotNull(editor);
 838
 839     fContextMenuID = contextMenuID;
 840     fEditor = editor;
 841
 842     fTogglePresentation = new TogglePresentationAction();
 843     fPreviousError = new GotoErrorAction("PreviousError.", false); //$NON-NLS-1$
 844     fPreviousError.setImageDescriptor(PHPUiImages.DESC_TOOL_GOTO_PREV_ERROR);
 845     fNextError = new GotoErrorAction("NextError.", true); //$NON-NLS-1$
 846     fNextError.setImageDescriptor(PHPUiImages.DESC_TOOL_GOTO_NEXT_ERROR);
 847     fShowJavadoc = (TextEditorAction) fEditor.getAction("ShowJavaDoc"); //$NON-NLS-1$
 848     fUndo = (TextOperationAction) fEditor.getAction(ITextEditorActionConstants.UNDO);
 849     fRedo = (TextOperationAction) fEditor.getAction(ITextEditorActionConstants.REDO);
 850
 851     fTogglePresentation.setEditor(editor);
 852     fPreviousError.setEditor(editor);
 853     fNextError.setEditor(editor);
 854
 855     fPropertyChangeListener = new IPropertyChangeListener() {
 856       public void propertyChange(PropertyChangeEvent event) {
 857         doPropertyChange(event);
 858       }
 859     };
 860     PHPeclipsePlugin.getDefault().getPreferenceStore().addPropertyChangeListener(fPropertyChangeListener);
 861   }
 862
 863   /**
 864    * Returns the primary type of a compilation unit (has the same name as the compilation unit).
 865    *
 866    * @param compilationUnit
 867    *          the compilation unit
 868    * @return returns the primary type of the compilation unit, or <code>null</code> if is does not have one
 869    */
 870   protected IType getMainType(ICompilationUnit compilationUnit) {
 871     String name = compilationUnit.getElementName();
 872     int index = name.indexOf('.');
 873     if (index != -1)
 874       name = name.substring(0, index);
 875     IType type = compilationUnit.getType(name);
 876     return type.exists() ? type : null;
 877   }
 878
 879   /**
 880    * Returns the primary type of a class file.
 881    *
 882    * @param classFile
 883    *          the class file
 884    * @return returns the primary type of the class file, or <code>null</code> if is does not have one
 885    */
 886   //    protected IType getMainType(IClassFile classFile) {
 887   //            try {
 888   //                    IType type= classFile.getType();
 889   //                    return type != null && type.exists() ? type : null;
 890   //            } catch (JavaModelException e) {
 891   //                    return null;
 892   //            }
 893   //    }
 894   /*
 895    * (non-Javadoc) Method declared on Page
 896    */
 897   public void init(IPageSite pageSite) {
 898     super.init(pageSite);
 899   }
 900
 901   private void doPropertyChange(PropertyChangeEvent event) {
 902     if (fOutlineViewer != null) {
 903       if (PreferenceConstants.APPEARANCE_MEMBER_SORT_ORDER.equals(event.getProperty())) {
 904         fOutlineViewer.refresh(false);
 905       }
 906     }
 907   }
 908
 909   /*
 910    * @see ISelectionProvider#addSelectionChangedListener(ISelectionChangedListener)
 911    */
 912   public void addSelectionChangedListener(ISelectionChangedListener listener) {
 913     if (fOutlineViewer != null)
 914       fOutlineViewer.addPostSelectionChangedListener(listener);
 915     else
 916       fSelectionChangedListeners.add(listener);
 917   }
 918
 919   /*
 920    * @see ISelectionProvider#removeSelectionChangedListener(ISelectionChangedListener)
 921    */
 922   public void removeSelectionChangedListener(ISelectionChangedListener listener) {
 923     if (fOutlineViewer != null)
 924       fOutlineViewer.removePostSelectionChangedListener(listener);
 925     else
 926       fSelectionChangedListeners.remove(listener);
 927   }
 928
 929   /*
 930    * @see ISelectionProvider#setSelection(ISelection)
 931    */
 932   public void setSelection(ISelection selection) {
 933     if (fOutlineViewer != null)
 934       fOutlineViewer.setSelection(selection);
 935   }
 936
 937   /*
 938    * @see ISelectionProvider#getSelection()
 939    */
 940   public ISelection getSelection() {
 941     if (fOutlineViewer == null)
 942       return StructuredSelection.EMPTY;
 943     return fOutlineViewer.getSelection();
 944   }
 945
 946   //  private void registerToolbarActions() {
 947   //
 948   //    IToolBarManager toolBarManager = getSite().getActionBars().getToolBarManager();
 949   //    if (toolBarManager != null) {
 950   //      toolBarManager.add(new ClassOnlyAction());
 951   //      toolBarManager.add(new LexicalSortingAction());
 952   //
 953   //      fMemberFilterActionGroup = new MemberFilterActionGroup(fOutlineViewer, "JavaOutlineViewer"); //$NON-NLS-1$
 954   //      fMemberFilterActionGroup.contributeToToolBar(toolBarManager);
 955   //
 956   //    }
 957   //  }
 958
 959   private void registerToolbarActions(IActionBars actionBars) {
 960
 961     IToolBarManager toolBarManager = actionBars.getToolBarManager();
 962     if (toolBarManager != null) {
 963       toolBarManager.add(new LexicalSortingAction());
 964
 965       fMemberFilterActionGroup = new MemberFilterActionGroup(fOutlineViewer, "org.eclipse.jdt.ui.JavaOutlinePage"); //$NON-NLS-1$
 966       fMemberFilterActionGroup.contributeToToolBar(toolBarManager);
 967
 968       //                fCustomFiltersActionGroup.fillActionBars(actionBars);
 969
 970       IMenuManager menu = actionBars.getMenuManager();
 971       menu.add(new Separator("EndFilterGroup")); //$NON-NLS-1$
 972
 973       fToggleLinkingAction = new ToggleLinkingAction(this);
 974       menu.add(new ClassOnlyAction());
 975       menu.add(fToggleLinkingAction);
 976     }
 977   }
 978
 979   /*
 980    * @see IPage#createControl
 981    */
 982   public void createControl(Composite parent) {
 983
 984     Tree tree = new Tree(parent, SWT.MULTI);
 985
 986     AppearanceAwareLabelProvider lprovider = new AppearanceAwareLabelProvider(AppearanceAwareLabelProvider.DEFAULT_TEXTFLAGS
 987         | JavaElementLabels.F_APP_TYPE_SIGNATURE, AppearanceAwareLabelProvider.DEFAULT_IMAGEFLAGS);
 988
 989     fOutlineViewer = new JavaOutlineViewer(tree);
 990     fOutlineViewer.setContentProvider(new ChildrenProvider());
 991     fOutlineViewer.setLabelProvider(new DecoratingJavaLabelProvider(lprovider));
 992
 993     Object[] listeners = fSelectionChangedListeners.getListeners();
 994     for (int i = 0; i < listeners.length; i++) {
 995       fSelectionChangedListeners.remove(listeners[i]);
 996       fOutlineViewer.addPostSelectionChangedListener((ISelectionChangedListener) listeners[i]);
 997     }
 998
 999     listeners = fPostSelectionChangedListeners.getListeners();
1000     for (int i = 0; i < listeners.length; i++) {
1001       fPostSelectionChangedListeners.remove(listeners[i]);
1002       fOutlineViewer.addPostSelectionChangedListener((ISelectionChangedListener) listeners[i]);
1003     }
1004
1005     MenuManager manager = new MenuManager(fContextMenuID, fContextMenuID);
1006     manager.setRemoveAllWhenShown(true);
1007     manager.addMenuListener(new IMenuListener() {
1008       public void menuAboutToShow(IMenuManager manager) {
1009         contextMenuAboutToShow(manager);
1010       }
1011     });
1012     fMenu = manager.createContextMenu(tree);
1013     tree.setMenu(fMenu);
1014
1015     IPageSite site = getSite();
1016     site.registerContextMenu(PHPeclipsePlugin.getPluginId() + ".outline", manager, fOutlineViewer); //$NON-NLS-1$
1017     site.setSelectionProvider(fOutlineViewer);
1018
1019     // we must create the groups after we have set the selection provider to the site
1020     fActionGroups = new CompositeActionGroup(new ActionGroup[] {
1021     //                          new OpenViewActionGroup(this),
1022         //                              fCCPActionGroup= new CCPActionGroup(this),
1023         new GenerateActionGroup(this) });
1024     //                          new RefactorActionGroup(this),
1025     //                          new JavaSearchActionGroup(this)});
1026
1027     // register global actions
1028     IActionBars bars = site.getActionBars();
1029
1030     bars.setGlobalActionHandler(ITextEditorActionConstants.UNDO, fUndo);
1031     bars.setGlobalActionHandler(ITextEditorActionConstants.REDO, fRedo);
1032     bars.setGlobalActionHandler(ITextEditorActionConstants.PREVIOUS, fPreviousError);
1033     bars.setGlobalActionHandler(ITextEditorActionConstants.NEXT, fNextError);
1034     //          bars.setGlobalActionHandler(PHPdtActionConstants.SHOW_PHP_DOC, fShowJavadoc);
1035     bars.setGlobalActionHandler(IJavaEditorActionConstants.TOGGLE_PRESENTATION, fTogglePresentation);
1036     // http://dev.eclipse.org/bugs/show_bug.cgi?id=18968
1037     bars.setGlobalActionHandler(IJavaEditorActionConstants.PREVIOUS_ERROR, fPreviousError);
1038     bars.setGlobalActionHandler(IJavaEditorActionConstants.NEXT_ERROR, fNextError);
1039
1040     fActionGroups.fillActionBars(bars);
1041
1042     IStatusLineManager statusLineManager = site.getActionBars().getStatusLineManager();
1043     if (statusLineManager != null) {
1044       StatusBarUpdater updater = new StatusBarUpdater(statusLineManager);
1045       fOutlineViewer.addPostSelectionChangedListener(updater);
1046     }
1047
1048     registerToolbarActions(bars);
1049
1050     fOutlineViewer.setInput(fInput);
1051     //    fOutlineViewer.getControl().addKeyListener(new KeyAdapter() {
1052     //      public void keyPressed(KeyEvent e) {
1053     //        handleKeyReleased(e);
1054     //      }
1055     //    });
1056     //
1057     //    initDragAndDrop();
1058   }
1059
1060   public void dispose() {
1061
1062     if (fEditor == null)
1063       return;
1064
1065     if (fMemberFilterActionGroup != null) {
1066       fMemberFilterActionGroup.dispose();
1067       fMemberFilterActionGroup = null;
1068     }
1069
1070     fEditor.outlinePageClosed();
1071     fEditor = null;
1072
1073     fSelectionChangedListeners.clear();
1074     fSelectionChangedListeners = null;
1075
1076     fPostSelectionChangedListeners.clear();
1077     fPostSelectionChangedListeners = null;
1078
1079     if (fPropertyChangeListener != null) {
1080       PHPeclipsePlugin.getDefault().getPreferenceStore().removePropertyChangeListener(fPropertyChangeListener);
1081       fPropertyChangeListener = null;
1082     }
1083
1084     if (fMenu != null && !fMenu.isDisposed()) {
1085       fMenu.dispose();
1086       fMenu = null;
1087     }
1088
1089     if (fActionGroups != null)
1090       fActionGroups.dispose();
1091
1092     fTogglePresentation.setEditor(null);
1093     fPreviousError.setEditor(null);
1094     fNextError.setEditor(null);
1095
1096     fOutlineViewer = null;
1097
1098     super.dispose();
1099   }
1100
1101   public Control getControl() {
1102     if (fOutlineViewer != null)
1103       return fOutlineViewer.getControl();
1104     return null;
1105   }
1106
1107   public void setInput(IJavaElement inputElement) {
1108     fInput = inputElement;
1109     if (fOutlineViewer != null)
1110       fOutlineViewer.setInput(fInput);
1111   }
1112
1113   public void select(ISourceReference reference) {
1114     if (fOutlineViewer != null) {
1115
1116       ISelection s = fOutlineViewer.getSelection();
1117       if (s instanceof IStructuredSelection) {
1118         IStructuredSelection ss = (IStructuredSelection) s;
1119         List elements = ss.toList();
1120         if (!elements.contains(reference)) {
1121           s = (reference == null ? StructuredSelection.EMPTY : new StructuredSelection(reference));
1122           fOutlineViewer.setSelection(s, true);
1123         }
1124       }
1125     }
1126   }
1127
1128   public void setAction(String actionID, IAction action) {
1129     Assert.isNotNull(actionID);
1130     if (action == null)
1131       fActions.remove(actionID);
1132     else
1133       fActions.put(actionID, action);
1134   }
1135
1136   public IAction getAction(String actionID) {
1137     Assert.isNotNull(actionID);
1138     return (IAction) fActions.get(actionID);
1139   }
1140
1141   /**
1142    * Answer the property defined by key.
1143    */
1144   public Object getAdapter(Class key) {
1145     if (key == IShowInSource.class) {
1146       return getShowInSource();
1147     }
1148     if (key == IShowInTargetList.class) {
1149       return new IShowInTargetList() {
1150         public String[] getShowInTargetIds() {
1151           return new String[] { JavaUI.ID_PACKAGES };
1152         }
1153
1154       };
1155     }
1156     if (key == IShowInTarget.class) {
1157       return getShowInTarget();
1158     }
1159
1160     return null;
1161   }
1162
1163   /**
1164    * Convenience method to add the action installed under the given actionID to the specified group of the menu.
1165    */
1166   protected void addAction(IMenuManager menu, String group, String actionID) {
1167     IAction action = getAction(actionID);
1168     if (action != null) {
1169       if (action instanceof IUpdate)
1170         ((IUpdate) action).update();
1171
1172       if (action.isEnabled()) {
1173         IMenuManager subMenu = menu.findMenuUsingPath(group);
1174         if (subMenu != null)
1175           subMenu.add(action);
1176         else
1177           menu.appendToGroup(group, action);
1178       }
1179     }
1180   }
1181
1182   protected void contextMenuAboutToShow(IMenuManager menu) {
1183
1184     PHPeclipsePlugin.createStandardGroups(menu);
1185
1186     IStructuredSelection selection = (IStructuredSelection) getSelection();
1187     fActionGroups.setContext(new ActionContext(selection));
1188     fActionGroups.fillContextMenu(menu);
1189   }
1190
1191   /*
1192    * @see Page#setFocus()
1193    */
1194   public void setFocus() {
1195     if (fOutlineViewer != null)
1196       fOutlineViewer.getControl().setFocus();
1197   }
1198
1199   /**
1200    * Checkes whether a given Java element is an inner type.
1201    */
1202   private boolean isInnerType(IJavaElement element) {
1203
1204     if (element.getElementType() == IJavaElement.TYPE) {
1205       IJavaElement parent = element.getParent();
1206       int type = parent.getElementType();
1207       return (type != IJavaElement.COMPILATION_UNIT && type != IJavaElement.CLASS_FILE);
1208     }
1209
1210     return false;
1211   }
1212
1213   /**
1214    * Handles key events in viewer.
1215    */
1216   private void handleKeyReleased(KeyEvent event) {
1217
1218     if (event.stateMask != 0)
1219       return;
1220
1221     IAction action = null;
1222     //          if (event.character == SWT.DEL) {
1223     //                  action= fCCPActionGroup.getDeleteAction();
1224     //          }
1225
1226     if (action != null && action.isEnabled())
1227       action.run();
1228   }
1229
1230   /**
1231    * Returns the <code>IShowInSource</code> for this view.
1232    */
1233   protected IShowInSource getShowInSource() {
1234     return new IShowInSource() {
1235       public ShowInContext getShowInContext() {
1236         return new ShowInContext(null, getSite().getSelectionProvider().getSelection());
1237       }
1238     };
1239   }
1240
1241   /**
1242    * Returns the <code>IShowInTarget</code> for this view.
1243    */
1244   protected IShowInTarget getShowInTarget() {
1245     return new IShowInTarget() {
1246       public boolean show(ShowInContext context) {
1247         ISelection sel = context.getSelection();
1248         if (sel instanceof ITextSelection) {
1249           ITextSelection tsel = (ITextSelection) sel;
1250           int offset = tsel.getOffset();
1251           IJavaElement element = fEditor.getElementAt(offset);
1252           if (element != null) {
1253             setSelection(new StructuredSelection(element));
1254             return true;
1255           }
1256         }
1257         return false;
1258       }
1259     };
1260   }
1261
1262   private void initDragAndDrop() {
1263     int ops = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
1264     Transfer[] transfers = new Transfer[] { LocalSelectionTransfer.getInstance() };
1265
1266     // Drop Adapter
1267     //          TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
1268     //                  new SelectionTransferDropAdapter(fOutlineViewer)
1269     //          };
1270     //          fOutlineViewer.addDropSupport(ops | DND.DROP_DEFAULT, transfers, new DelegatingDropAdapter(dropListeners));
1271
1272     // Drag Adapter
1273     TransferDragSourceListener[] dragListeners = new TransferDragSourceListener[] { new SelectionTransferDragAdapter(fOutlineViewer) };
1274     fOutlineViewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(fOutlineViewer, dragListeners));
1275   }
1276
1277   /*
1278    * @see org.eclipse.jface.text.IPostSelectionProvider#addPostSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
1279    */
1280   public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
1281     if (fOutlineViewer != null)
1282       fOutlineViewer.addPostSelectionChangedListener(listener);
1283     else
1284       fPostSelectionChangedListeners.add(listener);
1285   }
1286
1287   /*
1288    * @see org.eclipse.jface.text.IPostSelectionProvider#removePostSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
1289    */
1290   public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
1291     if (fOutlineViewer != null)
1292       fOutlineViewer.removePostSelectionChangedListener(listener);
1293     else
1294       fPostSelectionChangedListeners.remove(listener);
1295   }
1296 }