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