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