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