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