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

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