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