Fix hover functionality.
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpdt / ui / JavaUI.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.phpdt.ui;
12
13 import net.sourceforge.phpdt.core.IBufferFactory;
14 import net.sourceforge.phpdt.core.IJavaElement;
15 import net.sourceforge.phpdt.core.IWorkingCopy;
16 import net.sourceforge.phpdt.core.JavaCore;
17 import net.sourceforge.phpdt.core.JavaModelException;
18 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
19 import net.sourceforge.phpeclipse.phpeditor.EditorUtility;
20 import net.sourceforge.phpeclipse.ui.WebUI;
21
22 import org.eclipse.ui.IEditorPart;
23 import org.eclipse.ui.ISharedImages;
24 import org.eclipse.ui.PartInitException;
25 import org.eclipse.ui.internal.SharedImages;
26 import org.eclipse.ui.texteditor.IDocumentProvider;
27
28 /**
29  * Central access point for the Java UI plug-in (id
30  * <code>"net.sourceforge.phpdt.ui"</code>). This class provides static
31  * methods for:
32  * <ul>
33  * <li> creating various kinds of selection dialogs to present a collection of
34  * Java elements to the user and let them make a selection.</li>
35  * <li> opening a Java editor on a compilation unit.</li>
36  * </ul>
37  * <p>
38  * This class provides static methods and fields only; it is not intended to be
39  * instantiated or subclassed by clients.
40  * </p>
41  */
42 public final class JavaUI {
43
44         private static ISharedImages fgSharedImages = null;
45
46         private JavaUI() {
47                 // prevent instantiation of JavaUI.
48         }
49
50         /**
51          * The id of the Java plugin (value <code>"net.sourceforge.phpdt.ui"</code>).
52          */
53         // public static final String ID_PLUGIN= "net.sourceforge.phpdt.ui";
54         // //$NON-NLS-1$
55         /**
56          * The id of the Java perspective (value
57          * <code>"net.sourceforge.phpdt.ui.JavaPerspective"</code>).
58          */
59          public static final String ID_PERSPECTIVE=
60          "net.sourceforge.phpdt.ui.JavaPerspective"; //$NON-NLS-1$
61         /**
62          * The id of the Java hierarchy perspective (value
63          * <code>"net.sourceforge.phpdt.ui.JavaHierarchyPerspective"</code>).
64          */
65         // public static final String ID_HIERARCHYPERSPECTIVE=
66         // "net.sourceforge.phpdt.ui.JavaHierarchyPerspective"; //$NON-NLS-1$
67         /**
68          * The id of the Java action set (value
69          * <code>"net.sourceforge.phpdt.ui.JavaActionSet"</code>).
70          */
71         // public static final String ID_ACTION_SET=
72         // "net.sourceforge.phpdt.ui.JavaActionSet"; //$NON-NLS-1$
73         /**
74          * The id of the Java Element Creation action set (value
75          * <code>"net.sourceforge.phpdt.ui.JavaElementCreationActionSet"</code>).
76          * 
77          * @since 2.0
78          */
79         // public static final String ID_ELEMENT_CREATION_ACTION_SET=
80         // "net.sourceforge.phpdt.ui.JavaElementCreationActionSet"; //$NON-NLS-1$
81         /**
82          * The id of the Java Coding action set (value
83          * <code>"net.sourceforge.phpdt.ui.CodingActionSet"</code>).
84          * 
85          * @since 2.0
86          */
87         // public static final String ID_CODING_ACTION_SET=
88         // "net.sourceforge.phpdt.ui.CodingActionSet"; //$NON-NLS-1$
89         /**
90          * The id of the Java action set for open actions (value
91          * <code>"net.sourceforge.phpdt.ui.A_OpenActionSet"</code>).
92          * 
93          * @since 2.0
94          */
95         // public static final String ID_OPEN_ACTION_SET=
96         // "net.sourceforge.phpdt.ui.A_OpenActionSet"; //$NON-NLS-1$
97         /**
98          * The id of the Java Search action set (value
99          * <code>net.sourceforge.phpdt.ui.SearchActionSet"</code>).
100          * 
101          * @since 2.0
102          */
103         // public static final String ID_SEARCH_ACTION_SET=
104         // "net.sourceforge.phpdt.ui.SearchActionSet"; //$NON-NLS-1$
105         /**
106          * The editor part id of the editor that presents Java compilation units
107          * (value <code>"net.sourceforge.phpdt.ui.CompilationUnitEditor"</code>).
108          */
109         // public static final String ID_CU_EDITOR=
110         // "net.sourceforge.phpdt.ui.PHPUnitEditor"; //$NON-NLS-1$
111         /**
112          * The editor part id of the editor that presents Java binary class files
113          * (value <code>"net.sourceforge.phpdt.ui.ClassFileEditor"</code>).
114          */
115         // public static final String ID_CF_EDITOR=
116         // "net.sourceforge.phpdt.ui.ClassFileEditor"; //$NON-NLS-1$
117         /**
118          * The editor part id of the code snippet editor (value
119          * <code>"net.sourceforge.phpdt.ui.SnippetEditor"</code>).
120          */
121         // public static final String ID_SNIPPET_EDITOR=
122         // "net.sourceforge.phpdt.ui.SnippetEditor"; //$NON-NLS-1$
123         /**
124          * The view part id of the Packages view (value
125          * <code>"net.sourceforge.phpdt.ui.PackageExplorer"</code>).
126          * <p>
127          * When this id is used to access a view part with
128          * <code>IWorkbenchPage.findView</code> or <code>showView</code>, the
129          * returned <code>IViewPart</code> can be safely cast to an
130          * <code>IPackagesViewPart</code>.
131          * </p>
132          * 
133          * @see IPackagesViewPart
134          * @see org.eclipse.ui.IWorkbenchPage#findView(java.lang.String)
135          * @see org.eclipse.ui.IWorkbenchPage#showView(java.lang.String)
136          */
137         public static final String ID_PACKAGES = "net.sourceforge.phpdt.ui.PackageExplorer"; //$NON-NLS-1$
138
139         /**
140          * The view part id of the type hierarchy part. (value
141          * <code>"net.sourceforge.phpdt.ui.TypeHierarchy"</code>).
142          * <p>
143          * When this id is used to access a view part with
144          * <code>IWorkbenchPage.findView</code> or <code>showView</code>, the
145          * returned <code>IViewPart</code> can be safely cast to an
146          * <code>ITypeHierarchyViewPart</code>.
147          * </p>
148          * 
149          * @see ITypeHierarchyViewPart
150          * @see org.eclipse.ui.IWorkbenchPage#findView(java.lang.String)
151          * @see org.eclipse.ui.IWorkbenchPage#showView(java.lang.String)
152          */
153         public static final String ID_TYPE_HIERARCHY = "net.sourceforge.phpdt.ui.TypeHierarchy"; //$NON-NLS-1$
154
155         /**
156          * The id of the Java Browsing Perspective (value
157          * <code>"net.sourceforge.phpdt.ui.JavaBrowsingPerspective"</code>).
158          * 
159          * @since 2.0
160          */
161         // public static String ID_BROWSING_PERSPECTIVE=
162         // "net.sourceforge.phpdt.ui.JavaBrowsingPerspective"; //$NON-NLS-1$
163         /**
164          * The view part id of the Java Browsing Projects view (value
165          * <code>"net.sourceforge.phpdt.ui.ProjectsView"</code>).
166          * 
167          * @since 2.0
168          */
169         // public static String ID_PROJECTS_VIEW=
170         // "net.sourceforge.phpdt.ui.ProjectsView"; //$NON-NLS-1$
171         /**
172          * The view part id of the Java Browsing Packages view (value
173          * <code>"net.sourceforge.phpdt.ui.PackagesView"</code>).
174          * 
175          * @since 2.0
176          */
177         // public static String ID_PACKAGES_VIEW=
178         // "net.sourceforge.phpdt.ui.PackagesView"; //$NON-NLS-1$
179         /**
180          * The view part id of the Java Browsing Types view (value
181          * <code>"net.sourceforge.phpdt.ui.TypesView"</code>).
182          * 
183          * @since 2.0
184          */
185         // public static String ID_TYPES_VIEW= "net.sourceforge.phpdt.ui.TypesView";
186         // //$NON-NLS-1$
187         /**
188          * The view part id of the Java Browsing Members view (value
189          * <code>"net.sourceforge.phpdt.ui.MembersView"</code>).
190          * 
191          * @since 2.0
192          */
193         // public static String ID_MEMBERS_VIEW=
194         // "net.sourceforge.phpdt.ui.MembersView"; //$NON-NLS-1$
195         /**
196          * The class org.eclipse.debug.core.model.IProcess allows attaching String
197          * properties to processes. The Java UI contributes a property page for
198          * IProcess that will show the contents of the property with this key. The
199          * intent of this property is to show the command line a process was
200          * launched with.
201          * 
202          * @deprecated
203          */
204         // public final static String ATTR_CMDLINE=
205         // "net.sourceforge.phpdt.ui.launcher.cmdLine"; //$NON-NLS-1$
206         /**
207          * Returns the shared images for the Java UI.
208          * 
209          * @return the shared images manager
210          */
211         public static ISharedImages getSharedImages() {
212                 if (fgSharedImages == null)
213                         fgSharedImages = new SharedImages();
214
215                 return fgSharedImages;
216         }
217
218         /**
219          * Creates a selection dialog that lists all packages of the given Java
220          * project. The caller is responsible for opening the dialog with
221          * <code>Window.open</code>, and subsequently extracting the selected
222          * package (of type <code>IPackageFragment</code>) via
223          * <code>SelectionDialog.getResult</code>.
224          * 
225          * @param parent
226          *            the parent shell of the dialog to be created
227          * @param project
228          *            the Java project
229          * @param style
230          *            flags defining the style of the dialog; the valid flags are:
231          *            <code>IJavaElementSearchConstants.CONSIDER_BINARIES</code>,
232          *            indicating that packages from binary package fragment roots
233          *            should be included in addition to those from source package
234          *            fragment roots;
235          *            <code>IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS</code>,
236          *            indicating that packages from required projects should be
237          *            included as well.
238          * @param filter
239          *            the initial pattern to filter the set of packages. For example
240          *            "com" shows all packages starting with "com". The meta
241          *            character '?' representing any character and '*' representing
242          *            any string are supported. Clients can pass an empty string if
243          *            no filtering is required.
244          * @return a new selection dialog
245          * @exception JavaModelException
246          *                if the selection dialog could not be opened
247          * 
248          * @since 2.0
249          */
250         // public static SelectionDialog createPackageDialog(Shell parent,
251         // IJavaProject project, int style, String filter) throws JavaModelException
252         // {
253         // Assert.isTrue((style | IJavaElementSearchConstants.CONSIDER_BINARIES |
254         // IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS) ==
255         // (IJavaElementSearchConstants.CONSIDER_BINARIES |
256         // IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS));
257         //
258         // IPackageFragmentRoot[] roots= null;
259         // if ((style & IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS) !=
260         // 0) {
261         // roots= project.getAllPackageFragmentRoots();
262         // } else {
263         // roots= project.getPackageFragmentRoots();
264         // }
265         //              
266         // List consideredRoots= null;
267         // if ((style & IJavaElementSearchConstants.CONSIDER_BINARIES) != 0) {
268         // consideredRoots= Arrays.asList(roots);
269         // } else {
270         // consideredRoots= new ArrayList(roots.length);
271         // for (int i= 0; i < roots.length; i++) {
272         // IPackageFragmentRoot root= roots[i];
273         // if (root.getKind() != IPackageFragmentRoot.K_BINARY)
274         // consideredRoots.add(root);
275         //                                      
276         // }
277         // }
278         //              
279         // int flags= JavaElementLabelProvider.SHOW_DEFAULT;
280         // if (consideredRoots.size() > 1)
281         // flags= flags | JavaElementLabelProvider.SHOW_ROOT;
282         //
283         // List packages= new ArrayList();
284         // Iterator iter= consideredRoots.iterator();
285         // while(iter.hasNext()) {
286         // IPackageFragmentRoot root= (IPackageFragmentRoot)iter.next();
287         // packages.addAll(Arrays.asList(root.getChildren()));
288         // }
289         // ElementListSelectionDialog dialog= new ElementListSelectionDialog(parent,
290         // new JavaElementLabelProvider(flags));
291         // dialog.setIgnoreCase(false);
292         // dialog.setElements(packages.toArray()); // XXX inefficient
293         // dialog.setFilter(filter);
294         // return dialog;
295         // }
296         /**
297          * Creates a selection dialog that lists all packages of the given Java
298          * project. The caller is responsible for opening the dialog with
299          * <code>Window.open</code>, and subsequently extracting the selected
300          * package (of type <code>IPackageFragment</code>) via
301          * <code>SelectionDialog.getResult</code>.
302          * 
303          * @param parent
304          *            the parent shell of the dialog to be created
305          * @param project
306          *            the Java project
307          * @param style
308          *            flags defining the style of the dialog; the valid flags are:
309          *            <code>IJavaElementSearchConstants.CONSIDER_BINARIES</code>,
310          *            indicating that packages from binary package fragment roots
311          *            should be included in addition to those from source package
312          *            fragment roots;
313          *            <code>IJavaElementSearchConstants.CONSIDER_REQUIRED_PROJECTS</code>,
314          *            indicating that packages from required projects should be
315          *            included as well.
316          * @return a new selection dialog
317          * @exception JavaModelException
318          *                if the selection dialog could not be opened
319          */
320         // public static SelectionDialog createPackageDialog(Shell parent,
321         // IJavaProject project, int style) throws JavaModelException {
322         // return createPackageDialog(parent, project, style, ""); //$NON-NLS-1$
323         // }
324         /**
325          * Creates a selection dialog that lists all packages under the given
326          * package fragment root. The caller is responsible for opening the dialog
327          * with <code>Window.open</code>, and subsequently extracting the
328          * selected package (of type <code>IPackageFragment</code>) via
329          * <code>SelectionDialog.getResult</code>.
330          * 
331          * @param parent
332          *            the parent shell of the dialog to be created
333          * @param root
334          *            the package fragment root
335          * @param filter
336          *            the initial pattern to filter the set of packages. For example
337          *            "com" shows all packages starting with "com". The meta
338          *            character '?' representing any character and '*' representing
339          *            any string are supported. Clients can pass an empty string if
340          *            no filtering is required.
341          * @return a new selection dialog
342          * @exception JavaModelException
343          *                if the selection dialog could not be opened
344          * 
345          * @since 2.0
346          */
347         // public static SelectionDialog createPackageDialog(Shell parent,
348         // IPackageFragmentRoot root, String filter) throws JavaModelException {
349         // ElementListSelectionDialog dialog= new ElementListSelectionDialog(parent,
350         // new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT));
351         // dialog.setIgnoreCase(false);
352         // dialog.setElements(root.getChildren());
353         // dialog.setFilter(filter);
354         // return dialog;
355         // }
356         /**
357          * Creates a selection dialog that lists all packages under the given
358          * package fragment root. The caller is responsible for opening the dialog
359          * with <code>Window.open</code>, and subsequently extracting the
360          * selected package (of type <code>IPackageFragment</code>) via
361          * <code>SelectionDialog.getResult</code>.
362          * 
363          * @param parent
364          *            the parent shell of the dialog to be created
365          * @param root
366          *            the package fragment root
367          * @return a new selection dialog
368          * @exception JavaModelException
369          *                if the selection dialog could not be opened
370          */
371         // public static SelectionDialog createPackageDialog(Shell parent,
372         // IPackageFragmentRoot root) throws JavaModelException {
373         // return createPackageDialog(parent, root, ""); //$NON-NLS-1$
374         // }
375         /**
376          * Creates a selection dialog that lists all types in the given scope. The
377          * caller is responsible for opening the dialog with
378          * <code>Window.open</code>, and subsequently extracting the selected
379          * type(s) (of type <code>IType</code>) via
380          * <code>SelectionDialog.getResult</code>.
381          * 
382          * @param parent
383          *            the parent shell of the dialog to be created
384          * @param context
385          *            the runnable context used to show progress when the dialog is
386          *            being populated
387          * @param scope
388          *            the scope that limits which types are included
389          * @param style
390          *            flags defining the style of the dialog; the only valid values
391          *            are <code>IJavaElementSearchConstants.CONSIDER_CLASSES</code>,
392          *            <code>CONSIDER_INTERFACES</code>, or their bitwise OR
393          *            (equivalent to <code>CONSIDER_TYPES</code>)
394          * @param multipleSelection
395          *            <code>true</code> if multiple selection is allowed
396          * @param filter
397          *            the initial pattern to filter the set of types. For example
398          *            "Abstract" shows all types starting with "abstract". The meta
399          *            character '?' representing any character and '*' representing
400          *            any string are supported. Clients can pass an empty string if
401          *            no filtering is required.
402          * @exception JavaModelException
403          *                if the selection dialog could not be opened
404          * 
405          * @since 2.0
406          */
407         // public static SelectionDialog createTypeDialog(Shell parent,
408         // IRunnableContext context, IJavaSearchScope scope, int style, boolean
409         // multipleSelection, String filter) throws JavaModelException {
410         // int elementKinds= 0;
411         // if (style == IJavaElementSearchConstants.CONSIDER_TYPES) {
412         // elementKinds= IJavaSearchConstants.TYPE;
413         // } else if (style == IJavaElementSearchConstants.CONSIDER_INTERFACES) {
414         // elementKinds= IJavaSearchConstants.INTERFACE;
415         // } else if (style == IJavaElementSearchConstants.CONSIDER_CLASSES) {
416         // elementKinds= IJavaSearchConstants.CLASS;
417         // } else {
418         // Assert.isTrue(false, "illegal style"); //$NON-NLS-1$
419         // }
420         // if (multipleSelection) {
421         // MultiTypeSelectionDialog dialog= new MultiTypeSelectionDialog(parent,
422         // context, elementKinds, scope);
423         // dialog.setMessage(JavaUIMessages.getString("JavaUI.defaultDialogMessage"));
424         // //$NON-NLS-1$
425         // dialog.setFilter(filter);
426         // return dialog;
427         // } else {
428         // TypeSelectionDialog dialog= new TypeSelectionDialog(parent, context,
429         // elementKinds, scope);
430         // dialog.setMessage(JavaUIMessages.getString("JavaUI.defaultDialogMessage"));
431         // //$NON-NLS-1$
432         // dialog.setFilter(filter);
433         // return dialog;
434         // }
435         // }
436         /**
437          * Creates a selection dialog that lists all types in the given scope. The
438          * caller is responsible for opening the dialog with
439          * <code>Window.open</code>, and subsequently extracting the selected
440          * type(s) (of type <code>IType</code>) via
441          * <code>SelectionDialog.getResult</code>.
442          * 
443          * @param parent
444          *            the parent shell of the dialog to be created
445          * @param context
446          *            the runnable context used to show progress when the dialog is
447          *            being populated
448          * @param scope
449          *            the scope that limits which types are included
450          * @param style
451          *            flags defining the style of the dialog; the only valid values
452          *            are <code>IJavaElementSearchConstants.CONSIDER_CLASSES</code>,
453          *            <code>CONSIDER_INTERFACES</code>, or their bitwise OR
454          *            (equivalent to <code>CONSIDER_TYPES</code>)
455          * @param multipleSelection
456          *            <code>true</code> if multiple selection is allowed
457          * @return a new selection dialog
458          * @exception JavaModelException
459          *                if the selection dialog could not be opened
460          */
461         // public static SelectionDialog createTypeDialog(Shell parent,
462         // IRunnableContext context, IJavaSearchScope scope, int style, boolean
463         // multipleSelection) throws JavaModelException {
464         // return createTypeDialog(parent, context, scope, style, multipleSelection,
465         // "");//$NON-NLS-1$
466         // }
467         /**
468          * Creates a selection dialog that lists all types in the given scope
469          * containing a standard <code>main</code> method. The caller is
470          * responsible for opening the dialog with <code>Window.open</code>, and
471          * subsequently extracting the selected type(s) (of type <code>IType</code>)
472          * via <code>SelectionDialog.getResult</code>.
473          * 
474          * @param parent
475          *            the parent shell of the dialog to be created
476          * @param context
477          *            the runnable context used to show progress when the dialog is
478          *            being populated
479          * @param scope
480          *            the scope that limits which types are included
481          * @param style
482          *            flags defining the style of the dialog; the only valid values
483          *            are <code>IJavaElementSearchConstants.CONSIDER_BINARIES</code>,
484          *            <code>CONSIDER_EXTERNAL_JARS</code>, or their bitwise OR,
485          *            or <code>0</code>
486          * @param multipleSelection
487          *            <code>true</code> if multiple selection is allowed
488          * @param filter
489          *            the initial pattern to filter the set of types containg a main
490          *            method. For example "App" shows all types starting with "app".
491          *            The meta character '?' representing any character and '*'
492          *            representing any string are supported. Clients can pass an
493          *            empty string if no filtering is required.
494          * @return a new selection dialog
495          * 
496          * @since 2.0
497          */
498         // public static SelectionDialog createMainTypeDialog(Shell parent,
499         // IRunnableContext context, IJavaSearchScope scope, int style, boolean
500         // multipleSelection, String filter) {
501         // if (multipleSelection) {
502         // MultiMainTypeSelectionDialog dialog= new
503         // MultiMainTypeSelectionDialog(parent, context, scope, style);
504         // dialog.setFilter(filter);
505         // return dialog;
506         // } else {
507         // MainTypeSelectionDialog dialog= new MainTypeSelectionDialog(parent,
508         // context, scope, style);
509         // dialog.setFilter(filter);
510         // return dialog;
511         // }
512         // }
513         /**
514          * Creates a selection dialog that lists all types in the given scope
515          * containing a standard <code>main</code> method. The caller is
516          * responsible for opening the dialog with <code>Window.open</code>, and
517          * subsequently extracting the selected type(s) (of type <code>IType</code>)
518          * via <code>SelectionDialog.getResult</code>.
519          * 
520          * @param parent
521          *            the parent shell of the dialog to be created
522          * @param context
523          *            the runnable context used to show progress when the dialog is
524          *            being populated
525          * @param scope
526          *            the scope that limits which types are included
527          * @param style
528          *            flags defining the style of the dialog; the only valid values
529          *            are <code>IJavaElementSearchConstants.CONSIDER_BINARIES</code>,
530          *            <code>CONSIDER_EXTERNAL_JARS</code>, or their bitwise OR,
531          *            or <code>0</code>
532          * @param multipleSelection
533          *            <code>true</code> if multiple selection is allowed
534          * @return a new selection dialog
535          */
536         // public static SelectionDialog createMainTypeDialog(Shell parent,
537         // IRunnableContext context, IJavaSearchScope scope, int style, boolean
538         // multipleSelection) {
539         // return createMainTypeDialog(parent, context, scope, style,
540         // multipleSelection, "");//$NON-NLS-1$
541         // }
542         /**
543          * Creates a selection dialog that lists all types in the given project. The
544          * caller is responsible for opening the dialog with
545          * <code>Window.open</code>, and subsequently extracting the selected
546          * type(s) (of type <code>IType</code>) via
547          * <code>SelectionDialog.getResult</code>.
548          * 
549          * @param parent
550          *            the parent shell of the dialog to be created
551          * @param context
552          *            the runnable context used to show progress when the dialog is
553          *            being populated
554          * @param project
555          *            the Java project
556          * @param style
557          *            flags defining the style of the dialog; the only valid values
558          *            are <code>IJavaElementSearchConstants.CONSIDER_CLASSES</code>,
559          *            <code>CONSIDER_INTERFACES</code>, or their bitwise OR
560          *            (equivalent to <code>CONSIDER_TYPES</code>)
561          * @param multipleSelection
562          *            <code>true</code> if multiple selection is allowed
563          * @return a new selection dialog
564          * @exception JavaModelException
565          *                if the selection dialog could not be opened
566          */
567         // public static SelectionDialog createTypeDialog(Shell parent,
568         // IRunnableContext context, IProject project, int style, boolean
569         // multipleSelection) throws JavaModelException {
570         // IJavaSearchScope scope= SearchEngine.createJavaSearchScope(new
571         // IJavaProject[] { JavaCore.create(project) });
572         // return createTypeDialog(parent, context, scope, style,
573         // multipleSelection);
574         // }
575         /**
576          * Opens a Java editor on the given Java element. The element can be a
577          * compilation unit or class file. If there already is an open Java editor
578          * for the given element, it is returned.
579          * 
580          * @param element
581          *            the input element; either a compilation unit (<code>ICompilationUnit</code>)
582          *            or a class file (</code>IClassFile</code>)
583          * @return the editor, or </code>null</code> if wrong element type or
584          *         opening failed
585          * @exception PartInitException
586          *                if the editor could not be initialized
587          * @exception JavaModelException
588          *                if this element does not exist or if an exception occurs
589          *                while accessing its underlying resource
590          */
591         public static IEditorPart openInEditor(IJavaElement element)
592                         throws JavaModelException, PartInitException {
593                 return EditorUtility.openInEditor(element);
594         }
595
596         /**
597          * Reveals the source range of the given source reference element in the
598          * given editor. No checking is done if the editor displays a compilation
599          * unit or class file that contains the given source reference. The editor
600          * simply reveals the source range denoted by the given source reference.
601          * 
602          * @param part
603          *            the editor displaying the compilation unit or class file
604          * @param element
605          *            the source reference element defining the source range to be
606          *            revealed
607          * 
608          * @deprecated use <code>revealInEditor(IEditorPart, IJavaElement)</code>
609          *             instead
610          */
611         // public static void revealInEditor(IEditorPart part, ISourceReference
612         // element) {
613         // if (element instanceof IJavaElement)
614         // revealInEditor(part, (IJavaElement) element);
615         // }
616         /**
617          * Reveals the given java element in the given editor. If the element is not
618          * an instance of <code>ISourceReference</code> this method result in a
619          * NOP. If it is a source reference no checking is done if the editor
620          * displays a compilation unit or class file that contains the source
621          * reference element. The editor simply reveals the source range denoted by
622          * the given element.
623          * 
624          * @param part
625          *            the editor displaying a compilation unit or class file
626          * @param element
627          *            the element to be revealed
628          * 
629          * @since 2.0
630          */
631         // public static void revealInEditor(IEditorPart part, IJavaElement element)
632         // {
633         // EditorUtility.revealInEditor(part, element);
634         // }
635         /**
636          * Returns the working copy manager for the Java UI plug-in.
637          * 
638          * @return the working copy manager for the Java UI plug-in
639          */
640         public static IWorkingCopyManager getWorkingCopyManager() {
641                 return WebUI.getDefault().getWorkingCopyManager();
642         }
643
644         /**
645          * Answers the shared working copies currently registered for the Java
646          * plug-in. Note that the returned array can include working copies that are
647          * not on the class path of a Java project.
648          * 
649          * @return the list of shared working copies
650          * 
651          * @see net.sourceforge.phpdt.core.JavaCore#getSharedWorkingCopies(net.sourceforge.phpdt.core.IBufferFactory)
652          * @since 2.0
653          */
654         public static IWorkingCopy[] getSharedWorkingCopies() {
655                 return JavaCore.getSharedWorkingCopies(getBufferFactory());
656         }
657
658         /**
659          * Answers the shared working copies that are on the class path of a Java
660          * project currently registered for the Java plug-in.
661          * 
662          * 
663          * @return the list of shared working copies
664          * 
665          * @see #getSharedWorkingCopies()
666          * @since 2.1
667          */
668         // public static IWorkingCopy[] getSharedWorkingCopiesOnClasspath() {
669         // IWorkingCopy[] wcs= getSharedWorkingCopies();
670         // List result= new ArrayList(wcs.length);
671         // for (int i = 0; i < wcs.length; i++) {
672         // IWorkingCopy wc= wcs[i];
673         // if (wc instanceof IJavaElement) {
674         // IJavaElement je= (IJavaElement)wc;
675         // if (je.getJavaProject().isOnClasspath(je)) {
676         // result.add(wc);
677         // }
678         // }
679         // }
680         // return (IWorkingCopy[])result.toArray(new IWorkingCopy[result.size()]);
681         // }
682         /**
683          * Returns the BufferFactory for the Java UI plug-in.
684          * 
685          * @return the BufferFactory for the Java UI plug-in
686          * 
687          * @see net.sourceforge.phpdt.core.IBufferFactory
688          * @since 2.0
689          * @deprecated {@link IBufferFactory} has been replaced by
690          *             {@link net.sourceforge.phpdt.core.WorkingCopyOwner}. The
691          *             Java UI plug-in uses the <i>primary working copy owner</i>
692          *             that can be accessed with <code>null</code> in API's that
693          *             require an owner
694          */
695         public static IBufferFactory getBufferFactory() {
696                 return PHPeclipsePlugin.getDefault().getBufferFactory();
697         }
698
699         /**
700          * Returns the DocumentProvider used for Java compilation units.
701          * 
702          * @return the DocumentProvider for Java compilation units.
703          * 
704          * @see IDocumentProvider
705          * @since 2.0
706          */
707         public static IDocumentProvider getDocumentProvider() {
708                 return WebUI.getDefault()
709                                 .getCompilationUnitDocumentProvider();
710         }
711
712         /**
713          * Sets the Javadoc location for an archive with the given path.
714          * 
715          * @param archivePath
716          *            the path of the library; this can be an workspace path or an
717          *            external path in case of an external library.
718          * @param url
719          *            The Javadoc location to set. This location should contain
720          *            index.html and a file 'package-list'. <code>null</code>
721          *            clears the current documentation location.
722          * 
723          * @since 2.0
724          */
725         // public static void setLibraryJavadocLocation(IPath archivePath, URL url)
726         // {
727         // JavaDocLocations.setLibraryJavadocLocation(archivePath, url);
728         // }
729         /**
730          * Returns the Javadoc location for an archive or <code>null</code> if no
731          * location is available.
732          * 
733          * @param archivePath
734          *            the path of the library. This can be an workspace path or an
735          *            external path in case of an external library.
736          * 
737          * @since 2.0
738          */
739         // public static URL getLibraryJavadocLocation(IPath archivePath) {
740         // return JavaDocLocations.getLibraryJavadocLocation(archivePath);
741         // }
742         /**
743          * Sets the Javadoc location for a Java project. This location is used for
744          * all types located in the project's source folders.
745          * 
746          * @param project
747          *            the project
748          * @param url
749          *            The Javadoc location to set. This location should contain
750          *            index.html and a file 'package-list'. <code>null</code>
751          *            clears the current documentation location.
752          * 
753          * @since 2.1
754          */
755         // public static void setProjectJavadocLocation(IJavaProject project, URL
756         // url) {
757         // JavaDocLocations.setProjectJavadocLocation(project, url);
758         // }
759         /**
760          * Returns the Javadoc location for a Java project or <code>null</code> if
761          * no location is available. This location is used for all types located in
762          * the project's source folders.
763          * 
764          * @param project
765          *            the project
766          * 
767          * @since 2.1
768          */
769         // public static URL getProjectJavadocLocation(IJavaProject project) {
770         // return JavaDocLocations.getProjectJavadocLocation(project);
771         // }
772         /**
773          * Returns the Javadoc base URL for an element. The base location contains
774          * the index file. This location doesn't have to exist. Returns
775          * <code>null</code> if no javadoc location has been attached to the
776          * element's library or project. Example of a returned URL is <i>http://www.
777          * junit. org/junit/javadoc</i>.
778          * 
779          * @param The
780          *            element for which the doc URL is requested.
781          * 
782          * @since 2.0
783          */
784         // public static URL getJavadocBaseLocation(IJavaElement element) throws
785         // JavaModelException {
786         // return JavaDocLocations.getJavadocBaseLocation(element);
787         // }
788         /**
789          * Returns the Javadoc URL for an element. Example of a returned URL is
790          * <i>http://www.junit.org/junit/javadoc/junit/extensions/TestSetup.html</i>.
791          * This returned location doesn't have to exist. Returns <code>null</code>
792          * if no javadoc location has been attached to the element's library or
793          * project.
794          * 
795          * @param The
796          *            element for which the doc URL is requested.
797          * @param includeAnchor
798          *            If set, the URL contains an anchor for member references:
799          *            <i>http://www.junit.org/junit/javadoc/junit/extensions/TestSetup.html#run(junit.framework.TestResult)</i>.
800          *            Note that this involves type resolving and is a more expensive
801          *            call than without anchor.
802          * 
803          * @since 2.0
804          */
805         // public static URL getJavadocLocation(IJavaElement element, boolean
806         // includeAnchor) throws JavaModelException {
807         // return JavaDocLocations.getJavadocLocation(element, includeAnchor);
808         // }
809 }