org.eclipse.ui.ISharedImages Java Examples

public Image getImage(Object element) {
	final String s;
	switch (((PreviewFile)element).type) {
	case IResource.PROJECT:
		s= SharedImages.IMG_OBJ_PROJECT; break;
	case IResource.FOLDER:
		s= ISharedImages.IMG_OBJ_FOLDER; break;
	default:
		s= ISharedImages.IMG_OBJ_FILE; break;
	}
	final Image baseImage= PlatformUI.getWorkbench().getSharedImages().getImage(s);
	final ImageDescriptor overlay = getOverlay(element);
	if (overlay == null)
		return baseImage;
	try {
              return fImageCache.createImage(new OverlayIcon(baseImage, new ImageDescriptor[] {overlay}, new int[] {OverlayIcon.BOTTOM_RIGHT}, new Point(baseImage.getBounds().width, baseImage.getBounds().height)));
          } catch (Exception e) {
          	SVNUIPlugin.log(e.getMessage());
          }
          return null;
}
 

@Override
   //NOTE: changes in node type recognition must me mirrored in XdsOutlineFilter.isFiltered()
public Image getImage(Object element) {
    Image image = null;
    if (element instanceof IXdsCompilationUnit) {
   		IXdsCompilationUnit xdsCompilationUnit = (IXdsCompilationUnit)element;
   		CompilationUnitType compilationUnitType = xdsCompilationUnit.getCompilationUnitType();
   		if (CompilationUnitType.DEFINITION_MODULE == compilationUnitType) {
   			image = ImageUtils.getImage(ImageUtils.DEFINITION_MODULE_IMAGE_NAME);
   		}
   		else if (CompilationUnitType.PROGRAM_MODULE == compilationUnitType) {
   			image = ImageUtils.getImage(ImageUtils.IMPLEMENTATION_MODULE_IMAGE_NAME);
   		}
           else if (CompilationUnitType.SYMBOL_FILE == compilationUnitType) {
               return ImageUtils.getImage(ImageUtils.SYMBOL_FILE_IMAGE_NAME);
           }
   	}
    else if (element instanceof IXdsElement) {
        image = XdsElementImages.getModulaElementImage((IXdsElement)element);
    }
       
       if (image == null) {
           image = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT);
       }
	return image;
}
 

/**
 * There is no official method/extension point for replacing the shared
 * workbench images. Thus, we access the internal WorkbenchImages class here
 * and replace some images with our own here.
 */
private void changeWorkbenchImages() {
	try {
		WorkbenchImages.declareImage(
				IWorkbenchGraphicConstants.IMG_WIZBAN_IMPORT_WIZ,
				RcpActivator.getImageDescriptor("icons/wizard/import.png"),
				true);
		WorkbenchImages.declareImage(
				IWorkbenchGraphicConstants.IMG_WIZBAN_EXPORT_WIZ,
				RcpActivator.getImageDescriptor("icons/wizard/export.png"),
				true);
		WorkbenchImages.declareImage(
				ISharedImages.IMG_OBJ_FOLDER,
				RcpActivator.getImageDescriptor("icons/folder_open.png"),
				true);
	} catch (Exception e) {
		Logger log = LoggerFactory.getLogger(getClass());
		log.error("failed to patch workbench images", e);
	}
}
 

@Override
public void setUp() throws Exception {
	super.setUp();
	final Injector injector = TestsActivator.getInstance().getInjector("org.eclipse.xtext.ui.tests.editor.outline.OutlineTestLanguage");
	with(new ISetup() {
		@Override
		public Injector createInjectorAndDoEMFRegistration() {
			return injector;
		}
	});
	comparer = new IOutlineNodeComparer.Default();
	image = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FILE);
	image2 = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FOLDER);
	eObject = OutlineTestFactory.eINSTANCE.createModel();

}
 

protected void createHelpWidget(final Composite parent, final Control control, String helpId) {
	final ImageHyperlink helpWidget = toolkit.createImageHyperlink(parent, SWT.CENTER);
	Image defaultImage = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_LCL_LINKTO_HELP);
	helpWidget.setImage(defaultImage);
	GridDataFactory.fillDefaults().align(SWT.FILL, SWT.TOP).applyTo(helpWidget);
	helpWidget.setToolTipText(JFaceResources.getString(IDialogLabelKeys.HELP_LABEL_KEY));
	helpWidget.addMouseListener(new MouseAdapter() {
		public void mouseDown(MouseEvent e) {
			control.setFocus();
			PlatformUI.getWorkbench().getHelpSystem().displayDynamicHelp();
		}
	});
	GridDataFactory.fillDefaults().applyTo(helpWidget);
	helpWidget.setEnabled(true);
	setHelpContext(control, helpId);
}
 

private void createToolbarActions(ToolBar bar) {
	createAction(bar, SWT.PUSH,
			"Snapshot",
			"Take a data snapshot.",
			Activator.getInstance().ICON_SNAPSHOT,
			this::takeSnapshot);
	createAction(bar, SWT.PUSH,
			"Snapshot and Save",
			"Take a data snapshot and save it as CSV file.",
			Activator.getInstance().ICON_SNAPSHOT_SAVE,
			this::takeSnapshotAndSave);
	createAction(bar, SWT.PUSH,
			"Delete",
			"Delete selected snapshots from history.",
			PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_TOOL_DELETE),
			this::deleteCurrentSelection);
}
 

/**
 * Constructs an action for copying resource.
 * 
 * @param page
 *            the resource explorer page
 * @param clipboard
 *            the clipboard for copying resource
 */
public CopyResourceAction( LibraryExplorerTreeViewPage page,
		Clipboard clipboard )
{
	super( Messages.getString( "CopyLibraryAction.Text" ), page ); //$NON-NLS-1$
	this.clipboard = clipboard;
	setId( ActionFactory.COPY.getId( ) );
	setAccelerator( SWT.CTRL | 'C' );

	setImageDescriptor( PlatformUI.getWorkbench( )
			.getSharedImages( )
			.getImageDescriptor( ISharedImages.IMG_TOOL_COPY ) );

	setDisabledImageDescriptor( PlatformUI.getWorkbench( )
			.getSharedImages( )
			.getImageDescriptor( ISharedImages.IMG_TOOL_COPY_DISABLED ) );
}
 

/**
 * Constructs an action for pasting resource.
 * 
 * @param page
 *            the resource explorer page
 * @param clipboard
 *            the clipboard for pasting resource
 */
public PasteResourceAction( LibraryExplorerTreeViewPage page,
		Clipboard clipboard )
{
	super( Messages.getString( "PasteLibraryAction.Text" ), page ); //$NON-NLS-1$
	this.clipboard = clipboard;
	setId( ActionFactory.PASTE.getId( ) );
	setAccelerator( SWT.CTRL | 'V' );

	setImageDescriptor( PlatformUI.getWorkbench( )
			.getSharedImages( )
			.getImageDescriptor( ISharedImages.IMG_TOOL_PASTE ) );

	setDisabledImageDescriptor( PlatformUI.getWorkbench( )
			.getSharedImages( )
			.getImageDescriptor( ISharedImages.IMG_TOOL_PASTE_DISABLED ) );
}
 

public Image getImage(final Object element) {
	if (element == null) {
		return null;
	}
	if (element instanceof Spec) {
		if (Activator.getSpecManager().isSpecLoaded((Spec) element)) {
			return Activator.getDefault().getImageRegistry().get(Activator.IMG_SPEC_OPEN);
		}
		return Activator.getDefault().getImageRegistry().get(Activator.IMG_SPEC_CLOSED);
	} else if (element instanceof Module) {
		return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FILE);
	} else if (element instanceof Group) {
		return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_TOOL_COPY);
	}
	return null;
}
 

/**
 * Gets the icon image for the given model.
 * 
 * @param model
 *            the model of the node
 * 
 * @return Returns the icon name for the model,or null if no proper one
 *         available for the given model
 */
public Image getNodeIcon( Object model )
{
	Image icon = null;
	String iconName = getIconName( model );

	if ( model instanceof DesignElementHandle
			&& ( (DesignElementHandle) model ).getSemanticErrors( ).size( ) > 0 )
	{
		return ReportPlatformUIImages.getImage( ISharedImages.IMG_OBJS_ERROR_TSK );
	}
	if ( iconName != null )
	{// if the getIconName is defined
		icon = ReportPlatformUIImages.getImage( iconName );
	}
	if ( icon == null )
	{
		if ( model instanceof DesignElementHandle )
		{
			icon = ReportPlatformUIImages.getImage( model );
		}
	}

	return decorateImage( icon, model );
	// return icon;
}
 

private void updateObjectCell(ViewerCell cell, IAbapGitObject object) {
	StyledString text = new StyledString();
	if (object.getType() == null || object.getType().isEmpty()) { //non-code and meta files
		text.append(object.getName().toLowerCase(Locale.ENGLISH), this.customStyler);
		cell.setImage(PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FOLDER));
	} else {
		if (object.eContainer() instanceof IIgnoredObjects) { //Ignored Objects will be shown as greyed out
			text.append(object.getName().toUpperCase(Locale.ENGLISH), this.grayStyler);
		} else {
			text.append(object.getName().toUpperCase(Locale.ENGLISH));
		}
		text.append(DASH, this.grayStyler).append(object.getType(), this.grayStyler);
		cell.setImage(getObjectImage(object));
	}

	cell.setText(text.getString());
	cell.setStyleRanges(text.getStyleRanges());
}
 

@Override
   public void createControl(final Composite composite, final TabbedPropertySheetWidgetFactory widgetFactory, final ExtensibleGridPropertySection extensibleGridPropertySection) {
GridData gd = (GridData) composite.getLayoutData();
gd.grabExcessHorizontalSpace = true;
ControlDecoration controlDecoration = new ControlDecoration(composite.getChildren()[0], SWT.RIGHT);
       controlDecoration.setDescriptionText(Messages.bind(Messages.warningDisplayLabelMaxLength, MAX_LENGTH, MAX_LENGTH));
       controlDecoration.setImage(PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_WARN_TSK));
       expressionViewer = new ExpressionViewer(composite,SWT.BORDER,widgetFactory,editingDomain, ProcessPackage.Literals.FLOW_ELEMENT__DYNAMIC_LABEL);
       expressionViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.DEFAULT, true, false));
       expressionViewer.addFilter(new AvailableExpressionTypeFilter(new String[]{ExpressionConstants.CONSTANT_TYPE,ExpressionConstants.VARIABLE_TYPE,ExpressionConstants.PARAMETER_TYPE,ExpressionConstants.SCRIPT_TYPE}));
       expressionViewer.setExpressionNameResolver(new DefaultExpressionNameResolver("displayName"));
       expressionViewer.setInput(eObject) ;
       expressionViewer.setMessage(Messages.dynamicLabelHint) ;
       expressionViewer.addExpressionValidator(new ExpressionLengthValidator(MAX_LENGTH));
       refreshDataBindingContext();
   }
 

public Image getImage(final Object element) {
	if (element == null) {
		return null;
	}
	if (element instanceof Spec) {
		if (Activator.getSpecManager().isSpecLoaded((Spec) element)) {
			return Activator.getDefault().getImageRegistry().get(Activator.IMG_SPEC_OPEN);
		}
		return Activator.getDefault().getImageRegistry().get(Activator.IMG_SPEC_CLOSED);
	} else if (element instanceof Module) {
		return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FILE);
	} else if (element instanceof Model) {
		return ModelImage;
	}
	return null;
}
 

private IAction[] createActions() {

		ISharedImages sharedImages = PlatformUI.getWorkbench()
				.getSharedImages();

		projectsAction = new TopLevelContentAction(false);
		projectsAction
				.setText(WorkbenchNavigatorMessages.actions_WorkingSetRootModeActionGroup_Project_);
		projectsAction.setImageDescriptor(sharedImages
				.getImageDescriptor(IDE.SharedImages.IMG_OBJ_PROJECT));

		workingSetsAction = new TopLevelContentAction(true);
		workingSetsAction
				.setText(WorkbenchNavigatorMessages.actions_WorkingSetRootModeActionGroup_Working_Set_);
		workingSetsAction.setImageDescriptor(WorkbenchNavigatorPlugin
				.getDefault().getImageRegistry().getDescriptor(
						"full/obj16/workingsets.gif")); //$NON-NLS-1$

		return new IAction[] { projectsAction, workingSetsAction };
	}
 

public Image getNodeIcon( Object model )
{
	if ( model instanceof DesignElementHandle
			&& ( (DesignElementHandle) model ).getSemanticErrors( ).size( ) > 0 )
	{
		return ReportPlatformUIImages.getImage( ISharedImages.IMG_OBJS_ERROR_TSK );
	}

	if ( model instanceof MeasureHandle )
	{
		return ( (MeasureHandle) model ).isCalculated( ) ? IMG_DERIVED_MEASURE
				: IMG_MEASURE;
	}

	return super.getNodeIcon( model );
}
 

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 CopyAction() {
	super(WorkbenchMessages.Workbench_copy);
	setEnabled(false);
	ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages();
	setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
	setDisabledImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED));
}
 

/**
 * Fill the context menu for the tree viewer.
 *
 * @param manager
 *            The menu manager
 */
protected void fillContextMenu(IMenuManager manager) {
    final ISelection selection = fViewer.getSelection();
    ITmfFilterTreeNode filterTreeNode = null;
    if (selection instanceof StructuredSelection) {
        Object element = ((StructuredSelection) selection).getFirstElement();
        if (element instanceof ITmfFilterTreeNode) {
            filterTreeNode = (ITmfFilterTreeNode) element;
        }
    }

    final ITmfFilterTreeNode selectedNode = filterTreeNode;
    if (selectedNode != null) {
        fillContextMenuForNode(selectedNode, manager);
    }

    manager.add(new Separator("delete")); //$NON-NLS-1$

    if (fIsDialog && (selectedNode != null)) {
        Action deleteAction = new Action(Messages.FilterViewer_DeleteActionText) {
            @Override
            public void run() {
                selectedNode.remove();
                fViewer.refresh();
            }
        };
        deleteAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_TOOL_DELETE));
        manager.add(deleteAction);
    }
    manager.add(new Separator("edit")); //$NON-NLS-1$

    if (fViewer.getInput() instanceof TmfFilterRootNode || filterTreeNode == null) {
        manager.add(new Separator());
        ITmfFilterTreeNode root = (ITmfFilterTreeNode) fViewer.getInput();
        fillContextMenuForNode(root, manager);
    }
}
 

@Override
public Image getImage(Object obj) {
    String imageKey = ISharedImages.IMG_OBJ_ELEMENT;
    if (obj instanceof TreeParent) {
        imageKey = ISharedImages.IMG_OBJ_FOLDER;
    }
    return PlatformUI.getWorkbench().getSharedImages().getImage(
            imageKey);
}
 

public Image getNodeIcon( Object model )
{
	if ( model instanceof DesignElementHandle
			&& ( (DesignElementHandle) model ).getSemanticErrors( ).size( ) > 0 )
	{
		return ReportPlatformUIImages.getImage( ISharedImages.IMG_OBJS_ERROR_TSK );
	}
	// if ( model instanceof DesignElementHandle
	// && DEUtil.isLinkedElement( (DesignElementHandle) model ) )
	// return CrosstabUIHelper.getImage(
	// CrosstabUIHelper.CROSSTAB_LINK_IMAGE );
	return decorateImage( CrosstabUIHelper.getImage( CrosstabUIHelper.CROSSTAB_IMAGE ),
			model );
}
 

SyncStackTraversal() {
	super("Sync traversing of the stack trace by arrow keys to the editor.", AS_CHECK_BOX);
	
	final ImageDescriptor id = PlatformUI.getWorkbench().getSharedImages()
			.getImageDescriptor(ISharedImages.IMG_ELCL_SYNCED);
	setImageDescriptor(id);
	
       final boolean enabled = Activator.getDefault().getDialogSettings().getBoolean(SYNCED_TRAVERSAL_KEY);
       setChecked(enabled);
       
       run();
}
 

/**
 * Creates the hide single node action.
 *
 * @param part the call hierarchy view part
 * @param viewer the call hierarchy viewer
 */
public RemoveFromViewAction(CallHierarchyViewPart part, CallHierarchyViewer viewer) {
	fPart= part;
	fCallHierarchyViewer= viewer;
	setText(CallHierarchyMessages.RemoveFromViewAction_removeFromView_text);
	setDescription(CallHierarchyMessages.RemoveFromViewAction_removeFromView_description);
	setToolTipText(CallHierarchyMessages.RemoveFromViewAction_removeFromView_tooltip);
	PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IJavaHelpContextIds.CALL_HIERARCHY_REMOVE_FROM_VIEW_ACTION);

	ISharedImages workbenchImages= JavaPlugin.getDefault().getWorkbench().getSharedImages();
	setDisabledImageDescriptor(workbenchImages.getImageDescriptor(ISharedImages.IMG_ELCL_REMOVE_DISABLED));
	setImageDescriptor(workbenchImages.getImageDescriptor(ISharedImages.IMG_ELCL_REMOVE));
	setHoverImageDescriptor(workbenchImages.getImageDescriptor(ISharedImages.IMG_ELCL_REMOVE));
}
 

public BackAction(IXtextBrowserInformationControl infoControl) {
	fInfoControl = infoControl;
	setText(XtextUIMessages.XtextBrowserInformationControlInput_Back);
	ISharedImages images = PlatformUI.getWorkbench().getSharedImages();
	setImageDescriptor(images.getImageDescriptor(ISharedImages.IMG_TOOL_BACK));
	setDisabledImageDescriptor(images.getImageDescriptor(ISharedImages.IMG_TOOL_BACK_DISABLED));

	update();
}
 

public Image getImage( )
{
	if ( this.isRoot || hasChildren( ) )
	{
		return PlatformUI.getWorkbench( )
				.getSharedImages( )
				.getImage( ISharedImages.IMG_OBJ_FOLDER );
	}
	return PlatformUI.getWorkbench( )
			.getSharedImages( )
			.getImage( ISharedImages.IMG_OBJ_FILE );
}
 

public CopyAction(final IWorkbenchPart part) {
    super(part);

    setText(ResourceString.getResourceString("action.title.copy"));

    final ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages();
    setImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY));
    setDisabledImageDescriptor(sharedImages.getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED));

    setId(ActionFactory.COPY.getId());
}
 

@Override
 	public boolean paint(SourceCodeTextEditor editor, MarkerAnnotation annotation,
 			GC gc, Canvas canvas, Rectangle bounds) {
 		IMarker marker = annotation.getMarker();
try {
	if (marker.exists() && XdsMarkerConstants.PARSER_PROBLEM.equals(marker.getType())) {
		boolean isInCompilationSet = CompilationSetManager.getInstance().isInCompilationSet((IFile)marker.getResource());
		if (!isInCompilationSet) {
			int actualSeverity = marker.getAttribute(XdsMarkerConstants.PARSER_PROBLEM_SEVERITY_ATTRIBUTE, -1);
			if (actualSeverity > -1) {
				Image image = null;
				switch (actualSeverity) {
				case IMarker.SEVERITY_ERROR:
					image = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_ERROR_TSK); 
					break;
				case IMarker.SEVERITY_WARNING:
					image = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_WARN_TSK); 
					break;
				default:
					break;
				}

				if (image != null) {
					ImageUtilities.drawImage(image, gc, canvas, bounds, SWT.CENTER, SWT.TOP);
					return true;
				}

				return false;
			}
		}
	}
} catch (CoreException e) {
	LogHelper.logError(e);
}
 		return false;
 	}
 

public Image getNodeIcon( Object element )
{
	if ( element instanceof DesignElementHandle
			&& ( (DesignElementHandle) element ).getSemanticErrors( )
					.size( ) > 0 )
	{
		return ReportPlatformUIImages.getImage( ISharedImages.IMG_OBJS_ERROR_TSK );
	}
	return CrosstabUIHelper.getImage( CrosstabUIHelper.LEVEL_IMAGE );
}
 

public BackAction(BrowserInformationControl infoControl) {
	fInfoControl= infoControl;
	setText(JavaHoverMessages.JavadocHover_back);
	ISharedImages images= PlatformUI.getWorkbench().getSharedImages();
	setImageDescriptor(images.getImageDescriptor(ISharedImages.IMG_TOOL_BACK));
	setDisabledImageDescriptor(images.getImageDescriptor(ISharedImages.IMG_TOOL_BACK_DISABLED));

	update();
}
 

public ForwardAction(BrowserInformationControl infoControl) {
	fInfoControl= infoControl;
	setText(JavaHoverMessages.JavadocHover_forward);
	ISharedImages images= PlatformUI.getWorkbench().getSharedImages();
	setImageDescriptor(images.getImageDescriptor(ISharedImages.IMG_TOOL_FORWARD));
	setDisabledImageDescriptor(images.getImageDescriptor(ISharedImages.IMG_TOOL_FORWARD_DISABLED));

	update();
}
 

public TexOutlineActionDelete(TexOutlinePage outline) {
	super("Delete");
	setToolTipText("Delete");
	setImageDescriptor(TexlipsePlugin.getDefault().getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_TOOL_DELETE));
	setDisabledImageDescriptor(TexlipsePlugin.getDefault().getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_TOOL_DELETE_DISABLED));

	this.outline = outline;
}