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