| /******************************************************************************* |
| * Copyright (c) 2003, 2016 IBM Corporation and others. |
| * 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: |
| * IBM Corporation - initial API and implementation |
| * Cornel Izbasa <cizbasa@info.uvt.ro> - Bug 436247 |
| * Lars Vogel <Lars.Vogel@vogella.com> - Bug 440136, 472654 |
| * Robert Roth <robert.roth.off@gmail.com> - Bugs 274005, 456291 |
| * Mickael Istria (Red Hat Inc.) - Theme and fontregistry rather than pref |
| * Patrik Suzzi <psuzzi@gmail.com> - Bug 489250 |
| *******************************************************************************/ |
| package org.eclipse.ui.internal.themes; |
| |
| import static org.eclipse.swt.events.SelectionListener.widgetSelectedAdapter; |
| import static org.eclipse.ui.internal.themes.WorkbenchThemeManager.EMPTY_COLOR_VALUE; |
| |
| import com.ibm.icu.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.ResourceBundle; |
| import java.util.Set; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.e4.core.services.events.IEventBroker; |
| import org.eclipse.e4.ui.css.swt.theme.IThemeEngine; |
| import org.eclipse.jface.preference.PreferenceConverter; |
| import org.eclipse.jface.preference.PreferencePage; |
| import org.eclipse.jface.resource.JFaceResources; |
| import org.eclipse.jface.resource.StringConverter; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.jface.viewers.IColorProvider; |
| import org.eclipse.jface.viewers.IFontProvider; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITreeContentProvider; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.LabelProviderChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.jface.viewers.ViewerComparator; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.SashForm; |
| import org.eclipse.swt.custom.StackLayout; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.FontData; |
| import org.eclipse.swt.graphics.FontMetrics; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.layout.FillLayout; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Canvas; |
| import org.eclipse.swt.widgets.ColorDialog; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.FontDialog; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPreferencePage; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.dialogs.FilteredTree; |
| import org.eclipse.ui.dialogs.PatternFilter; |
| import org.eclipse.ui.internal.IWorkbenchGraphicConstants; |
| import org.eclipse.ui.internal.IWorkbenchHelpContextIds; |
| import org.eclipse.ui.internal.Workbench; |
| import org.eclipse.ui.internal.WorkbenchMessages; |
| import org.eclipse.ui.internal.WorkbenchPlugin; |
| import org.eclipse.ui.internal.misc.StatusUtil; |
| import org.eclipse.ui.internal.util.PrefUtil; |
| import org.eclipse.ui.themes.ITheme; |
| import org.eclipse.ui.themes.IThemeManager; |
| import org.eclipse.ui.themes.IThemePreview; |
| import org.osgi.service.event.Event; |
| import org.osgi.service.event.EventHandler; |
| |
| |
| /** |
| * Preference page for management of system colors, gradients and fonts. |
| * |
| * @since 3.0 |
| */ |
| public final class ColorsAndFontsPreferencePage extends PreferencePage |
| implements IWorkbenchPreferencePage { |
| |
| private static final String SELECTED_ELEMENT_PREF = "ColorsAndFontsPreferencePage.selectedElement"; //$NON-NLS-1$ |
| /** |
| * The preference that stores the expanded state. |
| */ |
| private static final String EXPANDED_ELEMENTS_PREF = "ColorsAndFontsPreferencePage.expandedCategories"; //$NON-NLS-1$ |
| /** |
| * The token that separates expanded elements in EXPANDED_ELEMENTS_PREF. |
| */ |
| private static final String EXPANDED_ELEMENTS_TOKEN = "\t"; //$NON-NLS-1$ |
| |
| /** |
| * Marks category tokens in EXPANDED_ELEMENTS_PREF and SELECTED_ELEMENT_PREF. |
| */ |
| private static final char MARKER_CATEGORY = 'T'; |
| |
| /** |
| * Marks color tokens in EXPANDED_ELEMENTS_PREF and SELECTED_ELEMENT_PREF. |
| */ |
| private static final char MARKER_COLOR = 'C'; |
| |
| /** |
| * Marks font tokens in EXPANDED_ELEMENTS_PREF and SELECTED_ELEMENT_PREF. |
| */ |
| private static final char MARKER_FONT = 'F'; |
| |
| private static final int DEFINITION_NOT_AVAIL_COLOR = SWT.COLOR_WIDGET_LIGHT_SHADOW; |
| |
| private class ThemeContentProvider implements ITreeContentProvider { |
| |
| private IThemeRegistry registry; |
| |
| @Override |
| public Object[] getChildren(Object parentElement) { |
| if (parentElement instanceof ThemeElementCategory) { |
| String categoryId = ((ThemeElementCategory) parentElement) |
| .getId(); |
| Object[] defintions = (Object[]) categoryMap.get(categoryId); |
| if (defintions == null) { |
| defintions = getCategoryChildren(categoryId); |
| categoryMap.put(categoryId, defintions); |
| } |
| return defintions; |
| } |
| |
| ArrayList list = new ArrayList(); |
| IHierarchalThemeElementDefinition def = (IHierarchalThemeElementDefinition) parentElement; |
| String id = def.getId(); |
| IHierarchalThemeElementDefinition[] defs; |
| if (def instanceof ColorDefinition) { |
| defs = registry.getColors(); |
| } else { |
| defs = registry.getFonts(); |
| } |
| |
| for (IHierarchalThemeElementDefinition elementDefinition : defs) { |
| if (id.equals(elementDefinition.getDefaultsTo()) |
| && ColorsAndFontsPreferencePage.equals( |
| ((ICategorizedThemeElementDefinition) def).getCategoryId(), |
| ((ICategorizedThemeElementDefinition) elementDefinition).getCategoryId())) { |
| list.add(elementDefinition); |
| } |
| } |
| return list.toArray(); |
| } |
| |
| private Object[] getCategoryChildren(String categoryId) { |
| ArrayList list = new ArrayList(); |
| |
| if (categoryId != null) { |
| for (ThemeElementCategory category : registry.getCategories()) { |
| if (categoryId.equals(category.getParentId())) { |
| Set bindings = themeRegistry.getPresentationsBindingsFor(category); |
| if (bindings == null) { |
| list.add(category); |
| } |
| } |
| } |
| } |
| { |
| ColorDefinition[] colorDefinitions = themeRegistry |
| .getColorsFor(currentTheme.getId()); |
| for (int i = 0; i < colorDefinitions.length; i++) { |
| if (!colorDefinitions[i].isEditable()) { |
| continue; |
| } |
| String catId = colorDefinitions[i].getCategoryId(); |
| if ((catId == null && categoryId == null) |
| || (catId != null && categoryId != null && categoryId |
| .equals(catId))) { |
| if (colorDefinitions[i].getDefaultsTo() != null |
| && parentIsInSameCategory(colorDefinitions[i])) { |
| continue; |
| } |
| list.add(colorDefinitions[i]); |
| } |
| } |
| } |
| { |
| FontDefinition[] fontDefinitions = themeRegistry |
| .getFontsFor(currentTheme.getId()); |
| for (int i = 0; i < fontDefinitions.length; i++) { |
| if (!fontDefinitions[i].isEditable()) { |
| continue; |
| } |
| String catId = fontDefinitions[i].getCategoryId(); |
| if ((catId == null && categoryId == null) |
| || (catId != null && categoryId != null && categoryId |
| .equals(catId))) { |
| if (fontDefinitions[i].getDefaultsTo() != null |
| && parentIsInSameCategory(fontDefinitions[i])) { |
| continue; |
| } |
| list.add(fontDefinitions[i]); |
| } |
| } |
| } |
| return list.toArray(new Object[list.size()]); |
| } |
| |
| private boolean parentIsInSameCategory(ColorDefinition definition) { |
| String defaultsTo = definition.getDefaultsTo(); |
| for (ColorDefinition colorDef : registry.getColors()) { |
| if (colorDef.getId().equals(defaultsTo) && ColorsAndFontsPreferencePage.equals(colorDef |
| .getCategoryId(), definition.getCategoryId())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean parentIsInSameCategory(FontDefinition definition) { |
| String defaultsTo = definition.getDefaultsTo(); |
| for (FontDefinition fontDef : registry.getFonts()) { |
| if (fontDef.getId().equals(defaultsTo) && ColorsAndFontsPreferencePage.equals(fontDef |
| .getCategoryId(), definition.getCategoryId())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| public Object getParent(Object element) { |
| if (element instanceof ThemeElementCategory) |
| return registry; |
| |
| if (element instanceof ColorDefinition) { |
| String defaultId = ((IHierarchalThemeElementDefinition) element).getDefaultsTo(); |
| if (defaultId != null) { |
| ColorDefinition defaultElement = registry.findColor(defaultId); |
| if (parentIsInSameCategory(defaultElement)) |
| return defaultElement; |
| } |
| String categoryId = ((ColorDefinition) element).getCategoryId(); |
| return registry.findCategory(categoryId); |
| } |
| |
| if (element instanceof FontDefinition) { |
| String defaultId = ((FontDefinition) element).getDefaultsTo(); |
| if (defaultId != null) { |
| FontDefinition defaultElement = registry.findFont(defaultId); |
| if (parentIsInSameCategory(defaultElement)) |
| return defaultElement; |
| } |
| String categoryId = ((FontDefinition) element).getCategoryId(); |
| return registry.findCategory(categoryId); |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public boolean hasChildren(Object element) { |
| if (element instanceof ThemeElementCategory) { |
| return true; |
| } |
| |
| IHierarchalThemeElementDefinition def = (IHierarchalThemeElementDefinition) element; |
| String id = def.getId(); |
| IHierarchalThemeElementDefinition[] defs; |
| if (def instanceof ColorDefinition) { |
| defs = registry.getColors(); |
| } else { |
| defs = registry.getFonts(); |
| } |
| |
| for (IHierarchalThemeElementDefinition elementDefinition : defs) { |
| if (id.equals(elementDefinition.getDefaultsTo()) |
| && ColorsAndFontsPreferencePage.equals( |
| ((ICategorizedThemeElementDefinition) def).getCategoryId(), |
| ((ICategorizedThemeElementDefinition) elementDefinition).getCategoryId())) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| @Override |
| public Object[] getElements(Object inputElement) { |
| ArrayList list = new ArrayList(); |
| Object[] uncatChildren = getCategoryChildren(null); |
| list.addAll(Arrays.asList(uncatChildren)); |
| for (ThemeElementCategory category : ((IThemeRegistry) inputElement).getCategories()) { |
| if (category.getParentId() == null) { |
| Set bindings = themeRegistry.getPresentationsBindingsFor(category); |
| if (bindings == null) { |
| Object[] children = getChildren(category); |
| if (children != null && children.length > 0) { |
| list.add(category); |
| } |
| } |
| } |
| } |
| return list.toArray(new Object[list.size()]); |
| } |
| |
| @Override |
| public void dispose() { |
| categoryMap.clear(); |
| } |
| |
| @Override |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| categoryMap.clear(); |
| registry = (IThemeRegistry) newInput; |
| } |
| |
| } |
| |
| private class PresentationLabelProvider extends LabelProvider implements |
| IFontProvider, |
| IColorProvider { |
| |
| private HashMap fonts = new HashMap(); |
| |
| private HashMap images = new HashMap(); |
| |
| private int imageSize = -1; |
| |
| private int usableImageSize = -1; |
| |
| private IPropertyChangeListener listener = event -> { |
| if (event.getNewValue() != null) { |
| fireLabelProviderChanged(new LabelProviderChangedEvent( |
| PresentationLabelProvider.this)); |
| } else { |
| // Some theme definition element has been modified and we |
| // need to refresh the viewer |
| refreshAllLabels(); |
| } |
| }; |
| |
| private Image emptyImage; |
| |
| public PresentationLabelProvider() { |
| hookListeners(); |
| } |
| |
| /** |
| * Hook the listeners onto the various registries. |
| */ |
| public void hookListeners() { |
| colorRegistry.addListener(listener); |
| fontRegistry.addListener(listener); |
| } |
| |
| @Override |
| public void dispose() { |
| super.dispose(); |
| colorRegistry.removeListener(listener); |
| fontRegistry.removeListener(listener); |
| for (Iterator i = images.values().iterator(); i.hasNext();) { |
| ((Image) i.next()).dispose(); |
| } |
| images.clear(); |
| |
| if (emptyImage != null) { |
| emptyImage.dispose(); |
| emptyImage = null; |
| } |
| |
| //clear the fonts. |
| clearFontCache(); |
| } |
| |
| /** |
| * Clears and disposes all fonts. |
| */ |
| public void clearFontCache() { |
| for (Iterator i = fonts.values().iterator(); i.hasNext();) { |
| ((Font) i.next()).dispose(); |
| } |
| fonts.clear(); |
| } |
| |
| /** |
| * Clears and disposes all fonts and fires a label update. |
| */ |
| public void clearFontCacheAndUpdate() { |
| clearFontCache(); |
| fireLabelProviderChanged(new LabelProviderChangedEvent( |
| PresentationLabelProvider.this)); |
| } |
| |
| @Override |
| public Font getFont(Object element) { |
| Display display = tree.getDisplay(); |
| if (element instanceof FontDefinition) { |
| int parentHeight = tree.getViewer().getControl().getFont() |
| .getFontData()[0].getHeight(); |
| Font baseFont = fontRegistry.get(((FontDefinition) element) |
| .getId()); |
| Font font = (Font) fonts.get(baseFont); |
| if (font == null) { |
| FontData[] data = baseFont.getFontData(); |
| for (FontData fontData : data) { |
| fontData.setHeight(parentHeight); |
| } |
| font = new Font(display, data); |
| |
| fonts.put(baseFont, font); |
| } |
| return font; |
| } |
| return JFaceResources.getDialogFont(); |
| } |
| |
| @Override |
| public Image getImage(Object element) { |
| if (element instanceof ColorDefinition) { |
| Display display = tree.getDisplay(); |
| Color c = colorRegistry |
| .get(((ColorDefinition) element).getId()); |
| Color foregroundColor = display.getSystemColor(SWT.COLOR_BLACK); |
| if (!isAvailableInCurrentTheme((ColorDefinition) element)) { |
| c = display.getSystemColor(SWT.COLOR_WHITE); |
| foregroundColor = display.getSystemColor(DEFINITION_NOT_AVAIL_COLOR); |
| } |
| Image image = (Image) images.get(c); |
| if (image == null) { |
| ensureImageSize(); |
| image = new Image(display, imageSize, imageSize); |
| |
| GC gc = new GC(image); |
| gc.setBackground(tree.getViewer().getControl() |
| .getBackground()); |
| gc.setForeground(tree.getViewer().getControl() |
| .getBackground()); |
| gc.drawRectangle(0, 0, imageSize - 1, imageSize - 1); |
| |
| gc.setForeground(foregroundColor); |
| gc.setBackground(c); |
| |
| int offset = (imageSize - usableImageSize) / 2; |
| gc.drawRectangle(offset, offset, usableImageSize - offset, |
| usableImageSize - offset); |
| gc.fillRectangle(offset + 1, offset + 1, usableImageSize |
| - offset - 1, usableImageSize - offset - 1); |
| gc.dispose(); |
| |
| images.put(c, image); |
| } |
| return image; |
| |
| } else if (element instanceof FontDefinition) { |
| return workbench.getSharedImages().getImage( |
| IWorkbenchGraphicConstants.IMG_OBJ_FONT); |
| } else { |
| return workbench.getSharedImages().getImage( |
| IWorkbenchGraphicConstants.IMG_OBJ_THEME_CATEGORY); |
| } |
| } |
| |
| private void ensureImageSize() { |
| if (imageSize == -1) { |
| imageSize = tree.getViewer().getTree().getItemHeight(); |
| usableImageSize = Math.max(1, imageSize - 4); |
| } |
| } |
| |
| @Override |
| public String getText(Object element) { |
| if (element instanceof IHierarchalThemeElementDefinition) { |
| IHierarchalThemeElementDefinition themeElement = (IHierarchalThemeElementDefinition) element; |
| if (themeElement.getDefaultsTo() != null) { |
| String myCategory = ((ICategorizedThemeElementDefinition) themeElement).getCategoryId(); |
| ICategorizedThemeElementDefinition def; |
| if (element instanceof ColorDefinition) { |
| def = themeRegistry.findColor(themeElement.getDefaultsTo()); |
| } else { |
| def = themeRegistry.findFont(themeElement.getDefaultsTo()); |
| } |
| if (def != null && !ColorsAndFontsPreferencePage.equals(def.getCategoryId(), myCategory)) { |
| if (isDefault(themeElement)) { |
| return MessageFormat.format(RESOURCE_BUNDLE.getString("defaultFormat_default"), //$NON-NLS-1$ |
| themeElement.getName(), def.getName()); |
| } |
| return MessageFormat.format(RESOURCE_BUNDLE.getString("defaultFormat_override"), //$NON-NLS-1$ |
| themeElement.getName(), def.getName()); |
| } |
| } |
| } |
| return ((IThemeElementDefinition) element).getName(); |
| } |
| |
| /** |
| * Return whether the element is set to default. |
| * |
| * @param def the definition |
| * @return whether the element is set to default |
| * @since 3.2 |
| */ |
| private boolean isDefault(IThemeElementDefinition def) { |
| if (def instanceof FontDefinition) { |
| FontDefinition fontDef = (FontDefinition) def; |
| String defaultFontID = fontDef.getDefaultsTo(); |
| return defaultFontID != null |
| && Arrays.equals(fontRegistry.getFontData(def.getId()), |
| fontRegistry.getFontData(defaultFontID)); |
| } |
| if (def instanceof ColorDefinition) { |
| ColorDefinition colorDef = (ColorDefinition) def; |
| String defaultColorID = colorDef.getDefaultsTo(); |
| if (defaultColorID == null) |
| return false; |
| RGB defaultRGB = colorRegistry.getRGB(defaultColorID); |
| return defaultRGB != null |
| && defaultRGB.equals(colorRegistry.getRGB(colorDef.getId())); |
| } |
| return false; |
| } |
| |
| /** |
| * Returns the DEFINITION_NOT_AVAIL_COLOR color when definition is not |
| * present in the current theme or null when it is available |
| * |
| * @param def |
| * the definition |
| * @return the DEFINITION_NOT_AVAIL_COLOR color or null |
| */ |
| @Override |
| public Color getForeground(Object element) { |
| if (element instanceof ThemeElementDefinition && !isAvailableInCurrentTheme((ThemeElementDefinition) element)) { |
| return tree.getDisplay().getSystemColor(DEFINITION_NOT_AVAIL_COLOR); |
| } |
| return null; |
| } |
| |
| @Override |
| public Color getBackground(Object element) { |
| return null; |
| } |
| } |
| |
| /** |
| * The translation bundle in which to look up internationalized text. |
| */ |
| private final static ResourceBundle RESOURCE_BUNDLE = ResourceBundle |
| .getBundle(ColorsAndFontsPreferencePage.class.getName()); |
| |
| /** |
| * Map to precalculate category color lists. |
| */ |
| private Map categoryMap = new HashMap(7); |
| |
| private Font appliedDialogFont; |
| |
| /** |
| * Map of definition ColorDefinition->RGB capturing the explicit changes |
| * made by the user. These changes need to be stored into the preference |
| * store. |
| */ |
| private Map<ColorDefinition, RGB> colorPreferencesToSet = new HashMap<>(7); |
| |
| private CascadingColorRegistry colorRegistry; |
| |
| /** |
| * Map of definition id->RGB capturing the temporary changes caused by a |
| * 'defaultsTo' color change. |
| */ |
| private Map colorValuesToSet = new HashMap(7); |
| |
| /** |
| * The default color preview composite. |
| */ |
| private Composite defaultColorPreview; |
| |
| /** |
| * The default font preview composite. |
| */ |
| private Composite defaultFontPreview; |
| |
| /** |
| * The composite to use when no preview is available. |
| */ |
| private Composite defaultNoPreview; |
| |
| /** |
| * Currently selected font for preview; might be null. |
| */ |
| private Font currentFont; |
| |
| /** |
| * Currently selected color for preview; might be null. |
| */ |
| private Color currentColor; |
| |
| /** |
| * Canvas used to draw default color preview |
| */ |
| private Canvas colorSampler; |
| |
| /** |
| * Canvas used to draw default font preview |
| */ |
| private Canvas fontSampler; |
| |
| private String fontSampleText; |
| |
| private List dialogFontWidgets = new ArrayList(); |
| |
| private Button fontChangeButton; |
| |
| /** |
| * The button to edit the default of the selected element. |
| * |
| * @since 3.7 |
| */ |
| private Button editDefaultButton; |
| |
| /** |
| * The button to go to the default of the selected element. |
| * |
| * @since 3.7 |
| */ |
| private Button goToDefaultButton; |
| |
| /** |
| * The button to expand the tree. |
| * |
| * @since 4.5 |
| */ |
| private Button expandAllButton; |
| |
| /** |
| * Map of definition FontDefinition->FontData[] capturing the changes |
| * explicitly made by the user. These changes need to be stored into the |
| * preference store. |
| */ |
| private Map<FontDefinition, FontData[]> fontPreferencesToSet = new HashMap<>( |
| 7); |
| |
| private CascadingFontRegistry fontRegistry; |
| |
| private Button fontResetButton; |
| |
| private Button fontSystemButton; |
| |
| /** |
| * Map of definition id->FontData[] capturing the temporary changes caused |
| * by a 'defaultsTo' font change. |
| * |
| * @deprecated in this page, we should only care about preferences, |
| * preference to fontValues synchronization in registry is |
| * handled in the ThemeAPI and listeners |
| */ |
| @Deprecated |
| private Map fontValuesToSet = new HashMap(7); |
| |
| /** |
| * The composite that is parent to all previews. |
| */ |
| private Composite previewComposite; |
| |
| /** |
| * A mapping from PresentationCategory->Composite for the created previews. |
| */ |
| private Map previewMap = new HashMap(7); |
| |
| /** |
| * Set containing all IPresentationPreviews created. |
| */ |
| private Set previewSet = new HashSet(7); |
| |
| /** |
| * The layout for the previewComposite. |
| */ |
| private StackLayout stackLayout; |
| |
| private final IThemeRegistry themeRegistry; |
| |
| private ITheme currentTheme; |
| |
| private PresentationLabelProvider labelProvider; |
| |
| private CascadingThemeExt cascadingTheme; |
| |
| private IPropertyChangeListener themeChangeListener; |
| |
| private Workbench workbench; |
| |
| private FilteredTree tree; |
| |
| private Text descriptionText; |
| |
| private IEventBroker eventBroker; |
| |
| private EventHandler themeRegistryRestyledHandler = new EventHandler() { |
| @Override |
| public void handleEvent(Event event) { |
| if (isAnyThemeChanged()) { |
| updateThemeInfo(workbench.getThemeManager()); |
| } |
| refreshCategory(); |
| refreshAllLabels(); |
| |
| clearPreviews(); |
| previewMap.clear(); |
| restoreTreeSelection(); |
| updateControls(); |
| } |
| |
| private boolean isAnyThemeChanged() { |
| return currentTheme != workbench.getThemeManager().getCurrentTheme() |
| || currentCSSTheme != getActiveTheme(); |
| } |
| }; |
| |
| private org.eclipse.e4.ui.css.swt.theme.ITheme currentCSSTheme; |
| |
| private IThemeEngine themeEngine; |
| |
| /** |
| * Create a new instance of the receiver. |
| */ |
| public ColorsAndFontsPreferencePage() { |
| themeRegistry = WorkbenchPlugin.getDefault().getThemeRegistry(); |
| //no-op |
| } |
| |
| /** |
| * {@inheritDoc} |
| * <p> |
| * Everything else except the following string patterns is ignored: |
| * <ul> |
| * <li><strong>selectCategory:</strong>ID - selects and expands the category |
| * with the given ID</li> |
| * <li><strong>selectFont:</strong>ID - selects the font with the given ID</li> |
| * <li><strong>selectColor:</strong>ID - selects the color with the given ID |
| * </li> |
| * </p> |
| * |
| * @param data |
| * the data to be applied |
| */ |
| @Override |
| public void applyData(Object data) { |
| if (tree == null || !(data instanceof String)) |
| return; |
| |
| ThemeRegistry themeRegistry = (ThemeRegistry) tree.getViewer().getInput(); |
| String command = (String) data; |
| if (command.startsWith("selectCategory:")) { //$NON-NLS-1$ |
| String categoryId = command.substring(15); |
| ThemeElementCategory category = themeRegistry.findCategory(categoryId); |
| if (category != null) { |
| selectAndReveal(category); |
| tree.getViewer().expandToLevel(category, 1); |
| } |
| } else if (command.startsWith("selectFont:")) { //$NON-NLS-1$ |
| String id = command.substring(11); |
| FontDefinition fontDef = themeRegistry.findFont(id); |
| if (fontDef != null) { |
| selectAndReveal(fontDef); |
| } |
| } else if (command.startsWith("selectColor:")) { //$NON-NLS-1$ |
| String id = command.substring(12); |
| ColorDefinition colorDef = themeRegistry.findColor(id); |
| if (colorDef != null) { |
| selectAndReveal(colorDef); |
| } |
| } |
| } |
| |
| /** |
| * Selects and reveals the given element. |
| * |
| * @param selection |
| * the object to select and reveal |
| * @since 3.7 |
| */ |
| private void selectAndReveal(Object selection) { |
| TreeViewer viewer = tree.getViewer(); |
| viewer.setSelection(new StructuredSelection(selection), false); |
| viewer.reveal(selection); |
| viewer.getTree().setFocus(); |
| } |
| |
| private static boolean equals(String string, String string2) { |
| if ((string == null && string2 == null)) |
| return true; |
| if (string == null || string2 == null) |
| return false; |
| if (string.equals(string2)) |
| return true; |
| return false; |
| } |
| |
| /** |
| * Get the active theme. |
| * |
| * @return the active theme if there is one; <code>null</code> if there |
| * isn't or {@link #themeEngine} is <code>null</code>. |
| */ |
| private org.eclipse.e4.ui.css.swt.theme.ITheme getActiveTheme() { |
| if (themeEngine != null) { |
| return themeEngine.getActiveTheme(); |
| } |
| return null; |
| } |
| |
| /** |
| * Create a button for the preference page. |
| * @param parent |
| * @param label |
| */ |
| private Button createButton(Composite parent, String label) { |
| Button button = new Button(parent, SWT.PUSH | SWT.CENTER); |
| button.setText(label); |
| myApplyDialogFont(button); |
| setButtonLayoutData(button); |
| button.setEnabled(false); |
| return button; |
| } |
| |
| private Label createSeparator(Composite parent) { |
| Label separator = new Label(parent, SWT.NONE); |
| separator.setFont(parent.getFont()); |
| separator.setVisible(false); |
| GridData gd = new GridData(); |
| gd.horizontalAlignment = GridData.FILL; |
| gd.verticalAlignment = GridData.BEGINNING; |
| gd.heightHint = 4; |
| separator.setLayoutData(gd); |
| return separator; |
| } |
| |
| @Override |
| protected Control createContents(Composite parent) { |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, IWorkbenchHelpContextIds.FONTS_PREFERENCE_PAGE); |
| |
| parent.addDisposeListener(e -> { |
| if (appliedDialogFont != null) |
| appliedDialogFont.dispose(); |
| }); |
| |
| final SashForm advancedComposite = new SashForm(parent, SWT.VERTICAL); |
| GridData sashData = new GridData(SWT.FILL, SWT.FILL, true, true); |
| advancedComposite.setLayoutData(sashData); |
| |
| Composite mainColumn = new Composite(advancedComposite, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.marginWidth = 0; |
| layout.marginHeight = 0; |
| mainColumn.setFont(parent.getFont()); |
| mainColumn.setLayout(layout); |
| |
| GridData data = new GridData(GridData.BEGINNING); |
| data.horizontalSpan = 2; |
| Label label = new Label(mainColumn, SWT.LEFT); |
| label.setText(RESOURCE_BUNDLE.getString("colorsAndFonts")); //$NON-NLS-1$ |
| myApplyDialogFont(label); |
| label.setLayoutData(data); |
| |
| createTree(mainColumn); |
| |
| // --- buttons |
| Composite controlColumn = new Composite(mainColumn, SWT.NONE); |
| data = new GridData(GridData.FILL_VERTICAL); |
| controlColumn.setLayoutData(data); |
| layout = new GridLayout(); |
| layout.marginHeight = 0; |
| layout.marginWidth = 0; |
| controlColumn.setLayout(layout); |
| |
| // we need placeholder to offset the filter control of the table |
| Label placeholder = new Label(controlColumn, SWT.NONE); |
| GridData placeholderData = new GridData(SWT.TOP); |
| placeholderData.heightHint = convertVerticalDLUsToPixels(12); |
| placeholder.setLayoutData(placeholderData); |
| |
| fontChangeButton = createButton(controlColumn, RESOURCE_BUNDLE.getString("openChange")); //$NON-NLS-1$ |
| fontSystemButton = createButton(controlColumn, WorkbenchMessages.FontsPreference_useSystemFont); |
| fontResetButton = createButton(controlColumn, RESOURCE_BUNDLE.getString("reset")); //$NON-NLS-1$ |
| createSeparator(controlColumn); |
| editDefaultButton = createButton(controlColumn, RESOURCE_BUNDLE.getString("editDefault")); //$NON-NLS-1$ |
| goToDefaultButton = createButton(controlColumn, RESOURCE_BUNDLE.getString("goToDefault")); //$NON-NLS-1$ |
| createSeparator(controlColumn); |
| expandAllButton = createButton(controlColumn, RESOURCE_BUNDLE.getString("expandAll")); //$NON-NLS-1$ |
| expandAllButton.setEnabled(true); |
| // --- end of buttons |
| |
| createDescriptionControl(mainColumn); |
| |
| Composite previewColumn = new Composite(advancedComposite, SWT.NONE); |
| GridLayout previewLayout = new GridLayout(); |
| previewLayout.marginTop = 7; |
| previewLayout.marginWidth = 0; |
| previewLayout.marginHeight = 0; |
| previewColumn.setFont(parent.getFont()); |
| previewColumn.setLayout(previewLayout); |
| |
| // --- create preview control |
| Composite composite = new Composite(previewColumn, SWT.NONE); |
| |
| GridData data2 = new GridData(GridData.FILL_BOTH); |
| composite.setLayoutData(data2); |
| GridLayout layout2 = new GridLayout(1, true); |
| layout2.marginHeight = 0; |
| layout2.marginWidth = 0; |
| composite.setLayout(layout2); |
| |
| Label label2 = new Label(composite, SWT.LEFT); |
| label2.setText(RESOURCE_BUNDLE.getString("preview")); //$NON-NLS-1$ |
| myApplyDialogFont(label2); |
| |
| previewComposite = new Composite(composite, SWT.NONE); |
| previewComposite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| stackLayout = new StackLayout(); |
| stackLayout.marginHeight = 0; |
| stackLayout.marginWidth = 0; |
| previewComposite.setLayout(stackLayout); |
| // -- end of preview control |
| |
| |
| defaultFontPreview = createFontPreviewControl(); |
| defaultColorPreview = createColorPreviewControl(); |
| defaultNoPreview = createNoPreviewControl(); |
| |
| hookListeners(); |
| |
| updateTreeSelection(tree.getViewer().getSelection()); |
| |
| advancedComposite.setWeights(new int[] { 75, 25 }); |
| return advancedComposite; |
| } |
| |
| /** |
| * Create the <code>ListViewer</code> that will contain all color |
| * definitions as defined in the extension point. |
| * |
| * @param parent |
| * the parent <code>Composite</code>. |
| */ |
| private void createTree(Composite parent) { |
| labelProvider = new PresentationLabelProvider(); |
| |
| // Create a custom pattern matcher that will allow |
| // non-category elements to be returned in the event that their children |
| // do not and also search the descriptions. |
| PatternFilter filter = new PatternFilter() { |
| @Override |
| protected boolean isLeafMatch(Viewer viewer, Object element) { |
| if (super.isLeafMatch(viewer, element)) |
| return true; |
| |
| String text = null; |
| if (element instanceof ICategorizedThemeElementDefinition) |
| text = ((ICategorizedThemeElementDefinition) element).getDescription(); |
| |
| return text != null ? wordMatches(text) : false; |
| } |
| }; |
| filter.setIncludeLeadingWildcard(true); |
| |
| tree = new FilteredTree(parent, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER, |
| filter, true); |
| tree.setQuickSelectionMode(true); |
| GridData data = new GridData(GridData.FILL_BOTH | GridData.VERTICAL_ALIGN_FILL); |
| data.widthHint = Math.max(285, convertWidthInCharsToPixels(30)); |
| data.heightHint = Math.max(175, convertHeightInCharsToPixels(10)); |
| tree.setLayoutData(data); |
| myApplyDialogFont(tree.getViewer().getControl()); |
| Text filterText = tree.getFilterControl(); |
| if (filterText != null) |
| myApplyDialogFont(filterText); |
| |
| tree.getViewer().setLabelProvider(labelProvider); |
| tree.getViewer().setContentProvider(new ThemeContentProvider()); |
| tree.getViewer().setComparator(new ViewerComparator() { |
| @Override |
| public int category(Object element) { |
| if (element instanceof ThemeElementCategory) |
| return 0; |
| return 1; |
| } |
| }); |
| tree.getViewer().setInput(WorkbenchPlugin.getDefault().getThemeRegistry()); |
| tree.getViewer().addDoubleClickListener(event -> { |
| IStructuredSelection s = (IStructuredSelection) event.getSelection(); |
| Object element = s.getFirstElement(); |
| if (tree.getViewer().isExpandable(element)) |
| tree.getViewer().setExpandedState(element, |
| !tree.getViewer().getExpandedState(element)); |
| |
| if (element instanceof ThemeElementDefinition) { |
| ThemeElementDefinition definition = (ThemeElementDefinition) element; |
| |
| if (element instanceof FontDefinition) { |
| editFont(tree.getDisplay()); |
| } else if (element instanceof ColorDefinition |
| && isAvailableInCurrentTheme(definition)) { |
| editColor(tree.getDisplay()); |
| } |
| updateControls(); |
| } |
| }); |
| |
| restoreTreeExpansion(); |
| restoreTreeSelection(); |
| } |
| |
| @Override |
| public void dispose() { |
| eventBroker.unsubscribe(themeRegistryRestyledHandler); |
| workbench.getThemeManager().removePropertyChangeListener(themeChangeListener); |
| clearPreviews(); |
| colorRegistry.dispose(); |
| fontRegistry.dispose(); |
| super.dispose(); |
| } |
| |
| /** |
| * Clear all previews. |
| */ |
| private void clearPreviews() { |
| if (cascadingTheme != null) |
| cascadingTheme.dispose(); |
| |
| for (Iterator i = previewSet.iterator(); i.hasNext();) { |
| IThemePreview preview = (IThemePreview) i.next(); |
| try { |
| preview.dispose(); |
| } catch (RuntimeException e) { |
| WorkbenchPlugin.log(RESOURCE_BUNDLE.getString("errorDisposePreviewLog"), //$NON-NLS-1$ |
| StatusUtil.newStatus(IStatus.ERROR, e.getMessage(), e)); |
| } |
| } |
| previewSet.clear(); |
| } |
| |
| /** |
| * Get the ancestor of the given color, if any. |
| * |
| * @param definition the descendant <code>ColorDefinition</code>. |
| * @return the ancestor <code>ColorDefinition</code>, or <code>null</code> |
| * if none. |
| */ |
| private ColorDefinition getColorAncestor(ColorDefinition definition) { |
| String defaultsTo = definition.getDefaultsTo(); |
| if (defaultsTo == null) |
| return null; |
| return themeRegistry.findColor(defaultsTo); |
| } |
| |
| /** |
| * Get the RGB value of the given colors ancestor, if any. |
| * |
| * @param definition the descendant <code>ColorDefinition</code>. |
| * @return the ancestor <code>RGB</code>, or <code>null</code> if none. |
| */ |
| private RGB getColorAncestorValue(ColorDefinition definition) { |
| ColorDefinition ancestor = getColorAncestor(definition); |
| if (ancestor == null) |
| return null; |
| return getColorValue(ancestor); |
| } |
| |
| /** |
| * Get the RGB value for the specified definition. Cascades through |
| * preferenceToSet, valuesToSet and finally the registry. |
| * |
| * @param definition the <code>ColorDefinition</code>. |
| * @return the <code>RGB</code> value. |
| */ |
| private RGB getColorValue(ColorDefinition definition) { |
| String id = definition.getId(); |
| RGB updatedRGB = colorPreferencesToSet.get(definition); |
| if (updatedRGB == null) { |
| updatedRGB = (RGB) colorValuesToSet.get(id); |
| if (updatedRGB == null) |
| updatedRGB = currentTheme.getColorRegistry().getRGB(id); |
| } |
| return updatedRGB; |
| } |
| |
| /** |
| * Get colors that descend from the provided color. |
| * |
| * @param definition the ancestor <code>ColorDefinition</code>. |
| * @return the ColorDefinitions that have the provided definition as their |
| * defaultsTo attribute. |
| */ |
| private ColorDefinition[] getDescendantColors(ColorDefinition definition) { |
| List list = new ArrayList(5); |
| String id = definition.getId(); |
| |
| ColorDefinition[] colors = themeRegistry.getColors(); |
| ColorDefinition[] sorted = new ColorDefinition[colors.length]; |
| System.arraycopy(colors, 0, sorted, 0, sorted.length); |
| |
| Arrays.sort(sorted, new IThemeRegistry.HierarchyComparator(colors)); |
| |
| for (ColorDefinition colorDefinition : sorted) { |
| if (id.equals(colorDefinition.getDefaultsTo())) |
| list.add(colorDefinition); |
| } |
| return (ColorDefinition[]) list.toArray(new ColorDefinition[list.size()]); |
| } |
| |
| private FontDefinition[] getDescendantFonts(FontDefinition definition) { |
| List list = new ArrayList(5); |
| String id = definition.getId(); |
| |
| FontDefinition[] fonts = themeRegistry.getFonts(); |
| FontDefinition[] sorted = new FontDefinition[fonts.length]; |
| System.arraycopy(fonts, 0, sorted, 0, sorted.length); |
| |
| Arrays.sort(sorted, new IThemeRegistry.HierarchyComparator(fonts)); |
| |
| for (FontDefinition fontDefinition : sorted) { |
| if (id.equals(fontDefinition.getDefaultsTo())) |
| list.add(fontDefinition); |
| } |
| return (FontDefinition[]) list.toArray(new FontDefinition[list.size()]); |
| } |
| |
| private FontDefinition getFontAncestor(FontDefinition definition) { |
| String defaultsTo = definition.getDefaultsTo(); |
| if (defaultsTo == null) |
| return null; |
| return themeRegistry.findFont(defaultsTo); |
| } |
| |
| private FontData[] getFontAncestorValue(FontDefinition definition) { |
| FontDefinition ancestor = getFontAncestor(definition); |
| if (ancestor == null) { |
| return PreferenceConverter.getDefaultFontDataArray( |
| getPreferenceStore(), |
| createPreferenceKey(definition)); |
| } |
| return getFontValue(ancestor); |
| } |
| |
| protected FontData[] getFontValue(FontDefinition definition) { |
| String id = definition.getId(); |
| FontData[] updatedFD = fontPreferencesToSet.get(definition); |
| if (updatedFD == null) { |
| updatedFD = (FontData[]) fontValuesToSet.get(id); |
| if (updatedFD == null) |
| updatedFD = currentTheme.getFontRegistry().getFontData(id); |
| } |
| return updatedFD; |
| } |
| |
| protected ColorDefinition getSelectedColorDefinition() { |
| Object o = tree.getViewer().getStructuredSelection().getFirstElement(); |
| if (o instanceof ColorDefinition) { |
| return themeRegistry.findColor(((ColorDefinition) o).getId()); |
| } |
| return null; |
| } |
| |
| protected FontDefinition getSelectedFontDefinition() { |
| Object o = tree.getViewer().getStructuredSelection().getFirstElement(); |
| if (o instanceof FontDefinition) { |
| return themeRegistry.findFont(((FontDefinition) o).getId()); |
| } |
| return null; |
| } |
| |
| protected boolean isFontSelected() { |
| Object o = tree.getViewer().getStructuredSelection().getFirstElement(); |
| return (o instanceof FontDefinition); |
| } |
| |
| protected boolean isColorSelected() { |
| Object o = tree.getViewer().getStructuredSelection().getFirstElement(); |
| return (o instanceof ColorDefinition); |
| } |
| |
| /** |
| * Hook all control listeners. |
| */ |
| private void hookListeners() { |
| TreeViewer viewer = tree.getViewer(); |
| viewer.addSelectionChangedListener(event -> updateTreeSelection(event.getSelection())); |
| |
| fontChangeButton.addSelectionListener(widgetSelectedAdapter(event -> { |
| Display display = event.display; |
| if (isFontSelected()) |
| editFont(display); |
| else if (isColorSelected()) |
| editColor(display); |
| updateControls(); |
| })); |
| |
| fontResetButton.addSelectionListener(widgetSelectedAdapter(e -> { |
| if (isFontSelected()) |
| resetFont(getSelectedFontDefinition(), false); |
| else if (isColorSelected()) |
| resetColor(getSelectedColorDefinition(), false); |
| updateControls(); |
| })); |
| |
| fontSystemButton.addSelectionListener(widgetSelectedAdapter(event -> { |
| FontDefinition definition = getSelectedFontDefinition(); |
| if (definition == null) |
| return; |
| FontData[] defaultFontData = JFaceResources.getDefaultFont().getFontData(); |
| setFontPreferenceValue(definition, defaultFontData, false); |
| updateControls(); |
| })); |
| |
| editDefaultButton.addSelectionListener(widgetSelectedAdapter(event -> { |
| Display display = event.display; |
| FontDefinition fontDefinition = getSelectedFontDefinition(); |
| if (fontDefinition != null) { |
| String defaultFontId = fontDefinition.getDefaultsTo(); |
| FontDefinition defaultFontDefinition = themeRegistry.findFont(defaultFontId); |
| editFont(defaultFontDefinition, display); |
| } else { |
| ColorDefinition colorDefinition = getSelectedColorDefinition(); |
| if (colorDefinition != null) { |
| String defaultColorId = colorDefinition.getDefaultsTo(); |
| ColorDefinition defaultColorDefinition = themeRegistry |
| .findColor(defaultColorId); |
| editColor(defaultColorDefinition, display); |
| } |
| } |
| updateControls(); |
| })); |
| |
| goToDefaultButton.addSelectionListener(widgetSelectedAdapter(event -> { |
| FontDefinition fontDefinition = getSelectedFontDefinition(); |
| if (fontDefinition != null) { |
| String defaultFontId = fontDefinition.getDefaultsTo(); |
| FontDefinition defaultFontDefinition = themeRegistry.findFont(defaultFontId); |
| selectAndReveal(defaultFontDefinition); |
| } else { |
| ColorDefinition colorDefinition = getSelectedColorDefinition(); |
| if (colorDefinition != null) { |
| String defaultColorId = colorDefinition.getDefaultsTo(); |
| ColorDefinition defaultColorDefinition = themeRegistry |
| .findColor(defaultColorId); |
| selectAndReveal(defaultColorDefinition); |
| } |
| } |
| updateControls(); |
| })); |
| |
| expandAllButton.addSelectionListener(widgetSelectedAdapter(event -> tree.getViewer().expandAll())); |
| |
| } |
| |
| @Override |
| public void init(IWorkbench aWorkbench) { |
| this.workbench = (Workbench) aWorkbench; |
| themeEngine = workbench.getService(IThemeEngine.class); |
| setPreferenceStore(PrefUtil.getInternalPreferenceStore()); |
| |
| final IThemeManager themeManager = aWorkbench.getThemeManager(); |
| themeChangeListener = event -> { |
| if (event.getProperty().equals( |
| IThemeManager.CHANGE_CURRENT_THEME)) { |
| updateThemeInfo(themeManager); |
| refreshCategory(); |
| refreshAllLabels(); |
| } |
| }; |
| themeManager.addPropertyChangeListener(themeChangeListener); |
| |
| updateThemeInfo(themeManager); |
| |
| eventBroker = workbench.getService(IEventBroker.class); |
| eventBroker.subscribe(WorkbenchThemeManager.Events.THEME_REGISTRY_RESTYLED, |
| themeRegistryRestyledHandler); |
| } |
| |
| private void updateThemeInfo(IThemeManager manager) { |
| clearPreviews(); |
| categoryMap.clear(); |
| |
| if (labelProvider != null) |
| labelProvider.dispose(); // nuke the old cache |
| |
| if (colorRegistry != null) |
| colorRegistry.dispose(); |
| if (fontRegistry != null) |
| fontRegistry.dispose(); |
| |
| currentTheme = manager.getCurrentTheme(); |
| |
| currentCSSTheme = getActiveTheme(); |
| |
| colorRegistry = new CascadingColorRegistry(currentTheme.getColorRegistry()); |
| fontRegistry = new CascadingFontRegistry(currentTheme.getFontRegistry()); |
| |
| if (cascadingTheme != null) { |
| cascadingTheme.dispose(); |
| cascadingTheme = new CascadingThemeExt(currentTheme, colorRegistry, fontRegistry); |
| } |
| |
| fontPreferencesToSet.clear(); |
| fontValuesToSet.clear(); |
| |
| colorPreferencesToSet.clear(); |
| colorValuesToSet.clear(); |
| |
| if (labelProvider != null) |
| labelProvider.hookListeners(); // rehook the listeners |
| } |
| |
| /** |
| * Answers whether the definition is currently set to the default value. |
| * |
| * @param definition the <code>ColorDefinition</code> to check. |
| * @return Return whether the definition is currently mapped to the default |
| * value, either in the preference store or in the local change record |
| * of this preference page. |
| */ |
| private boolean isDefault(ColorDefinition definition) { |
| String id = definition.getId(); |
| |
| if (colorPreferencesToSet.containsKey(definition)) { |
| if (definition.getValue() != null) { // value-based color |
| if (colorPreferencesToSet.get(definition).equals(definition.getValue())) |
| return true; |
| } else { |
| if (colorPreferencesToSet.get(definition).equals(getColorAncestorValue(definition))) |
| return true; |
| } |
| } else if (colorValuesToSet.containsKey(id)) { |
| if (definition.getValue() != null) { // value-based color |
| if (colorValuesToSet.get(id).equals(definition.getValue())) |
| return true; |
| } else { |
| if (colorValuesToSet.get(id).equals(getColorAncestorValue(definition))) |
| return true; |
| } |
| } else { |
| if (definition.getValue() != null) { // value-based color |
| if (getPreferenceStore().isDefault(createPreferenceKey(definition))) |
| return true; |
| } else { |
| // a descendant is default if it's the same value as its ancestor |
| RGB rgb = getColorValue(definition); |
| if (rgb != null && rgb.equals(getColorAncestorValue(definition))) |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean isDefault(FontDefinition definition) { |
| String id = definition.getId(); |
| |
| if (fontPreferencesToSet.containsKey(definition)) { |
| if (definition.getValue() != null) { // value-based font |
| if (Arrays.equals(fontPreferencesToSet.get(definition), |
| definition.getValue())) |
| return true; |
| } else { |
| FontData[] ancestor = getFontAncestorValue(definition); |
| if (Arrays.equals(fontPreferencesToSet.get(definition), ancestor)) |
| return true; |
| } |
| } else if (fontValuesToSet.containsKey(id)) { |
| if (definition.getValue() != null) { // value-based font |
| if (Arrays.equals((FontData[]) fontValuesToSet.get(id), definition.getValue())) |
| return true; |
| } else { |
| FontData[] ancestor = getFontAncestorValue(definition); |
| if (Arrays.equals((FontData[]) fontValuesToSet.get(id), ancestor)) |
| return true; |
| } |
| |
| } else { |
| if (definition.getValue() != null) { // value-based font |
| if (getPreferenceStore().isDefault(createPreferenceKey(definition))) |
| return true; |
| } else { |
| FontData[] ancestor = getFontAncestorValue(definition); |
| if (ancestor == null) |
| return true; |
| // a descendant is default if it's the same value as its ancestor |
| if (Arrays.equals(getFontValue(definition), ancestor)) |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Apply the dialog font to the control and store |
| * it for later so that it can be used for a later |
| * update. |
| * @param control |
| */ |
| private void myApplyDialogFont(Control control) { |
| control.setFont(JFaceResources.getDialogFont()); |
| dialogFontWidgets.add(control); |
| } |
| |
| /** |
| * @see org.eclipse.jface.preference.PreferencePage#performApply() |
| */ |
| @Override |
| protected void performApply() { |
| super.performApply(); |
| |
| //Apply the default font to the dialog. |
| Font oldFont = appliedDialogFont; |
| FontDefinition fontDefinition = themeRegistry.findFont(JFaceResources.DIALOG_FONT); |
| if (fontDefinition == null) |
| return; |
| FontData[] newData = getFontValue(fontDefinition); |
| |
| appliedDialogFont = new Font(getControl().getDisplay(), newData); |
| |
| updateForDialogFontChange(appliedDialogFont); |
| getApplyButton().setFont(appliedDialogFont); |
| getDefaultsButton().setFont(appliedDialogFont); |
| |
| if (oldFont != null) { |
| oldFont.dispose(); |
| } |
| |
| if (performColorOk() && performFontOk()) { |
| publishThemeRegistryModifiedEvent(); |
| } |
| } |
| |
| private void performColorDefaults() { |
| ColorDefinition[] definitions = themeRegistry.getColors(); |
| |
| // apply defaults in depth-order. |
| ColorDefinition[] definitionsCopy = new ColorDefinition[definitions.length]; |
| System.arraycopy(definitions, 0, definitionsCopy, 0,definitions.length); |
| |
| Arrays.sort(definitionsCopy, new IThemeRegistry.HierarchyComparator(definitions)); |
| |
| for (ColorDefinition colorDefinition : definitionsCopy) { |
| resetColor(colorDefinition, true); |
| } |
| } |
| |
| private boolean performColorOk() { |
| for (Map.Entry<ColorDefinition, RGB> entry : colorPreferencesToSet.entrySet()) { |
| String key = createPreferenceKey(entry.getKey()); |
| String rgbString = StringConverter.asString(entry.getValue()); |
| String storeString = getPreferenceStore().getString(key); |
| |
| if (!rgbString.equals(storeString)) |
| getPreferenceStore().setValue(key, rgbString); |
| } |
| |
| colorValuesToSet.clear(); |
| colorPreferencesToSet.clear(); |
| return true; |
| } |
| |
| private String createPreferenceKey(ThemeElementDefinition definition) { |
| if (definition.isOverridden() || definition.isAddedByCss()) { |
| return ThemeElementHelper.createPreferenceKey(currentCSSTheme, currentTheme, |
| definition.getId()); |
| } |
| return ThemeElementHelper.createPreferenceKey(currentTheme, definition.getId()); |
| } |
| |
| @Override |
| public void performDefaults() { |
| performColorDefaults(); |
| performFontDefaults(); |
| updateControls(); |
| tree.getViewer().refresh(); |
| } |
| |
| private void performFontDefaults() { |
| FontDefinition[] definitions = themeRegistry.getFonts(); |
| |
| // apply defaults in depth-order. |
| FontDefinition[] definitionsCopy = new FontDefinition[definitions.length]; |
| System.arraycopy(definitions, 0, definitionsCopy, 0, definitions.length); |
| |
| Arrays.sort(definitionsCopy, new IThemeRegistry.HierarchyComparator(definitions)); |
| |
| for (FontDefinition fontDefinition : definitionsCopy) { |
| resetFont(fontDefinition, true); |
| } |
| } |
| |
| private boolean performFontOk() { |
| for (Map.Entry<FontDefinition, FontData[]> entry : fontPreferencesToSet.entrySet()) { |
| String key = createPreferenceKey(entry.getKey()); |
| String fdString = PreferenceConverter.getStoredRepresentation(entry.getValue()); |
| String storeString = getPreferenceStore().getString(key); |
| |
| if (!fdString.equals(storeString)) |
| getPreferenceStore().setValue(key, fdString); |
| } |
| |
| fontValuesToSet.clear(); |
| fontPreferencesToSet.clear(); |
| return true; |
| } |
| |
| @Override |
| public boolean performOk() { |
| saveTreeExpansion(); |
| saveTreeSelection(); |
| boolean result = performColorOk() && performFontOk(); |
| if (result) { |
| PrefUtil.savePrefs(); |
| publishThemeRegistryModifiedEvent(); |
| } |
| return result; |
| } |
| |
| /** |
| * Refreshes the category. |
| */ |
| private void refreshCategory() { |
| updateControls(); |
| } |
| |
| /** |
| * Resets the supplied definition to its default value. |
| * |
| * @param definition the <code>ColorDefinition</code> to reset. |
| * @return whether any change was made. |
| */ |
| private boolean resetColor(ColorDefinition definition, boolean force) { |
| if (force || !isDefault(definition)) { |
| RGB newRGB; |
| if (definition.getValue() != null) |
| newRGB = definition.getValue(); |
| else |
| newRGB = getColorAncestorValue(definition); |
| |
| if (newRGB != null) { |
| setColorPreferenceValue(definition, newRGB, true); |
| setRegistryValue(definition, newRGB); |
| refreshElement(definition); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| protected boolean resetFont(FontDefinition definition, boolean force) { |
| if (force || !isDefault(definition)) { |
| FontData[] newFD; |
| if (definition.isOverridden()) { |
| newFD = definition.getValue(); |
| } else if (!force && definition.getDefaultsTo() != null) { |
| newFD = getFontAncestorValue(definition); |
| } else { |
| newFD = PreferenceConverter.getDefaultFontDataArray(getPreferenceStore(), |
| createPreferenceKey(definition)); |
| } |
| if (newFD != null) { |
| setFontPreferenceValue(definition, newFD, true); |
| refreshElement(definition); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Set the value (in preferences) for the given color. |
| * |
| * @param definition the <code>ColorDefinition</code> to set. |
| * @param newRGB the new <code>RGB</code> value for the definitions |
| * identifier. |
| */ |
| protected void setColorPreferenceValue(ColorDefinition definition, RGB newRGB, boolean reset) { |
| setDescendantRegistryValues(definition, newRGB); |
| colorPreferencesToSet.put(definition, newRGB); |
| updateDefinitionState(definition, reset); |
| } |
| |
| /** |
| * Set the value (in registry) for the given colors children. |
| * |
| * @param definition the <code>ColorDefinition</code> whose children should |
| * be set. |
| * @param newRGB the new <code>RGB</code> value for the definitions |
| * identifier. |
| */ |
| private void setDescendantRegistryValues(ColorDefinition definition, RGB newRGB) { |
| for (ColorDefinition colorDefinition : getDescendantColors(definition)) { |
| if (isDefault(colorDefinition)) { |
| setDescendantRegistryValues(colorDefinition, newRGB); |
| setRegistryValue(colorDefinition, newRGB); |
| colorValuesToSet.put(colorDefinition.getId(), newRGB); |
| } |
| } |
| } |
| |
| private void setDescendantRegistryValues(FontDefinition definition, FontData[] datas, boolean reset) { |
| for (FontDefinition fontDefinition : getDescendantFonts(definition)) { |
| if (isDefault(fontDefinition)) { |
| setFontPreferenceValue(fontDefinition, datas, reset); |
| } |
| } |
| } |
| |
| protected void setFontPreferenceValue(FontDefinition definition, FontData[] datas, boolean reset) { |
| // descendant values must be computed and set before updating current, |
| // or isDefault will miss them |
| setDescendantRegistryValues(definition, datas, reset); |
| fontPreferencesToSet.put(definition, datas); |
| setRegistryValue(definition, datas); |
| updateDefinitionState(definition, reset); |
| } |
| |
| /** |
| * Updates the working registry. |
| * @param definition |
| * @param newRGB |
| */ |
| protected void setRegistryValue(ColorDefinition definition, RGB newRGB) { |
| colorRegistry.put(definition.getId(), newRGB); |
| } |
| |
| protected void setRegistryValue(FontDefinition definition, FontData[] datas) { |
| fontRegistry.put(definition.getId(), datas); |
| } |
| |
| /** |
| * Returns the preview for the category. |
| * @param category the category |
| * @return the preview for the category, or its ancestors preview if it does not have one. |
| */ |
| private IThemePreview getThemePreview(ThemeElementCategory category) throws CoreException { |
| IThemePreview preview = category.createPreview(); |
| if (preview != null) |
| return preview; |
| |
| if (category.getParentId() != null) { |
| int idx = Arrays.binarySearch(themeRegistry.getCategories(), |
| category.getParentId(), IThemeRegistry.ID_COMPARATOR); |
| if (idx >= 0) |
| return getThemePreview(themeRegistry.getCategories()[idx]); |
| } |
| return null; |
| } |
| |
| private CascadingThemeExt getCascadingTheme() { |
| if (cascadingTheme == null) { |
| cascadingTheme = new CascadingThemeExt(currentTheme, colorRegistry, fontRegistry); |
| } |
| return cascadingTheme; |
| } |
| |
| /** |
| * Update for a change in the dialog font. |
| * @param newFont |
| */ |
| private void updateForDialogFontChange(Font newFont) { |
| Iterator iterator = dialogFontWidgets.iterator(); |
| while (iterator.hasNext()) { |
| ((Control) iterator.next()).setFont(newFont); |
| } |
| |
| //recalculate the fonts for the tree |
| labelProvider.clearFontCacheAndUpdate(); |
| } |
| |
| private void updateTreeSelection(ISelection selection) { |
| ThemeElementCategory category = null; |
| Object element = ((IStructuredSelection) selection).getFirstElement(); |
| if (element instanceof ThemeElementCategory) { |
| category = (ThemeElementCategory) element; |
| } else if (element instanceof ColorDefinition) { |
| String categoryID = ((ColorDefinition) element).getCategoryId(); |
| category = WorkbenchPlugin.getDefault().getThemeRegistry().findCategory(categoryID); |
| } else if (element instanceof FontDefinition) { |
| String categoryID = ((FontDefinition) element).getCategoryId(); |
| category = WorkbenchPlugin.getDefault().getThemeRegistry().findCategory(categoryID); |
| } |
| Composite previewControl = null; |
| if (category != null) { // check if there is a preview for it |
| previewControl = (Composite) previewMap.get(category); |
| if (previewControl == null) { |
| try { |
| IThemePreview preview = getThemePreview(category); |
| if (preview != null) { |
| previewControl = new Composite(previewComposite, SWT.NONE); |
| previewControl.setLayout(new FillLayout()); |
| ITheme theme = getCascadingTheme(); |
| preview.createControl(previewControl, theme); |
| previewSet.add(preview); |
| previewMap.put(category, previewControl); |
| } |
| } catch (CoreException e) { |
| previewControl = new Composite(previewComposite, SWT.NONE); |
| previewControl.setLayout(new FillLayout()); |
| myApplyDialogFont(previewControl); |
| Text error = new Text(previewControl, SWT.WRAP | SWT.READ_ONLY); |
| error.setText(RESOURCE_BUNDLE.getString("errorCreatingPreview")); //$NON-NLS-1$ |
| WorkbenchPlugin.log(RESOURCE_BUNDLE.getString("errorCreatePreviewLog"), //$NON-NLS-1$ |
| StatusUtil.newStatus(IStatus.ERROR, e.getMessage(), e)); |
| } |
| } |
| } |
| |
| if (previewControl == null) { // there is no preview for this theme, use default preview |
| if (element instanceof ColorDefinition) |
| previewControl = defaultColorPreview; |
| else if (element instanceof FontDefinition) |
| previewControl = defaultFontPreview; |
| else |
| previewControl = defaultNoPreview; |
| } |
| |
| stackLayout.topControl = previewControl; |
| previewComposite.layout(); |
| updateControls(); |
| } |
| |
| /** |
| * Restore the selection state of the tree. |
| * @since 3.1 |
| */ |
| private void restoreTreeSelection() { |
| String selectedElementString = getPreferenceStore().getString(SELECTED_ELEMENT_PREF); |
| if (selectedElementString == null) |
| return; |
| Object element = findElementFromMarker(selectedElementString); |
| if (element == null) |
| return; |
| tree.getViewer().setSelection(new StructuredSelection(element), true); |
| } |
| |
| /** |
| * Save the selection state of the tree. |
| * @since 3.1 |
| */ |
| private void saveTreeSelection() { |
| IStructuredSelection selection = tree.getViewer().getStructuredSelection(); |
| Object element = selection.getFirstElement(); |
| StringBuffer buffer = new StringBuffer(); |
| appendMarkerToBuffer(buffer, element); |
| if (buffer.length() > 0) |
| buffer.append(((IThemeElementDefinition) element).getId()); |
| getPreferenceStore().setValue(SELECTED_ELEMENT_PREF, buffer.toString()); |
| } |
| |
| /** |
| * Restore the expansion state of the tree. |
| * @since 3.1 |
| */ |
| private void restoreTreeExpansion() { |
| String expandedElementsString = getPreferenceStore().getString(EXPANDED_ELEMENTS_PREF); |
| if (expandedElementsString == null) |
| return; |
| String[] expandedElementIDs = expandedElementsString.split(EXPANDED_ELEMENTS_TOKEN); |
| if (expandedElementIDs.length == 0) |
| return; |
| |
| List elements = new ArrayList(expandedElementIDs.length); |
| for (String expandedElementID : expandedElementIDs) { |
| IThemeElementDefinition def = findElementFromMarker(expandedElementID); |
| if (def != null) |
| elements.add(def); |
| } |
| tree.getViewer().setExpandedElements(elements.toArray()); |
| } |
| |
| /** |
| * Find the theme element from the given string. It will check the first |
| * character against the known constants and then call the appropriate |
| * method on the theme registry. If the element does not exist or the string |
| * is invalid <code>null</code> is returned. |
| * |
| * @param string the string to parse |
| * @return the element, or <code>null</code> |
| */ |
| private IThemeElementDefinition findElementFromMarker(String string) { |
| if (string.length() < 2) |
| return null; |
| |
| char marker = string.charAt(0); |
| String id = string.substring(1); |
| IThemeElementDefinition def = null; |
| switch (marker) { |
| case MARKER_FONT: |
| def = themeRegistry.findFont(id); |
| break; |
| case MARKER_COLOR: |
| def = themeRegistry.findColor(id); |
| break; |
| case MARKER_CATEGORY: |
| def = themeRegistry.findCategory(id); |
| break; |
| } |
| return def; |
| } |
| |
| /** |
| * Saves the expansion state of the tree. |
| * @since 3.1 |
| */ |
| private void saveTreeExpansion() { |
| Object[] elements = tree.getViewer().getExpandedElements(); |
| List elementIds = new ArrayList(elements.length); |
| |
| StringBuffer buffer = new StringBuffer(); |
| for (Object object : elements) { |
| appendMarkerToBuffer(buffer, object); |
| |
| if (buffer.length() != 0) { |
| buffer.append(((IThemeElementDefinition) object).getId()); |
| elementIds.add(buffer.toString()); |
| } |
| buffer.setLength(0); |
| } |
| |
| for (Iterator i = elementIds.iterator(); i.hasNext();) { |
| String id = (String) i.next(); |
| buffer.append(id); |
| if (i.hasNext()) { |
| buffer.append(EXPANDED_ELEMENTS_TOKEN); |
| } |
| } |
| |
| getPreferenceStore().setValue(EXPANDED_ELEMENTS_PREF, buffer.toString()); |
| } |
| |
| private void appendMarkerToBuffer(StringBuffer buffer, Object object) { |
| if (object instanceof FontDefinition) { |
| buffer.append(MARKER_FONT); |
| } else if (object instanceof ColorDefinition) { |
| buffer.append(MARKER_COLOR); |
| } else if (object instanceof ThemeElementCategory) { |
| buffer.append(MARKER_CATEGORY); |
| } |
| } |
| |
| /** |
| * Edit the currently selected font. |
| * |
| * @param display |
| * the display to open the dialog on |
| * @since 3.2 |
| */ |
| private void editFont(Display display) { |
| editFont(getSelectedFontDefinition(), display); |
| } |
| |
| /** |
| * Edit the given font. |
| * |
| * @param definition |
| * the font definition |
| * @param display |
| * the display to open the dialog on |
| * @since 3.7 |
| */ |
| private void editFont(FontDefinition definition, Display display) { |
| if (definition != null) { |
| final FontDialog fontDialog = new FontDialog(getShell()); |
| fontDialog.setEffectsVisible(false); |
| fontDialog.setFontList(getFontValue(definition)); |
| final FontData data = fontDialog.open(); |
| if (data != null) { |
| setFontPreferenceValue(definition, fontDialog.getFontList(), false); |
| refreshElement(definition); |
| } |
| } |
| } |
| |
| private void editColor(Display display) { |
| editColor(getSelectedColorDefinition(), display); |
| } |
| |
| private void editColor(ColorDefinition definition, Display display) { |
| if (definition == null) |
| return; |
| RGB currentColor = colorRegistry.getRGB(definition.getId()); |
| |
| ColorDialog colorDialog = new ColorDialog(display.getActiveShell()); |
| colorDialog.setRGB(currentColor); |
| RGB selectedColor = colorDialog.open(); |
| if ((selectedColor != null) && (!selectedColor.equals(currentColor))) { |
| setColorPreferenceValue(definition, selectedColor, false); |
| setRegistryValue(definition, selectedColor); |
| refreshElement(definition); |
| } |
| } |
| |
| |
| protected void updateControls() { |
| FontDefinition fontDefinition = getSelectedFontDefinition(); |
| if (fontDefinition != null) { |
| boolean isDefault = isDefault(fontDefinition); |
| boolean hasDefault = fontDefinition.getDefaultsTo() != null; |
| fontChangeButton.setEnabled(true); |
| fontSystemButton.setEnabled(true); |
| fontResetButton.setEnabled(!isDefault); |
| editDefaultButton.setEnabled(hasDefault && isDefault); |
| goToDefaultButton.setEnabled(hasDefault); |
| setCurrentFont(fontDefinition); |
| return; |
| } |
| ColorDefinition colorDefinition = getSelectedColorDefinition(); |
| if (colorDefinition != null) { |
| boolean isDefault = isDefault(getSelectedColorDefinition()); |
| boolean hasDefault = colorDefinition.getDefaultsTo() != null; |
| fontChangeButton.setEnabled(true); |
| fontSystemButton.setEnabled(false); |
| fontResetButton.setEnabled(!isDefault); |
| editDefaultButton.setEnabled(hasDefault && isDefault); |
| goToDefaultButton.setEnabled(hasDefault); |
| setCurrentColor(colorDefinition); |
| return; |
| } |
| // not a font or a color? |
| fontChangeButton.setEnabled(false); |
| fontSystemButton.setEnabled(false); |
| fontResetButton.setEnabled(false); |
| editDefaultButton.setEnabled(false); |
| goToDefaultButton.setEnabled(false); |
| descriptionText.setText(""); //$NON-NLS-1$ |
| } |
| |
| /** |
| * @return Return the default "No preview available." preview. |
| */ |
| private Composite createNoPreviewControl() { |
| Composite noPreviewControl = new Composite(previewComposite, SWT.NONE); |
| noPreviewControl.setLayout(new FillLayout()); |
| Label l = new Label(noPreviewControl, SWT.LEFT); |
| l.setText(RESOURCE_BUNDLE.getString("noPreviewAvailable")); //$NON-NLS-1$ |
| myApplyDialogFont(l); |
| return noPreviewControl; |
| } |
| |
| private void setCurrentFont(FontDefinition fontDefinition) { |
| currentFont = fontRegistry.get(fontDefinition.getId()); |
| FontData[] fontData = currentFont != null ? currentFont.getFontData() : new FontData[0]; |
| |
| // recalculate sample text |
| StringBuffer tmp = new StringBuffer(); |
| for (FontData currentFontData : fontData) { |
| tmp.append(currentFontData.getName()); |
| tmp.append(' '); |
| tmp.append(currentFontData.getHeight()); |
| |
| int style = currentFontData.getStyle(); |
| if ((style & SWT.BOLD) != 0) { |
| tmp.append(' '); |
| tmp.append(RESOURCE_BUNDLE.getString("boldFont")); //$NON-NLS-1$ |
| } |
| if ((style & SWT.ITALIC) != 0) { |
| tmp.append(' '); |
| tmp.append(RESOURCE_BUNDLE.getString("italicFont")); //$NON-NLS-1$ |
| } |
| } |
| fontSampleText = tmp.toString(); |
| descriptionText.setText(fomatDescription(fontDefinition)); |
| fontSampler.redraw(); |
| } |
| |
| public void setCurrentColor(ColorDefinition colorDefinition) { |
| currentColor = colorRegistry.get(colorDefinition.getId()); |
| colorSampler.redraw(); |
| descriptionText.setText(fomatDescription(colorDefinition)); |
| } |
| |
| private Composite createFontPreviewControl() { |
| fontSampler = new Canvas(previewComposite, SWT.NONE); |
| GridLayout gridLayout = new GridLayout(); |
| gridLayout.marginWidth = 0; |
| gridLayout.marginHeight = 0; |
| fontSampler.setLayout(gridLayout); |
| fontSampler.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| fontSampler.addPaintListener(e -> { |
| if (currentFont != null) // do the font preview |
| paintFontSample(e.gc); |
| }); |
| return fontSampler; |
| } |
| |
| private void paintFontSample(GC gc) { |
| if (currentFont == null || currentFont.isDisposed()) |
| return; |
| |
| // draw rectangle all around |
| Rectangle clientArea = colorSampler.getClientArea(); |
| FontMetrics standardFontMetrics = gc.getFontMetrics(); |
| int standardLineHeight = standardFontMetrics.getHeight(); |
| int maxHeight = standardLineHeight * 4; |
| if (clientArea.height > maxHeight) |
| clientArea = new Rectangle(clientArea.x, clientArea.y, clientArea.width, maxHeight); |
| |
| gc.setForeground(previewComposite.getDisplay().getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW)); |
| gc.drawRectangle(0, 0, clientArea.width - 1, clientArea.height - 1); |
| |
| gc.setForeground(previewComposite.getDisplay().getSystemColor(SWT.COLOR_BLACK)); |
| gc.setFont(currentFont); |
| FontMetrics fontMetrics = gc.getFontMetrics(); |
| int lineHeight = fontMetrics.getHeight(); |
| int topY = clientArea.y + 5; |
| |
| gc.setClipping(1, 1, clientArea.width - 2, clientArea.height - 2); |
| gc.drawText(fontSampleText, clientArea.x + 5, topY); |
| gc.drawText(RESOURCE_BUNDLE.getString("fontTextSample"), clientArea.x + 5, topY + lineHeight); //$NON-NLS-1$ |
| } |
| |
| private Composite createColorPreviewControl() { |
| colorSampler = new Canvas(previewComposite, SWT.NONE); |
| GridLayout gridLayout = new GridLayout(); |
| gridLayout.marginWidth = 0; |
| gridLayout.marginHeight = 0; |
| colorSampler.setLayout(gridLayout); |
| colorSampler.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| colorSampler.addPaintListener(e -> { |
| if (currentColor != null) // do the color preview |
| paintColorSample(e.gc); |
| }); |
| return colorSampler; |
| } |
| |
| private void paintColorSample(GC gc) { |
| if (currentColor == null || currentColor.isDisposed()) |
| return; |
| gc.setFont(previewComposite.getDisplay().getSystemFont()); |
| FontMetrics fontMetrics = gc.getFontMetrics(); |
| int lineHeight = fontMetrics.getHeight(); |
| Rectangle clientArea = colorSampler.getClientArea(); |
| int maxHeight = lineHeight * 4; |
| if (clientArea.height > maxHeight) |
| clientArea = new Rectangle(clientArea.x, clientArea.y, clientArea.width, maxHeight); |
| |
| String messageTop = RESOURCE_BUNDLE.getString("fontColorSample"); //$NON-NLS-1$ |
| String fontColorString = RESOURCE_BUNDLE.getString("fontColorString"); //$NON-NLS-1$ |
| RGB rgb = currentColor.getRGB(); |
| String messageBottom = MessageFormat.format(fontColorString, Integer.valueOf(rgb.red), |
| Integer.valueOf(rgb.green), Integer.valueOf(rgb.blue)); |
| |
| // calculate position of the vertical line |
| int separator = (clientArea.width - 2) / 3; |
| |
| // calculate text positions |
| int verticalCenter = clientArea.height / 2; |
| int textTopY = (verticalCenter - lineHeight) / 2; |
| if (textTopY < 1) |
| textTopY = 1; |
| textTopY += clientArea.y; |
| |
| int textBottomY = verticalCenter + textTopY; |
| if (textBottomY > clientArea.height - 2) |
| textBottomY = clientArea.height - 2; |
| textBottomY += clientArea.y; |
| |
| int stringWidthTop = gc.stringExtent(messageTop).x; |
| int textTopX = (separator - stringWidthTop - 1) / 2; |
| if (textTopX < 1) |
| textTopX = 1; |
| textTopX += clientArea.x; |
| |
| int stringWidthBottom = gc.stringExtent(messageBottom).x; |
| int textBottomX = (separator - stringWidthBottom - 1) / 2; |
| if (textBottomX < 1) |
| textBottomX = 1; |
| textBottomX += clientArea.x; |
| |
| // put text on the left - default background |
| gc.setForeground(currentColor); |
| gc.drawText(messageTop, textTopX, textTopY); |
| gc.drawText(messageBottom, textBottomX, textBottomY); |
| |
| // fill right rectangle |
| gc.setBackground(previewComposite.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND)); |
| int rightWidth = clientArea.width - 2 - separator * 2; |
| gc.fillRectangle(separator * 2, 1, rightWidth, clientArea.height - 2); |
| // put text in the right rectangle |
| gc.setForeground(currentColor); |
| gc.drawText(messageTop, separator * 2 + textTopX, textTopY); |
| gc.drawText(messageBottom, separator * 2 + textBottomX, textBottomY); |
| |
| // fill center rectangle |
| gc.setBackground(currentColor); |
| gc.fillRectangle(separator, 1, separator, clientArea.height - 2); |
| // text: center top |
| gc.setForeground(previewComposite.getDisplay().getSystemColor(SWT.COLOR_BLACK)); |
| gc.drawText(messageTop, separator + textTopX, textTopY); |
| gc.setForeground(previewComposite.getDisplay().getSystemColor(SWT.COLOR_WHITE)); |
| gc.drawText(messageBottom, separator + textBottomX, textBottomY); |
| // niceties |
| gc.setForeground(previewComposite.getDisplay().getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW)); |
| gc.drawLine(separator, verticalCenter, separator * 2 - 1, verticalCenter); |
| |
| // draw rectangle all around |
| gc.setForeground(previewComposite.getDisplay().getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW)); |
| gc.drawRectangle(0, 0, clientArea.width - 1, clientArea.height - 1); |
| } |
| |
| private void createDescriptionControl(Composite parent) { |
| Composite composite = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.marginWidth = 0; |
| layout.marginHeight = 0; |
| composite.setLayout(layout); |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| data.horizontalSpan = 2; |
| composite.setLayoutData(data); |
| |
| Label label = new Label(composite, SWT.LEFT); |
| label.setText(RESOURCE_BUNDLE.getString("description")); //$NON-NLS-1$ |
| myApplyDialogFont(label); |
| |
| descriptionText = new Text(composite, SWT.READ_ONLY | SWT.BORDER | SWT.WRAP); |
| data = new GridData(GridData.FILL_BOTH); |
| data.heightHint = convertHeightInCharsToPixels(3); |
| data.widthHint = convertWidthInCharsToPixels(30); |
| descriptionText.setLayoutData(data); |
| myApplyDialogFont(descriptionText); |
| } |
| |
| private void publishThemeRegistryModifiedEvent() { |
| if (eventBroker != null) { |
| eventBroker.send(WorkbenchThemeManager.Events.THEME_REGISTRY_MODIFIED, null); |
| } |
| } |
| |
| private void refreshAllLabels() { |
| tree.getViewer().refresh(); // refresh all the labels in the tree |
| } |
| |
| private boolean isAvailableInCurrentTheme(ThemeElementDefinition definition) { |
| if (definition instanceof ColorDefinition) { |
| ColorDefinition colorDef = (ColorDefinition) definition; |
| RGB value = colorDef.getValue(); |
| if ((value == null || value == EMPTY_COLOR_VALUE) && colorDef.getDefaultsTo() == null) { |
| return false; |
| } |
| return colorRegistry.get(definition.getId()) != null; |
| } |
| return true; |
| } |
| |
| private String fomatDescription(ThemeElementDefinition definition) { |
| String description = definition.getDescription() != null ? definition.getDescription() : ""; //$NON-NLS-1$ |
| if (isAvailableInCurrentTheme(definition)) { |
| return description; |
| } |
| return MessageFormat.format(RESOURCE_BUNDLE.getString("definitionNotAvailInTheme"), //$NON-NLS-1$ |
| description).trim(); |
| } |
| |
| private void updateDefinitionState(ThemeElementDefinition definition, boolean reset) { |
| if (reset) { |
| definition.removeState(ThemeElementDefinition.State.MODIFIED_BY_USER); |
| } else { |
| definition.appendState(ThemeElementDefinition.State.MODIFIED_BY_USER); |
| } |
| } |
| |
| private void refreshElement(ThemeElementDefinition definition) { |
| tree.getViewer().refresh(definition); |
| updateTreeSelection(tree.getViewer().getSelection()); |
| |
| Object newValue = definition instanceof ColorDefinition ? |
| ((ColorDefinition) definition).getValue(): ((FontDefinition) definition).getValue(); |
| getCascadingTheme().fire(new PropertyChangeEvent(this, definition.getId(), null, newValue)); |
| } |
| |
| private static class CascadingThemeExt extends CascadingTheme { |
| /** |
| * @param currentTheme |
| * @param colorRegistry |
| * @param fontRegistry |
| */ |
| public CascadingThemeExt(ITheme currentTheme, CascadingColorRegistry colorRegistry, |
| CascadingFontRegistry fontRegistry) { |
| super(currentTheme, colorRegistry, fontRegistry); |
| } |
| |
| @Override |
| public void fire(PropertyChangeEvent event) { |
| super.fire(event); |
| } |
| |
| } |
| } |
