net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/phpeditor/EditorUtility.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
  12 package net.sourceforge.phpeclipse.phpeditor;
  13
  14 import net.sourceforge.phpdt.core.ICompilationUnit;
  15 import net.sourceforge.phpdt.core.IJavaElement;
  16 import net.sourceforge.phpdt.core.IJavaProject;
  17 import net.sourceforge.phpdt.core.IMember;
  18 import net.sourceforge.phpdt.core.IWorkingCopy;
  19 import net.sourceforge.phpdt.core.JavaCore;
  20 import net.sourceforge.phpdt.core.JavaModelException;
  21 import net.sourceforge.phpdt.internal.corext.util.JavaModelUtil;
  22 import net.sourceforge.phpdt.ui.JavaUI;
  23 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  24
  25 import org.eclipse.core.resources.IFile;
  26 import org.eclipse.core.resources.IProject;
  27 import org.eclipse.core.resources.IResource;
  28 import org.eclipse.jface.action.Action;
  29 import org.eclipse.swt.SWT;
  30 import org.eclipse.ui.IEditorDescriptor;
  31 import org.eclipse.ui.IEditorInput;
  32 import org.eclipse.ui.IEditorPart;
  33 import org.eclipse.ui.IEditorRegistry;
  34 import org.eclipse.ui.IFileEditorInput;
  35 import org.eclipse.ui.IWorkbenchPage;
  36 import org.eclipse.ui.PartInitException;
  37 import org.eclipse.ui.PlatformUI;
  38 import org.eclipse.ui.ide.IDE;
  39 import org.eclipse.ui.part.FileEditorInput;
  40 import org.eclipse.ui.texteditor.ITextEditor;
  41
  42 /**
  43  * A number of routines for working with JavaElements in editors
  44  *
  45  * Use 'isOpenInEditor' to test if an element is already open in a editor Use
  46  * 'openInEditor' to force opening an element in a editor With 'getWorkingCopy'
  47  * you get the working copy (element in the editor) of an element
  48  */
  49 public class EditorUtility {
  50
  51 //      public static boolean isEditorInput(Object element, IEditorPart editor) {
  52 //              if (editor != null) {
  53 //                      try {
  54 //                              return editor.getEditorInput().equals(getEditorInput(element));
  55 //                      } catch (JavaModelException x) {
  56 //                              PHPeclipsePlugin.log(x.getStatus());
  57 //                      }
  58 //              }
  59 //              return false;
  60 //      }
  61
  62         /**
  63          * Tests if a cu is currently shown in an editor
  64          *
  65          * @return the IEditorPart if shown, null if element is not open in an
  66          *         editor
  67          */
  68 //      public static IEditorPart isOpenInEditor(Object inputElement) {
  69 //              IEditorInput input = null;
  70 //
  71 //              try {
  72 //                      input = getEditorInput(inputElement);
  73 //              } catch (JavaModelException x) {
  74 //                      PHPeclipsePlugin.log(x.getStatus());
  75 //              }
  76 //
  77 //              if (input != null) {
  78 //                      IWorkbenchPage p = PHPeclipsePlugin.getActivePage();
  79 //                      if (p != null) {
  80 //                              return p.findEditor(input);
  81 //                      }
  82 //              }
  83 //
  84 //              return null;
  85 //      }
  86
  87         /**
  88          * Opens a Java editor for an element such as <code>IJavaElement</code>,
  89          * <code>IFile</code>, or <code>IStorage</code>. The editor is
  90          * activated by default.
  91          *
  92          * @return the IEditorPart or null if wrong element type or opening failed
  93          */
  94         public static IEditorPart openInEditor(Object inputElement)
  95                         throws JavaModelException, PartInitException {
  96                 return openInEditor(inputElement, true);
  97         }
  98
  99         /**
 100          * Opens a Java editor for an element (IJavaElement, IFile, IStorage...)
 101          *
 102          * @return the IEditorPart or null if wrong element type or opening failed
 103          */
 104         public static IEditorPart openInEditor(Object inputElement, boolean activate)
 105                         throws JavaModelException, PartInitException {
 106
 107                 if (inputElement instanceof IFile)
 108                         return openInEditor((IFile) inputElement, activate);
 109
 110                 IEditorInput input = getEditorInput(inputElement);
 111                 if (input instanceof IFileEditorInput) {
 112                         IFileEditorInput fileInput = (IFileEditorInput) input;
 113                         return openInEditor(fileInput.getFile(), activate);
 114                 }
 115
 116                 if (input != null)
 117                         return openInEditor(input, getEditorID(input, inputElement),
 118                                         activate);
 119
 120                 return null;
 121         }
 122
 123         /**
 124          * Selects a Java Element in an editor
 125          */
 126         public static void revealInEditor(IEditorPart part, IJavaElement element) {
 127                 if (element != null && part instanceof PHPEditor) {
 128                         ((PHPEditor) part).setSelection(element);
 129                 }
 130         }
 131
 132         private static IEditorPart openInEditor(IFile file, boolean activate)
 133                         throws PartInitException {
 134                 if (file != null) {
 135                         IWorkbenchPage p = PHPeclipsePlugin.getActivePage();
 136                         if (p != null) {
 137                                 IEditorPart editorPart = IDE.openEditor(p, file, activate);
 138                                 initializeHighlightRange(editorPart);
 139                                 return editorPart;
 140                         }
 141                 }
 142                 return null;
 143         }
 144
 145         private static IEditorPart openInEditor(IEditorInput input,
 146                         String editorID, boolean activate) throws PartInitException {
 147                 if (input != null) {
 148                         IWorkbenchPage p = PHPeclipsePlugin.getActivePage();
 149                         if (p != null) {
 150                                 IEditorPart editorPart = p
 151                                                 .openEditor(input, editorID, activate);
 152                                 initializeHighlightRange(editorPart);
 153                                 return editorPart;
 154                         }
 155                 }
 156                 return null;
 157         }
 158
 159         private static void initializeHighlightRange(IEditorPart editorPart) {
 160                 if (editorPart instanceof ITextEditor) {
 161                         TogglePresentationAction toggleAction = new TogglePresentationAction();
 162                         // Initialize editor
 163                         toggleAction.setEditor((ITextEditor) editorPart);
 164                         // Reset action
 165                         toggleAction.setEditor(null);
 166                 }
 167         }
 168
 169         /**
 170          * @deprecated Made it public again for java debugger UI.
 171          */
 172         public static String getEditorID(IEditorInput input, Object inputObject) {
 173                 IEditorRegistry registry = PlatformUI.getWorkbench()
 174                                 .getEditorRegistry();
 175                 IEditorDescriptor descriptor = registry.getDefaultEditor(input
 176                                 .getName());
 177                 if (descriptor != null)
 178                         return descriptor.getId();
 179                 return null;
 180         }
 181
 182         private static IEditorInput getEditorInput(IJavaElement element)
 183                         throws JavaModelException {
 184                 while (element != null) {
 185                         if (element instanceof IWorkingCopy
 186                                         && ((IWorkingCopy) element).isWorkingCopy())
 187                                 element = ((IWorkingCopy) element).getOriginalElement();
 188
 189                         if (element instanceof ICompilationUnit) {
 190                                 ICompilationUnit unit = (ICompilationUnit) element;
 191                                 IResource resource = unit.getResource();
 192                                 if (resource instanceof IFile)
 193                                         return new FileEditorInput((IFile) resource);
 194                         }
 195
 196                         // if (element instanceof IClassFile)
 197                         // return new InternalClassFileEditorInput((IClassFile) element);
 198                         //
 199                         element = element.getParent();
 200                 }
 201
 202                 return null;
 203         }
 204
 205         public static IEditorInput getEditorInput(Object input)
 206                         throws JavaModelException {
 207
 208                 if (input instanceof IJavaElement)
 209                         return getEditorInput((IJavaElement) input);
 210
 211                 if (input instanceof IFile)
 212                         return new FileEditorInput((IFile) input);
 213
 214                 // if (input instanceof IStorage)
 215                 // return new JarEntryEditorInput((IStorage)input);
 216
 217                 return null;
 218         }
 219
 220         /**
 221          * If the current active editor edits a java element return it, else return
 222          * null
 223          */
 224 //      public static IJavaElement getActiveEditorJavaInput() {
 225 //              IWorkbenchPage page = PHPeclipsePlugin.getActivePage();
 226 //              if (page != null) {
 227 //                      IEditorPart part = page.getActiveEditor();
 228 //                      if (part != null) {
 229 //                              IEditorInput editorInput = part.getEditorInput();
 230 //                              if (editorInput != null) {
 231 //                                      return (IJavaElement) editorInput
 232 //                                                      .getAdapter(IJavaElement.class);
 233 //                              }
 234 //                      }
 235 //              }
 236 //              return null;
 237 //      }
 238
 239         /**
 240          * Gets the working copy of an compilation unit opened in an editor
 241          *
 242          * @param part
 243          *            the editor part
 244          * @param cu
 245          *            the original compilation unit (or another working copy)
 246          * @return the working copy of the compilation unit, or null if not found
 247          */
 248         public static ICompilationUnit getWorkingCopy(ICompilationUnit cu) {
 249                 if (cu == null)
 250                         return null;
 251                 if (cu.isWorkingCopy())
 252                         return cu;
 253
 254                 return (ICompilationUnit) cu.findSharedWorkingCopy(JavaUI
 255                                 .getBufferFactory());
 256         }
 257
 258         /**
 259          * Gets the working copy of an member opened in an editor
 260          *
 261          * @param member
 262          *            the original member or a member in a working copy
 263          * @return the corresponding member in the shared working copy or
 264          *         <code>null</code> if not found
 265          */
 266 //      public static IMember getWorkingCopy(IMember member)
 267 //                      throws JavaModelException {
 268 //              ICompilationUnit cu = member.getCompilationUnit();
 269 //              if (cu != null) {
 270 //                      ICompilationUnit workingCopy = getWorkingCopy(cu);
 271 //                      if (workingCopy != null) {
 272 //                              return JavaModelUtil.findMemberInCompilationUnit(workingCopy,
 273 //                                              member);
 274 //                      }
 275 //              }
 276 //              return null;
 277 //      }
 278
 279         /**
 280          * Returns the compilation unit for the given java element.
 281          *
 282          * @param element
 283          *            the java element whose compilation unit is searched for
 284          * @return the compilation unit of the given java element
 285          */
 286         private static ICompilationUnit getCompilationUnit(IJavaElement element) {
 287
 288                 if (element == null)
 289                         return null;
 290
 291                 if (element instanceof IMember)
 292                         return ((IMember) element).getCompilationUnit();
 293
 294                 int type = element.getElementType();
 295                 if (IJavaElement.COMPILATION_UNIT == type)
 296                         return (ICompilationUnit) element;
 297                 if (IJavaElement.CLASS_FILE == type)
 298                         return null;
 299
 300                 return getCompilationUnit(element.getParent());
 301         }
 302
 303         /**
 304          * Returns the working copy of the given java element.
 305          *
 306          * @param javaElement
 307          *            the javaElement for which the working copyshould be found
 308          * @param reconcile
 309          *            indicates whether the working copy must be reconcile prior to
 310          *            searching it
 311          * @return the working copy of the given element or <code>null</code> if
 312          *         none
 313          */
 314         public static IJavaElement getWorkingCopy(IJavaElement element,
 315                         boolean reconcile) throws JavaModelException {
 316                 ICompilationUnit unit = getCompilationUnit(element);
 317                 if (unit == null)
 318                         return null;
 319
 320                 if (unit.isWorkingCopy())
 321                         return element;
 322
 323                 ICompilationUnit workingCopy = getWorkingCopy(unit);
 324                 if (workingCopy != null) {
 325                         if (reconcile) {
 326                                 synchronized (workingCopy) {
 327                                         workingCopy.reconcile();
 328                                         return JavaModelUtil.findInCompilationUnit(workingCopy,
 329                                                         element);
 330                                 }
 331                         } else {
 332                                 return JavaModelUtil
 333                                                 .findInCompilationUnit(workingCopy, element);
 334                         }
 335                 }
 336
 337                 return null;
 338         }
 339
 340         /**
 341          * Maps the localized modifier name to a code in the same manner as
 342          * #findModifier.
 343          *
 344          * @return the SWT modifier bit, or <code>0</code> if no match was found
 345          * @see findModifier
 346          * @since 2.1.1
 347          */
 348         public static int findLocalizedModifier(String token) {
 349                 if (token == null)
 350                         return 0;
 351
 352                 if (token.equalsIgnoreCase(Action.findModifierString(SWT.CTRL)))
 353                         return SWT.CTRL;
 354                 if (token.equalsIgnoreCase(Action.findModifierString(SWT.SHIFT)))
 355                         return SWT.SHIFT;
 356                 if (token.equalsIgnoreCase(Action.findModifierString(SWT.ALT)))
 357                         return SWT.ALT;
 358                 if (token.equalsIgnoreCase(Action.findModifierString(SWT.COMMAND)))
 359                         return SWT.COMMAND;
 360
 361                 return 0;
 362         }
 363
 364         /**
 365          * Returns the modifier string for the given SWT modifier modifier bits.
 366          *
 367          * @param stateMask
 368          *            the SWT modifier bits
 369          * @return the modifier string
 370          * @since 2.1.1
 371          */
 372         public static String getModifierString(int stateMask) {
 373                 String modifierString = ""; //$NON-NLS-1$
 374                 if ((stateMask & SWT.CTRL) == SWT.CTRL)
 375                         modifierString = appendModifierString(modifierString, SWT.CTRL);
 376                 if ((stateMask & SWT.ALT) == SWT.ALT)
 377                         modifierString = appendModifierString(modifierString, SWT.ALT);
 378                 if ((stateMask & SWT.SHIFT) == SWT.SHIFT)
 379                         modifierString = appendModifierString(modifierString, SWT.SHIFT);
 380                 if ((stateMask & SWT.COMMAND) == SWT.COMMAND)
 381                         modifierString = appendModifierString(modifierString, SWT.COMMAND);
 382
 383                 return modifierString;
 384         }
 385
 386         /**
 387          * Appends to modifier string of the given SWT modifier bit to the given
 388          * modifierString.
 389          *
 390          * @param modifierString
 391          *            the modifier string
 392          * @param modifier
 393          *            an int with SWT modifier bit
 394          * @return the concatenated modifier string
 395          * @since 2.1.1
 396          */
 397         private static String appendModifierString(String modifierString,
 398                         int modifier) {
 399                 if (modifierString == null)
 400                         modifierString = ""; //$NON-NLS-1$
 401                 String newModifierString = Action.findModifierString(modifier);
 402                 if (modifierString.length() == 0)
 403                         return newModifierString;
 404                 return PHPEditorMessages
 405                                 .getFormattedString(
 406                                                 "EditorUtility.concatModifierStrings", new String[] { modifierString, newModifierString }); //$NON-NLS-1$
 407         }
 408
 409         /**
 410          * Returns the Java project for a given editor input or <code>null</code>
 411          * if no corresponding Java project exists.
 412          *
 413          * @param input
 414          *            the editor input
 415          * @return the corresponding Java project
 416          *
 417          * @since 3.0
 418          */
 419         public static IJavaProject getJavaProject(IEditorInput input) {
 420                 IJavaProject jProject = null;
 421                 if (input instanceof IFileEditorInput) {
 422                         IProject project = ((IFileEditorInput) input).getFile()
 423                                         .getProject();
 424                         if (project != null) {
 425                                 jProject = JavaCore.create(project);
 426                                 if (!jProject.exists())
 427                                         jProject = null;
 428                         }
 429                 }
 430                 // else if (input instanceof IClassFileEditorInput) {
 431                 // jProject=
 432                 // ((IClassFileEditorInput)input).getClassFile().getJavaProject();
 433                 // }
 434                 return jProject;
 435         }
 436 }