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