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