Java 类org.eclipse.jface.viewers.DecorationOverlayIcon 实例源码

@Override
public Image getTitleImage() {
    Image image = super.getTitleImage();
    try {
        IEditorInput input = getEditorInput();
        IResource file = ResourceUtil.getResource(input);
        if (input.exists() && file != null
                && file.findMarkers(MARKER.ERROR, false, IResource.DEPTH_ZERO).length > 0) {
            if (errorTitleImage == null) {
                errorTitleImage = new DecorationOverlayIcon(image,
                        PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(
                                ISharedImages.IMG_DEC_FIELD_ERROR), IDecoration.BOTTOM_LEFT)
                        .createImage();
            }
            return errorTitleImage;
        }
    } catch (CoreException e) {
        Log.log(e);
    }
    return image;
}

@Override
public Image decorateImage(Image image, Object element)
{
    OutlineNode node = (OutlineNode) element;
    Image result = null;
    switch (node.getType())
    {
    case CATEGORY:
        DecorationOverlayIcon icon = new DecorationOverlayIcon(image,
                m_categoryImage, IDecoration.BOTTOM_RIGHT);
        result = icon.createImage();
        break;
    default:
        break;
    }

    return result;
}

private Image getInstalledBreakpointImage(BfBreakpoint breakpoint) {
    ImageDescriptor defaultImageDescriptor = DebugUITools.getDefaultImageDescriptor(breakpoint);
    if (this.overlayedImages.containsKey(defaultImageDescriptor)) {
        return this.overlayedImages.get(defaultImageDescriptor);
    }
    try {
        ImageDescriptor overlay = ImageDescriptor.createFromURL(new URL("platform:/plugin/org.eclipse.ui.ide/icons/full/obj16/header_complete.png"));
        Image defaultImage = defaultImageDescriptor.createImage();
        this.disposeImages.add(defaultImage);
        ImageDescriptor overlayedDescriptor = new DecorationOverlayIcon(defaultImage, overlay, IDecoration.BOTTOM_LEFT);
        Image overlayedImage = overlayedDescriptor.createImage();
        this.disposeImages.add(overlayedImage);
        this.overlayedImages.put(defaultImageDescriptor, overlayedImage);
        return overlayedImage;
    } 
    catch (MalformedURLException ex) {
        DbgActivator.getDefault().logError("URL malformed", ex);
        return null;
    }
}

@Override
protected void updateEditorImage(final XtextEditor editor) {
    Severity severity = null;
    //
    // try {
    severity = getSeverity(editor);
    //
    // } catch (ResourceException e) {
    // // do nothing, emitted when a marker cannot be found
    // }
    ImageDescriptor descriptor = null;
    if (severity == null || severity == Severity.INFO) {
        descriptor = GamaIcons.create(IGamaIcons.OVERLAY_OK).descriptor();
    } else if (severity == Severity.ERROR) {
        descriptor = GamaIcons.create("overlay.error2").descriptor();
    } else if (severity == Severity.WARNING) {
        descriptor = GamaIcons.create("overlay.warning2").descriptor();
    } else {
        super.updateEditorImage(editor);
        return;
    }
    final DecorationOverlayIcon decorationOverlayIcon = new DecorationOverlayIcon(editor.getDefaultImage(),
            descriptor, IDecoration.BOTTOM_LEFT);
    scheduleUpdateEditor(decorationOverlayIcon);

}

public Image decorateImage(Image image, Object element)
{
    Image result = null;

    if (image != null && element instanceof PropertyElement)
    {
        PropertyElement property = (PropertyElement) element;

        if (property.isClassProperty())
        {
            DecorationOverlayIcon decorator = new DecorationOverlayIcon(image, STATIC_OVERLAY,
                    IDecoration.TOP_RIGHT);

            result = decorator.createImage();
        }
    }

    return result;
}

@Override
public Image decorateImage(Image image, Object element) {
    if (element instanceof EPlanElement) {
        int severity = EPlanUtils.getSeverity(element);

        if (severity == IMarker.SEVERITY_ERROR) {
            return new DecorationOverlayIcon(image, errorImageDescriptor, quadrant).createImage();
        }

        else if (severity == MarkerConstants.SEVERITY_FIXED) {
            return new DecorationOverlayIcon(image, fixedImageDescriptor, quadrant).createImage();
        }

        else if (severity == IMarker.SEVERITY_WARNING) {
            return new DecorationOverlayIcon(image, warningImageDescriptor, quadrant).createImage();
        }

        else if (severity == MarkerConstants.SEVERITY_WAIVED) {
            return new DecorationOverlayIcon(image, waivedImageDescriptor, quadrant).createImage();
        }

    }

    return image;
}

@Override
public Image decorateImage(Image image, Object element) {
    if (image!=null) {
        if (element instanceof IProject) {
            IProject project = (IProject) element;
            boolean b = GW4ENature.hasGW4ENature(project);
            if (b) {
                DecorationOverlayIcon icon = new DecorationOverlayIcon(image, GW_DESCRIPTOR, IDecoration.TOP_LEFT);
                Image ret = (Image)resourceManager.get(icon);
                return ret;
            }
        }
    }
    return image;
}

@Override
@SuppressWarnings("PMD.AvoidDeeplyNestedIfStmts")
public Image getImage(final Object element) {
  Image image = super.getImage(element);
  if (image != null) {
    Pair<Object, Integer> decoration = getDecoration(element);
    if (decoration != null && decoration.getFirst() != null) {
      Image overlay = convertToImage(decoration.getFirst());
      if (overlay != null) {
        image = new DecorationOverlayIcon(image, ImageDescriptor.createFromImage(overlay), decoration.getSecond()).createImage();
      }
    }
  }
  return image;
}

/** {@inheritDoc} */
@Override
public Image getImage() {
  if (isOptional()) {
    // No decoration
    return getUndecoratedImage();
  } else {
    final ImageDescriptor[] descriptors = new ImageDescriptor[ValidPreferenceConstants.DECORATION_QUADRANTS_COUNT];
    descriptors[IDecoration.BOTTOM_RIGHT] = ValidPreferenceConstants.LOCK_OVERLAY_IMAGE_DESCRIPTOR;
    // Overlay custom image over base image
    return getImageManager().createImage(new DecorationOverlayIcon(getUndecoratedImage(), descriptors));
  }
}

/** {@inheritDoc} */
@Override
public Image getImage() {
  final Image categoryImage = getUndecoratedImage();
  if (hasRules() && hasOnlyMandatoryRules()) {
    final ImageDescriptor[] descriptors = new ImageDescriptor[ValidPreferenceConstants.DECORATION_QUADRANTS_COUNT];
    descriptors[IDecoration.BOTTOM_RIGHT] = ValidPreferenceConstants.LOCK_OVERLAY_IMAGE_DESCRIPTOR;
    // Overlay custom image over base image
    return getImageManager().createImage(new DecorationOverlayIcon(categoryImage, descriptors));
  } else {
    // No decoration
    return categoryImage;
  }
}

public static Image getDecoratedImage(Image baseImage, int severity) {
    initializeIfNeeded();
    String baseImageId = baseImage.toString();
    // Construct a new image identifier
    String decoratedImageId = baseImageId.concat(String.valueOf(severity));
    ImageDescriptor overlay = null;
    switch (severity) {
    case IStatus.ERROR:
        overlay = PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_DEC_FIELD_ERROR);
        break;
    case IStatus.WARNING:
        overlay = PlatformUI.getWorkbench().getSharedImages()
                .getImageDescriptor(ISharedImages.IMG_DEC_FIELD_WARNING);
        break;
    default:
        return baseImage;
    }
    // Return the stored image if we have one
    Image image = imageRegistry.get(decoratedImageId);
    if (image != null) {
        return image;
    }
    // Otherwise create a new image and store it
    DecorationOverlayIcon decoratedImage = new DecorationOverlayIcon(baseImage,
            new ImageDescriptor[] { null, null, null, overlay, null }, size) {
    };
    imageRegistry.put(decoratedImageId, decoratedImage);
    return imageRegistry.get(decoratedImageId);
}

protected void updateEditorImage(XtextEditor xtextEditor) {
    Severity severity = getSeverity(xtextEditor);
    if (severity != null && severity != Severity.INFO) {
        ImageDescriptor descriptor = severity == Severity.ERROR ? XtextPluginImages.DESC_OVR_ERROR
                : XtextPluginImages.DESC_OVR_WARNING;
        DecorationOverlayIcon decorationOverlayIcon = new DecorationOverlayIcon(defaultImage, descriptor,
                IDecoration.BOTTOM_LEFT);
        scheduleUpdateEditor(decorationOverlayIcon);
    } else {
        scheduleUpdateEditor(defaultImage);
    }
}

private Image decorateImage( Image image ) {
  Image result = null;
  if( image != null ) {
    ImageDescriptor imageDescriptor = Images.getImageDescriptor( RUNNING );
    DecorationOverlayIcon overlay = new DecorationOverlayIcon( image, imageDescriptor, BOTTOM_RIGHT );
    result = resourceManager.createImage( overlay );
  }
  return result;
}

private Image getDebugTargetWarningImage(BfDebugTarget debugTarget) {
    ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages();
    ImageDescriptor warningOverlay = sharedImages.getImageDescriptor(ISharedImages.IMG_DEC_FIELD_WARNING);
    ImageDescriptor targetDescriptor = DebugUITools.getDefaultImageDescriptor(debugTarget);
    if (this.overlayedImages.containsKey(targetDescriptor)) {
        return this.overlayedImages.get(targetDescriptor);
    }
    Image targetImage = targetDescriptor.createImage();
    this.disposeImages.add(targetImage);
    ImageDescriptor all = new DecorationOverlayIcon(targetImage, warningOverlay, IDecoration.TOP_LEFT);
    Image overlayedImage = all.createImage();
    this.disposeImages.add(overlayedImage);
    this.overlayedImages.put(targetDescriptor, overlayedImage);
    return overlayedImage;
}

/**
 * @return Image for the icon which indicates a key that has missing
 *         translations
 */
public static Image getMissingTranslationImage() {
    Image image = UIUtils.getImage(UIUtils.IMAGE_KEY);
    ImageDescriptor missing = ImageDescriptor.createFromImage(UIUtils
            .getImage(UIUtils.IMAGE_ERROR));
    image = new DecorationOverlayIcon(image, missing,
            IDecoration.BOTTOM_RIGHT).createImage();
    return image;
}

/**
 * @return Image for the icon which indicates a key that is unused
 */
public static Image getUnusedTranslationsImage() {
    Image image = UIUtils.getImage(UIUtils.IMAGE_UNUSED_TRANSLATION);
    ImageDescriptor warning = ImageDescriptor.createFromImage(UIUtils
            .getImage(UIUtils.IMAGE_WARNING));
    image = new DecorationOverlayIcon(image, warning,
            IDecoration.BOTTOM_RIGHT).createImage();
    return image;
}

/**
 * @return Image for the icon which indicates a key that has missing
 *         translations and is unused
 */
public static Image getMissingAndUnusedTranslationsImage() {
    Image image = UIUtils.getImage(UIUtils.IMAGE_UNUSED_TRANSLATION);
    ImageDescriptor missing = ImageDescriptor.createFromImage(UIUtils
            .getImage(UIUtils.IMAGE_ERROR));
    image = new DecorationOverlayIcon(image, missing,
            IDecoration.BOTTOM_RIGHT).createImage();
    return image;
}

/**
 * @return Image for the icon which indicates a key that has duplicate
 *         entries
 */
public static Image getDuplicateEntryImage() {
    Image image = UIUtils.getImage(UIUtils.IMAGE_KEY);
    ImageDescriptor missing = ImageDescriptor.createFromImage(UIUtils
            .getImage(UIUtils.IMAGE_WARNING));
    image = new DecorationOverlayIcon(image, missing,
            IDecoration.BOTTOM_RIGHT).createImage();
    return image;
}

/**
 * @return Image for the icon which indicates a key that has duplicate
 *         entries and is unused
 */
public static Image getDuplicateEntryAndUnusedTranslationsImage() {
    Image image = UIUtils.getImage(UIUtils.IMAGE_UNUSED_TRANSLATION);
    ImageDescriptor missing = ImageDescriptor.createFromImage(UIUtils
            .getImage(UIUtils.IMAGE_DUPLICATE));
    image = new DecorationOverlayIcon(image, missing,
            IDecoration.BOTTOM_RIGHT).createImage();
    return image;
}

private Image addOverlay(Image base, ImageDescriptor overlay, int location, String key)
{
    ImageRegistry reg = getImageRegistry();
    Image cached = reg.get(key);
    if (cached != null)
    {
        return cached;
    }

    DecorationOverlayIcon decorator = new DecorationOverlayIcon(base, overlay, location);
    Image result = decorator.createImage();
    reg.put(key, result);
    return result;
}

private Image getImage(PlanDiffObjectNode element) {    
    EObject object = element.getObject();
    Image undecoratedImage = null;
    if (object instanceof EPlanElement) {
        undecoratedImage = activityIconProvider.getImage(object);
    }
    if (undecoratedImage==null) return null;
    ImageDescriptor badge = diffTypeToBadge(element.getDiffType());
    return new DecorationOverlayIcon(undecoratedImage, badge, IDecoration.BOTTOM_RIGHT).createImage();
}

public CPVariableElementLabelProvider(boolean highlightReadOnly) {
    ImageRegistry reg= JavaPlugin.getDefault().getImageRegistry();
    fJARImage= reg.get(JavaPluginImages.IMG_OBJS_EXTJAR);
    fFolderImage= PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FOLDER);

    fDeprecatedJARImage= new DecorationOverlayIcon(fJARImage, JavaPluginImages.DESC_OVR_DEPRECATED, IDecoration.TOP_LEFT).createImage();
    fDeprecatedFolderImage= new DecorationOverlayIcon(fFolderImage, JavaPluginImages.DESC_OVR_DEPRECATED, IDecoration.TOP_LEFT).createImage();

    fHighlightReadOnly= highlightReadOnly;
}

public CPVariableElementLabelProvider(boolean highlightReadOnly) {
    ImageRegistry reg= JavaPlugin.getDefault().getImageRegistry();
    fJARImage= reg.get(JavaPluginImages.IMG_OBJS_EXTJAR);
    fFolderImage= PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FOLDER);

    fDeprecatedJARImage= new DecorationOverlayIcon(fJARImage, JavaPluginImages.DESC_OVR_DEPRECATED, IDecoration.TOP_LEFT).createImage();
    fDeprecatedFolderImage= new DecorationOverlayIcon(fFolderImage, JavaPluginImages.DESC_OVR_DEPRECATED, IDecoration.TOP_LEFT).createImage();

    fHighlightReadOnly= highlightReadOnly;
    fResolvedBackground= null;
}

private Image getImage(final Object element) {
    final Model model = (Model) element;
    Image img =
            model.getChildren() != null && model.getChildren().size() > 0 ? Util.Images.ELEMENT
                    : Util.Images.ATTRIBUTE;
    if (model.isCollection())
        img =
                new DecorationOverlayIcon(img, Util.Decorations.COLLECTION,
                        IDecoration.BOTTOM_RIGHT).createImage();
    if (editor.mapped((Model) element, rootModel))
        return new DecorationOverlayIcon(img, Util.Decorations.MAPPED,
                IDecoration.TOP_RIGHT).createImage();
    return img;
}

private ImageDescriptor getImageDescriptor(ImageDescriptor imageDesc, ImageDescriptor... overlays)
{
    if (overlays != null)
    {
        DecorationOverlayIcon overlayIcon = new DecorationOverlayIcon(imageDesc.createImage(), overlays);

        return overlayIcon;
    }

    return imageDesc;
}

@Override
    public Image decorateImage(Image image, Object obj) {
        if(image == null)
            return null;

        ImageDescriptor overlayImage = computeAdornmentFlags(obj);
        if(overlayImage != null) {
//          ImageDescriptor baseImage = new ImageImageDescriptor(image);
            return getRegistry().get(new DecorationOverlayIcon(image, overlayImage, IDecoration.BOTTOM_LEFT));
        }
        return image;
    }

private static Image get(String filename, String overlay) {
    if (filename == null || overlay == null)
        return null;
    String id = filename + "-" + overlay;
    Image withOverlay = registry.get(id);
    if (withOverlay != null && !withOverlay.isDisposed())
        return withOverlay;
    DecorationOverlayIcon withIcon = new DecorationOverlayIcon(get(filename), descriptor(overlay),
            IDecoration.BOTTOM_RIGHT);
    withOverlay = withIcon.createImage();
    registry.put(id, withOverlay);
    return withOverlay;
}

private static void initializeImages(){
    ImageDescriptor[] overlays = new ImageDescriptor[1];
    overlays[0] = AbstractUIPlugin.imageDescriptorFromPlugin("at.medevit.elexis.inbox.ui", //$NON-NLS-1$
        "/rsc/img/achtung_overlay.png"); //$NON-NLS-1$

    pathologicLabImage =
        new DecorationOverlayIcon(Images.IMG_VIEW_LABORATORY.getImage(), overlays);
}

public static Image decorateImage(Image image, ImageDescriptor imageDescriptor, int iconQuadrant) {
    DecorationOverlayIcon overlayIcon = new DecorationOverlayIcon(image, imageDescriptor, iconQuadrant);
    return overlayIcon.createImage();
}

public static Image getInfoIcon(Object element) {
    if(element instanceof Info<?>){
        switch(((Info) element).getType()){
        case CLASS:
            ITypeBinding typeBinding = Crystal.getInstance().getTypeBindingFromName((((Info) element).getKey()));
            if(typeBinding!=null){
                List<ImageDescriptor> overlayIcons = new ArrayList<ImageDescriptor>();
                int typeModifiers = typeBinding.getModifiers();
                if(Modifier.isAbstract(typeModifiers)){
                    overlayIcons.add(getImageDescriptor(IMG_ABSTRACT_CO));

                }else if(Modifier.isStatic(typeModifiers)){
                    overlayIcons.add(getImageDescriptor(IMG_STATIC_CO));
                }else if(Modifier.isPrivate(typeModifiers)){
                    overlayIcons.add(getImageDescriptor(IMG_PRIVATE_CO));
                }
                Image baseImage = JavaPluginImages.get(ISharedImages.IMG_OBJS_CLASS);

                DecorationOverlayIcon image = new DecorationOverlayIcon(baseImage, overlayIcons.toArray(new ImageDescriptor[0]));

                return image.createImage();
            }
            break;
        case METHOD:
            MethodDeclaration methodDeclaration = ASTUtils.getMethodDeclaration(((Info) element).getKey());
            if(methodDeclaration!=null){
                String icon= IMG_PUBLIC_CO;
                if(methodDeclaration!=null){
                    int modifiers = methodDeclaration.getModifiers();
                    if(Modifier.isPrivate(modifiers)){
                        icon = IMG_PRIVATE_CO;
                    }else if(Modifier.isProtected(modifiers)){
                        icon = IMG_PROTECTED_CO;
                    }else{

                    }

                }

                ImageDescriptor imageDescriptor = getImageDescriptor(icon);


                return imageDescriptor.createImage();
            }
            break;

        }
    }
    return null;
}

@Override
protected void initializeImageRegistry(ImageRegistry reg) {
  super.initializeImageRegistry(reg);

  reg.put(CoreImages.LIBRARY_ICON, imageDescriptorFromPath("icons/library_obj.gif"));

  reg.put(CoreImages.TERMINATE_ICON, imageDescriptorFromPath("icons/terminate_obj.gif"));

  ImageDescriptor errorOverlayDescriptor = imageDescriptorFromPath("icons/error_co.gif");
  reg.put(CoreImages.ERROR_OVERLAY, errorOverlayDescriptor);

  ImageDescriptor invalidSdkDescriptor = new DecorationOverlayIcon(
      getImage(CoreImages.LIBRARY_ICON), errorOverlayDescriptor, IDecoration.BOTTOM_LEFT);

  reg.put(CoreImages.INVALID_SDK_ICON, invalidSdkDescriptor);
}

/**
 * Returns the image with the specified Java image decorated added in the lower left quadrant of the image.
 */
private static ImageDescriptor decorateImageDescriptor(Image baseImage, ImageDescriptor overlayDescriptor) {
  return new DecorationOverlayIcon(baseImage, overlayDescriptor, IDecoration.BOTTOM_LEFT);
}

/**
 * @see ILabelProvider#getImage(Object)
 */
public Image getImage(Object element) {
    if (element instanceof KeyTreeNode) {
        KeyTreeNode node = (KeyTreeNode) element;
        Collection<IMessageCheck> c = editor.getMarkers().getFailedChecks(node.getMessageKey());
        if (c == null || c.isEmpty()) {
            // Return the default key image as no issue exists
            return UIUtils.getKeyImage();
        }
        if (editor.getMarkers().isUnusedKey(node.getMessageKey(), false)) {
            if (editor.getMarkers().isMissingKey(node.getMessageKey())) {
                return UIUtils.getMissingAndUnusedTranslationsImage();
            } else if (editor.getMarkers().isDuplicateValue(
                    node.getMessageKey())) {
                return UIUtils
                        .getDuplicateEntryAndUnusedTranslationsImage();
            }
            return UIUtils.getUnusedTranslationsImage();
        } else if (editor.getMarkers().isMissingKey(node.getMessageKey())) {
            return UIUtils.getMissingTranslationImage();
        } else if (editor.getMarkers().isDuplicateValue(
                node.getMessageKey())) {
            return UIUtils.getDuplicateEntryImage();
        }

        // This shouldnt happen, but just in case a default key with a
        // warning icon will be showed
        Image someWarning = UIUtils.getKeyImage();
        ImageDescriptor warning = ImageDescriptor.createFromImage(UIUtils
                .getImage(UIUtils.IMAGE_WARNING));
        someWarning = new DecorationOverlayIcon(someWarning, warning,
                IDecoration.BOTTOM_RIGHT).createImage();
        return someWarning;
        // return UIUtils.getImage(UIUtils.IMAGE_WARNED_TRANSLATION);
    } else {
        /*
         * // Figure out background icon if
         * (messagesBundleGroup.isMessageKey(key)) { //TODO create check (or
         * else) // if (!noInactiveKeyCheck.checkKey(messagesBundleGroup,
         * node.getPath())) { // iconFlags += KEY_COMMENTED; // } else {
         * iconFlags += KEY_DEFAULT;
         * 
         * // } } else { iconFlags += KEY_VIRTUAL; }
         */

        return UIUtils.getKeyImage();

    }
}

private static Image getOptionalOverlayIcon(Image base) {
    DecorationOverlayIcon decorationOverlayIcon = new DecorationOverlayIcon(base,
        createImageDescriptor(OPTIONAL_OVERLAY_ICON), IDecoration.TOP_LEFT);
    return decorationOverlayIcon.createImage();
}

private Image getDecoratedImage(Image base, ImageDescriptor decorator) {
    DecorationOverlayIcon decorated = new DecorationOverlayIcon(base,
            decorator, IDecoration.BOTTOM_RIGHT);
    return (Image) this.resourceManager.get(decorated);
}

private Image getDecoratedImage(Image base, ImageDescriptor decorator) {
    DecorationOverlayIcon decorated = new DecorationOverlayIcon(base,
            decorator, IDecoration.BOTTOM_RIGHT);
    return (Image) this.resourceManager.get(decorated);
}

private Image getDecoratedImage(Image base, ImageDescriptor decorator) {
    DecorationOverlayIcon decorated = new DecorationOverlayIcon(base,
            decorator, IDecoration.BOTTOM_RIGHT);
    return (Image) this.resourceManager.get(decorated);
}

private Image getDecoratedImage(Image base, String teamImageId) {
    ImageDescriptor overlay = TeamImages.getImageDescriptor(teamImageId);
    DecorationOverlayIcon decorated = new DecorationOverlayIcon(base,
            overlay, IDecoration.BOTTOM_LEFT);
    return (Image) this.resourceManager.get(decorated);
}