| /******************************************************************************* |
| * Copyright (c) 2010 BSI Business Systems Integration AG. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * BSI Business Systems Integration AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.scout.sdk.ui.util; |
| |
| import java.net.URI; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.URIUtil; |
| import org.eclipse.jdt.core.Flags; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IPackageFragment; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility; |
| import org.eclipse.jdt.internal.ui.viewsupport.JavaElementImageProvider; |
| import org.eclipse.jdt.ui.JavaElementImageDescriptor; |
| import org.eclipse.jdt.ui.JavaUI; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.scout.commons.StringUtility; |
| import org.eclipse.scout.sdk.jdt.compile.ScoutSeverityManager; |
| import org.eclipse.scout.sdk.ui.internal.ScoutSdkUi; |
| import org.eclipse.scout.sdk.ui.view.outline.pages.IPage; |
| import org.eclipse.scout.sdk.ui.view.outline.pages.ITypePage; |
| import org.eclipse.scout.sdk.util.resources.ResourceUtility; |
| import org.eclipse.scout.sdk.util.type.ITypeFilter; |
| import org.eclipse.scout.sdk.util.type.TypeUtility; |
| import org.eclipse.scout.sdk.workspace.IScoutBundle; |
| import org.eclipse.scout.sdk.workspace.IScoutBundleFilter; |
| import org.eclipse.scout.sdk.workspace.ScoutBundleFilters; |
| import org.eclipse.scout.sdk.workspace.type.ScoutTypeUtility; |
| import org.eclipse.swt.graphics.Drawable; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IURIEditorInput; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.texteditor.ITextEditor; |
| |
| /** |
| * <h3>{@link UiUtility}</h3> |
| * |
| * @author Andreas Hoegger |
| * @since 1.0.8 07.03.2011 |
| */ |
| @SuppressWarnings("restriction") |
| public final class UiUtility { |
| |
| private UiUtility() { |
| } |
| |
| /** |
| * Shows the given java element in the java editor. |
| * |
| * @param e |
| * The element to focus |
| * @param createNew |
| * indicates if a new editor should be opened if not open yet. If false, the element will only be shown if |
| * there is a java editor open yet. |
| */ |
| public static void showJavaElementInEditor(IJavaElement e, boolean createNew) { |
| try { |
| IEditorPart editor = null; |
| if (createNew) { |
| editor = JavaUI.openInEditor(e); |
| } |
| else { |
| editor = EditorUtility.isOpenInEditor(e); |
| if (editor != null) { |
| PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().activate(editor); |
| } |
| } |
| if (editor != null) { |
| JavaUI.revealInEditor(editor, e); |
| if (editor instanceof ITextEditor) { |
| ITextEditor textEditor = (ITextEditor) editor; |
| IRegion reg = textEditor.getHighlightRange(); |
| if (reg != null) { |
| textEditor.setHighlightRange(reg.getOffset(), reg.getLength(), true); |
| } |
| } |
| } |
| } |
| catch (Exception ex) { |
| ScoutSdkUi.logWarning(ex); |
| } |
| } |
| |
| /** |
| * Returns the extent of the given string. No tab |
| * expansion or carriage return processing will be performed. |
| * <p> |
| * The <em>extent</em> of a string is the width and height of the rectangular area it would cover if drawn in the |
| * given font. |
| * </p> |
| * |
| * @param text |
| * @param f |
| * @param context |
| * @return a point containing the extent of the string |
| */ |
| public static Point getTextBounds(String text, Font f, Drawable context) { |
| GC gc = new GC(context); |
| gc.setFont(f); |
| return gc.stringExtent(text); |
| } |
| |
| /** |
| * Gets the shortened text based on the given input so that the text returned is smaller than the given bounds. |
| * |
| * @param origText |
| * The original text that should be shortened to match into bounds. |
| * @param f |
| * The {@link Font} to use to calculate the text length. |
| * @param context |
| * The context in which the calculation should be performed. |
| * @param bounds |
| * The number of pixels. The returned text will be shorter than this limit if rendered in the given context |
| * with the given font. |
| * @return The text shortened to given bounds including an ellipsis if it has been cut. |
| */ |
| public static String getTextForBounds(String origText, Font f, Drawable context, int bounds) { |
| return getTextForBounds(origText, f, context, bounds, "…"); |
| } |
| |
| /** |
| * Gets the shortened text based on the given input so that the text returned is smaller than the given bounds. |
| * |
| * @param origText |
| * The original text that should be shortened to match into bounds. |
| * @param f |
| * The {@link Font} to use to calculate the text length. |
| * @param context |
| * The context in which the calculation should be performed. |
| * @param bounds |
| * The number of pixels. The returned text will be shorter than this limit if rendered in the given context |
| * with the given font. |
| * @param ellipsis |
| * The suffix to add if the given origText has been shortened or null if no suffix should be added. |
| * @return The text shortened to given bounds including the given ellipsis if it has been cut. |
| */ |
| public static String getTextForBounds(String origText, Font f, Drawable context, int bounds, String ellipsis) { |
| if (bounds <= 0) { |
| return origText; |
| } |
| |
| String cleanedEllipsis = null; |
| if (StringUtility.hasText(ellipsis)) { |
| cleanedEllipsis = ellipsis; |
| } |
| else { |
| cleanedEllipsis = ""; |
| } |
| StringBuilder sb = new StringBuilder(origText); |
| GC gc = new GC(context); |
| gc.setFont(f); |
| |
| Point p = gc.stringExtent(sb.toString()); |
| while (p.x > bounds && sb.length() > 0) { |
| sb.deleteCharAt(sb.length() - 1); |
| p = gc.stringExtent(sb.toString() + cleanedEllipsis); |
| } |
| |
| String ret = sb.toString(); |
| if (ret.equals(origText)) { |
| return origText; |
| } |
| else { |
| return sb.toString() + cleanedEllipsis; |
| } |
| } |
| |
| /** |
| * Gets the packages suffix of the given selection.<br> |
| * This method calculates the java package that surrounds the current selection and returns the suffix (the package |
| * part after the symbolic name of the containing bundle). |
| * |
| * @param selection |
| * The selection to evaluate |
| * @return A string with the package suffix or null. |
| */ |
| public static String getPackageSuffix(IStructuredSelection selection) { |
| if (selection == null) { |
| return null; |
| } |
| return getPackageSuffix(UiUtility.adapt(selection.getFirstElement(), IJavaElement.class)); |
| } |
| |
| /** |
| * Gets the packages suffix of the given element.<br> |
| * This method calculates the java package that surrounds the given element and returns the suffix (the package |
| * part after the symbolic name of the containing bundle). |
| * |
| * @param element |
| * The element |
| * @return A string with the package suffix or null. |
| */ |
| public static String getPackageSuffix(IJavaElement element) { |
| if (TypeUtility.exists(element)) { |
| IPackageFragment targetPackage = (IPackageFragment) element.getAncestor(IJavaElement.PACKAGE_FRAGMENT); |
| if (TypeUtility.exists(targetPackage)) { |
| String pck = targetPackage.getElementName(); |
| IScoutBundle declaringBundle = ScoutTypeUtility.getScoutBundle(targetPackage); |
| if (declaringBundle != null && pck.startsWith(declaringBundle.getSymbolicName()) && pck.length() > declaringBundle.getSymbolicName().length()) { |
| return pck.substring(declaringBundle.getSymbolicName().length() + 1); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Closes all open instances of the given editor.<br> |
| * If the editors are dirty, the user is asked if they should be saved. |
| * |
| * @param editorId |
| * The editor id filter or null if all editors should be closed. |
| * @param files |
| * The files filter or null. Only the editors of those files are closed. |
| * @return true if all editors have been closed. false otherwise (e.g. when the user presses cancel in the save dirty |
| * editor confirmation message box). |
| */ |
| public static boolean closeEditors(String editorId, Set<IFile> files) { |
| for (IWorkbenchWindow w : PlatformUI.getWorkbench().getWorkbenchWindows()) { |
| for (IWorkbenchPage p : w.getPages()) { |
| IEditorReference[] editorReferences = p.getEditorReferences(); |
| List<IEditorReference> partsToSave = new ArrayList<IEditorReference>(editorReferences.length); |
| for (IEditorReference r : editorReferences) { |
| if (editorId == null || editorId.equals(r.getId())) { |
| if (files == null || files.isEmpty() || isEditorInputInFiles(r, files)) { |
| partsToSave.add(r); |
| } |
| } |
| } |
| if (!partsToSave.isEmpty()) { |
| boolean success = p.closeEditors(partsToSave.toArray(new IEditorReference[partsToSave.size()]), true); |
| if (!success) { |
| return false; |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| private static boolean isEditorInputInFiles(IEditorReference ref, Set<IFile> files) { |
| try { |
| IEditorInput editorInput = ref.getEditorInput(); |
| if (editorInput instanceof IURIEditorInput) { |
| IURIEditorInput input = (IURIEditorInput) editorInput; |
| URI uriToSearch = input.getURI(); |
| for (IFile f : files) { |
| if (URIUtil.sameURI(uriToSearch, f.getLocationURI())) { |
| return true; |
| } |
| } |
| } |
| } |
| catch (PartInitException e) { |
| ScoutSdkUi.logError("Unable to get file input of editor.", e); |
| } |
| return false; |
| } |
| |
| /** |
| * Tries to calculate the most specific scout bundle that contains the given selection. |
| * |
| * @param selection |
| * @return |
| */ |
| public static IScoutBundle getScoutBundleFromSelection(IStructuredSelection selection) { |
| return getScoutBundleFromSelection(selection, null); |
| } |
| |
| /** |
| * Tries to calculate the most specific scout bundle that contains the given selection. |
| * The given filter is taken into account so that clients can influence which types of scout bundles around the |
| * selected one that should be used.<br> |
| * |
| * @param selection |
| * @param filter |
| * @return |
| */ |
| public static IScoutBundle getScoutBundleFromSelection(IStructuredSelection selection, IScoutBundleFilter filter) { |
| if (selection != null) { |
| IScoutBundle b = UiUtility.adapt(selection.getFirstElement(), IScoutBundle.class); |
| if (b != null) { |
| if (filter == null || filter.accept(b)) { |
| return b; |
| } |
| else { |
| IScoutBundle parentShared = b.getParentBundle(ScoutBundleFilters.getBundlesOfTypeFilter(IScoutBundle.TYPE_SHARED), b, true); |
| if (parentShared != null) { |
| IScoutBundle candidate = parentShared.getChildBundle(ScoutBundleFilters.getMultiFilterAnd(ScoutBundleFilters.getWorkspaceBundlesFilter(), filter), b, true); |
| if (candidate != null) { |
| return candidate; |
| } |
| } |
| else { |
| IScoutBundle candidate = b.getChildBundle(ScoutBundleFilters.getMultiFilterAnd(ScoutBundleFilters.getWorkspaceBundlesFilter(), filter), b, false); |
| if (candidate != null) { |
| return candidate; |
| } |
| } |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| public static IType getTypeFromSelection(IStructuredSelection selection) { |
| return getTypeFromSelection(selection, null); |
| } |
| |
| public static IType getTypeFromSelection(IStructuredSelection selection, ITypeFilter filter) { |
| return getTypeFromSelection(selection.getFirstElement(), filter); |
| } |
| |
| private static IType getTypeFromSelection(Object o, ITypeFilter filter) { |
| IType t = UiUtility.adapt(o, IType.class); |
| if (TypeUtility.exists(t) && (filter == null || filter.accept(t))) { |
| return t; |
| } |
| return null; |
| } |
| |
| public static Set<IType> getTypesFromSelection(IStructuredSelection selection, ITypeFilter filter) { |
| Set<IType> result = new LinkedHashSet<IType>(selection.size()); |
| if (selection.isEmpty()) { |
| return result; |
| } |
| |
| Iterator<?> it = selection.iterator(); |
| while (it.hasNext()) { |
| Object o = it.next(); |
| IType t = getTypeFromSelection(o, filter); |
| if (t != null) { |
| result.add(t); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Tries to convert the given element into the given class. |
| * This method respects scout IPage classes. |
| * |
| * @param element |
| * The element to convert. |
| * @param targetClass |
| * The class in which it should be converted. |
| * @return the converted element or null if the conversion could not be done. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> T adapt(Object element, Class<T> targetClass) { |
| if (element == null || targetClass == null) { |
| return null; |
| } |
| if (targetClass.isInstance(element)) { |
| return (T) element; |
| } |
| |
| // get element out of the pages |
| if (element instanceof IPage) { |
| IPage page = (IPage) element; |
| IScoutBundle sb = page.getScoutBundle(); |
| if (sb != null) { |
| element = sb; |
| } |
| |
| do { |
| if (page instanceof ITypePage) { |
| ITypePage astp = (ITypePage) page; |
| IType t = astp.getType(); |
| if (TypeUtility.exists(t)) { |
| element = t; |
| break; |
| } |
| } |
| page = page.getParent(); |
| } |
| while (page != null); |
| } |
| |
| // try to adapt |
| if (element instanceof IAdaptable) { |
| IAdaptable ad = (IAdaptable) element; |
| T result = (T) ad.getAdapter(targetClass); |
| if (result == null) { |
| // try to get a resource |
| IResource r = (IResource) ad.getAdapter(IResource.class); |
| if (!ResourceUtility.exists(r)) { |
| IJavaElement je = (IJavaElement) ad.getAdapter(IJavaElement.class); |
| if (TypeUtility.exists(je)) { |
| r = je.getResource(); |
| } |
| } |
| |
| if (ResourceUtility.exists(r)) { |
| // try to convert from a resource |
| result = (T) r.getAdapter(targetClass); |
| } |
| } |
| return result; |
| } |
| return null; |
| } |
| |
| /** |
| * Gets an image descriptor for classes.<br> |
| * The image descriptor includes flags like abstract, final, static, deprecated. Furthermore it shows different icons |
| * for interfaces and classes and includes the severity flags of the classes (e.g. error or warning). |
| * |
| * @param type |
| * The type for which the icon should be returned. |
| * @return The image descriptor. |
| */ |
| public static ImageDescriptor getTypeImageDescriptor(IType type) { |
| return getTypeImageDescriptor(type, true); |
| } |
| |
| public static ImageDescriptor getTypeImageDescriptor(IType type, boolean showSeverity) { |
| int flags = -1; |
| try { |
| flags = type.getFlags(); |
| } |
| catch (JavaModelException e) { |
| } |
| |
| boolean isInterface = Flags.isInterface(flags); |
| boolean isInner = TypeUtility.exists(type.getDeclaringType()); |
| int severity = 0; |
| if (showSeverity) { |
| ScoutSeverityManager.getInstance().getSeverityOf(type); |
| } |
| ImageDescriptor desc = JavaElementImageProvider.getTypeImageDescriptor(isInner, isInterface, flags, false); |
| |
| int adornmentFlags = 0; |
| if (Flags.isFinal(flags)) { |
| adornmentFlags |= JavaElementImageDescriptor.FINAL; |
| } |
| if (Flags.isAbstract(flags) && !isInterface) { |
| adornmentFlags |= JavaElementImageDescriptor.ABSTRACT; |
| } |
| if (Flags.isStatic(flags)) { |
| adornmentFlags |= JavaElementImageDescriptor.STATIC; |
| } |
| if (Flags.isDeprecated(flags)) { |
| adornmentFlags |= JavaElementImageDescriptor.DEPRECATED; |
| } |
| |
| if (severity == IMarker.SEVERITY_ERROR) { |
| adornmentFlags |= JavaElementImageDescriptor.ERROR; |
| } |
| else if (severity == IMarker.SEVERITY_WARNING) { |
| adornmentFlags |= JavaElementImageDescriptor.WARNING; |
| } |
| |
| return new JavaElementImageDescriptor(desc, adornmentFlags, JavaElementImageProvider.BIG_SIZE); |
| } |
| } |
