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

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