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