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