| /*=============================================================================# |
| # Copyright (c) 2005, 2021 Stephan Wahlbrink and others. |
| # |
| # This program and the accompanying materials are made available under the |
| # terms of the Eclipse Public License 2.0 which is available at |
| # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 |
| # which is available at https://www.apache.org/licenses/LICENSE-2.0. |
| # |
| # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 |
| # |
| # Contributors: |
| # Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation |
| #=============================================================================*/ |
| |
| package org.eclipse.statet.ecommons.text.ui.presentation; |
| |
| import static org.eclipse.statet.ltk.ui.LtkUI.BUNDLE_ID; |
| |
| import java.beans.PropertyChangeListener; |
| import java.io.BufferedReader; |
| import java.io.IOException; |
| import java.io.InputStreamReader; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.databinding.DataBindingContext; |
| import org.eclipse.core.databinding.UpdateValueStrategy; |
| import org.eclipse.core.databinding.beans.typed.BeanProperties; |
| import org.eclipse.core.databinding.observable.Observables; |
| import org.eclipse.core.databinding.observable.Realm; |
| import org.eclipse.core.databinding.observable.list.IObservableList; |
| import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory; |
| import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables; |
| import org.eclipse.core.databinding.observable.value.IObservableValue; |
| import org.eclipse.core.databinding.observable.value.IValueChangeListener; |
| import org.eclipse.core.databinding.observable.value.ValueChangeEvent; |
| import org.eclipse.core.filebuffers.IDocumentSetupParticipant; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.databinding.swt.typed.WidgetProperties; |
| import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; |
| import org.eclipse.jface.databinding.viewers.typed.ViewerProperties; |
| import org.eclipse.jface.preference.ColorSelector; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.preference.PreferenceConverter; |
| import org.eclipse.jface.text.Document; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.TextAttribute; |
| import org.eclipse.jface.text.source.SourceViewer; |
| import org.eclipse.jface.viewers.CellLabelProvider; |
| import org.eclipse.jface.viewers.ColumnViewerToolTipSupport; |
| import org.eclipse.jface.viewers.ComboViewer; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.ViewerCell; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.ui.editors.text.EditorsUI; |
| import org.eclipse.ui.statushandlers.StatusManager; |
| import org.eclipse.ui.texteditor.ChainedPreferenceStore; |
| |
| import org.eclipse.statet.jcommons.collections.ImCollections; |
| import org.eclipse.statet.jcommons.collections.ImList; |
| |
| import org.eclipse.statet.ecommons.databinding.core.conversion.ClassTypedConverter; |
| import org.eclipse.statet.ecommons.preferences.core.Preference; |
| import org.eclipse.statet.ecommons.preferences.ui.ColorSelectorObservableValue; |
| import org.eclipse.statet.ecommons.preferences.ui.OverlayStoreConfigurationBlock; |
| import org.eclipse.statet.ecommons.preferences.ui.OverlayStorePreference; |
| import org.eclipse.statet.ecommons.preferences.ui.PreferenceStoreBeanWrapper; |
| import org.eclipse.statet.ecommons.preferences.ui.RGBPref; |
| import org.eclipse.statet.ecommons.text.ui.TextViewerEditorColorUpdater; |
| import org.eclipse.statet.ecommons.text.ui.TextViewerJFaceUpdater; |
| import org.eclipse.statet.ecommons.text.ui.presentation.AbstractTextStylesConfigurationBlock.SyntaxNode.UseStyle; |
| import org.eclipse.statet.ecommons.text.ui.settings.JFaceTextStyleManager; |
| import org.eclipse.statet.ecommons.text.ui.settings.PreferenceStoreTextStyleManager; |
| import org.eclipse.statet.ecommons.ui.util.LayoutUtils; |
| import org.eclipse.statet.ecommons.ui.util.MessageUtils; |
| import org.eclipse.statet.ecommons.ui.util.PixelConverter; |
| import org.eclipse.statet.ecommons.ui.util.UIAccess; |
| import org.eclipse.statet.ecommons.ui.viewers.ViewerUtils; |
| import org.eclipse.statet.ecommons.ui.viewers.ViewerUtils.Node; |
| |
| import org.eclipse.statet.internal.ecommons.text.ui.Messages; |
| import org.eclipse.statet.ltk.ui.sourceediting.SourceEditorViewerConfiguration; |
| |
| |
| /** |
| * Common UI to configure the text style of syntax tokens (tree, options, preview). |
| */ |
| public abstract class AbstractTextStylesConfigurationBlock extends OverlayStoreConfigurationBlock { |
| // even in text, it currently depends on ltk SourceEditorViewerConfiguration; |
| |
| |
| /** |
| * Generic node of the tree. |
| * |
| * Note: getter and setters in all nodes for easy DataBinding. |
| */ |
| protected static abstract class SyntaxNode extends Node { |
| |
| |
| public static class UseStyle { |
| |
| private final String label; |
| private final String refRootKey; |
| |
| public UseStyle(final String refRootKey, final String label) { |
| super(); |
| this.refRootKey= refRootKey; |
| this.label= label; |
| } |
| |
| public String getLabel() { |
| return this.label; |
| } |
| |
| public String getRefRootKey() { |
| return this.refRootKey; |
| } |
| |
| } |
| |
| public static UseStyle createUseCustomStyle() { |
| return new UseStyle("", Messages.SyntaxColoring_Use_CustomStyle_label); //$NON-NLS-1$ |
| } |
| |
| public static UseStyle createUseNoExtraStyle(final String parentKey) { |
| return new UseStyle(parentKey, Messages.SyntaxColoring_Use_NoExtraStyle_label); |
| } |
| |
| public static UseStyle createUseOtherStyle(final String otherKey, final String otherLabel) { |
| return new UseStyle(otherKey, NLS.bind(Messages.SyntaxColoring_Use_OtherStyle_label, otherLabel)); |
| } |
| |
| public static UseStyle createUseOtherStyle(final String otherKey, final String cat, final String otherLabel) { |
| return new UseStyle(otherKey, NLS.bind(Messages.SyntaxColoring_Use_OtherStyleOf_label, otherLabel, cat)); |
| } |
| |
| |
| protected static class PrefProperty { |
| |
| public final Preference<?> pref; |
| public final String prop; |
| |
| public PrefProperty(final Preference<?> pref, final String prop) { |
| this.pref= pref; |
| this.prop= prop; |
| } |
| } |
| |
| |
| public static final String PROP_USE= "useStyle"; //$NON-NLS-1$ |
| public static final String PROP_COLOR= "color"; //$NON-NLS-1$ |
| public static final String PROP_BOLD= "bold"; //$NON-NLS-1$ |
| public static final String PROP_ITALIC= "italic"; //$NON-NLS-1$ |
| public static final String PROP_STRIKETHROUGH= "strikethrough"; //$NON-NLS-1$ |
| public static final String PROP_UNDERLINE= "underline"; //$NON-NLS-1$ |
| |
| |
| private final String description; |
| |
| private final ImList<UseStyle> availableStyles; |
| |
| private IPreferenceStore preferenceStore; |
| |
| private ImList<PrefProperty> preferences= ImCollections.emptyList(); |
| |
| private PreferenceStoreBeanWrapper beanSupport; |
| |
| |
| private SyntaxNode(final String name, final String description, |
| final SyntaxNode[] children, |
| final ImList<UseStyle> availableStyles) { |
| super(name, children); |
| assert (availableStyles != null); |
| |
| this.description= description; |
| |
| this.availableStyles= availableStyles; |
| } |
| |
| protected void setPreferences(final List<PrefProperty> prefs) { |
| this.preferences= ImCollections.toList(prefs); |
| } |
| |
| |
| public String getDescription() { |
| return this.description; |
| } |
| |
| |
| protected void gatherPreferenceKeys(final List<OverlayStorePreference> keys) { |
| for (final PrefProperty pref : this.preferences) { |
| keys.add(OverlayStorePreference.create(pref.pref)); |
| } |
| } |
| |
| protected void connectPreferenceStore(final IPreferenceStore store) { |
| this.preferenceStore= store; |
| this.beanSupport= new PreferenceStoreBeanWrapper(store, this); |
| for (final PrefProperty pref : this.preferences) { |
| this.beanSupport.addPreference(pref.prop, pref.pref); |
| } |
| } |
| |
| protected IPreferenceStore getPreferenceStore() { |
| return this.preferenceStore; |
| } |
| |
| |
| /*-- Bean-Support --*/ |
| |
| public void addPropertyChangeListener(final PropertyChangeListener listener) { |
| this.beanSupport.addPropertyChangeListener(listener); |
| } |
| |
| public void addPropertyChangeListener(final String propertyName, |
| final PropertyChangeListener listener) { |
| this.beanSupport.addPropertyChangeListener(propertyName, listener); |
| } |
| |
| public void removePropertyChangeListener(final PropertyChangeListener listener) { |
| this.beanSupport.removePropertyChangeListener(listener); |
| } |
| |
| public void removePropertyChangeListener(final String propertyName, |
| final PropertyChangeListener listener) { |
| this.beanSupport.removePropertyChangeListener(propertyName, listener); |
| } |
| |
| |
| /*-- Property-Access --*/ |
| public ImList<UseStyle> getAvailableUseStyles() { |
| return this.availableStyles; |
| } |
| public UseStyle getUseStyle() { |
| return (!this.availableStyles.isEmpty()) ? this.availableStyles.get(0) : null; |
| } |
| protected UseStyle getUseStyle(final String value) { |
| for (final UseStyle style : this.availableStyles) { |
| if (style.getRefRootKey().equals(value)) { |
| return style; |
| } |
| } |
| return this.availableStyles.get(0); |
| } |
| public void setUseStyle(final UseStyle useStyle) { |
| } |
| |
| public RGB getColor() { |
| return null; |
| } |
| public void setColor(final RGB color) { |
| } |
| |
| public boolean isBold() { |
| return false; |
| } |
| public void setBold(final boolean enabled) { |
| } |
| |
| public boolean isItalic() { |
| return false; |
| } |
| public void setItalic(final boolean enabled) { |
| } |
| |
| public boolean isStrikethrough() { |
| return false; |
| } |
| public void setStrikethrough(final boolean enabled) { |
| } |
| |
| public boolean isUnderline() { |
| return false; |
| } |
| public void setUnderline(final boolean enabled) { |
| } |
| |
| } |
| |
| /** |
| * Category Node without syntax style. |
| */ |
| protected static class CategoryNode extends SyntaxNode { |
| |
| public CategoryNode(final String name, final SyntaxNode[] children) { |
| super(name, null, children, ImCollections.<UseStyle>emptyList()); |
| } |
| |
| |
| } |
| |
| /** |
| * Style Node with syntax style, connected to overlay-preferencestory. |
| */ |
| protected static class StyleNode extends SyntaxNode { |
| |
| public class UseStylePref extends Preference<UseStyle> { |
| UseStylePref(final String qualifier, final String key) { |
| super(qualifier, key); |
| } |
| @Override |
| public Class<UseStyle> getUsageType() { |
| return UseStyle.class; |
| } |
| @Override |
| public UseStyle store2Usage(final String storeValue) { |
| return getUseStyle(storeValue); |
| } |
| @Override |
| public String usage2Store(final UseStyle usageValue) { |
| return usageValue.getRefRootKey(); |
| } |
| } |
| |
| private final String rootKey; |
| |
| |
| public StyleNode(final String name, final String description, final String rootKey, |
| final UseStyle[] availableStyles, final SyntaxNode[] children) { |
| super(name, description, children, ImCollections.newList(availableStyles)); |
| this.rootKey= rootKey; |
| |
| final List<PrefProperty> prefs= new ArrayList<>(); |
| if (getAvailableUseStyles().size() > 1) { |
| prefs.add(new PrefProperty(new UseStylePref(null, getUseKey()), PROP_USE)); |
| } |
| prefs.add(new PrefProperty(new RGBPref(null, getColorKey()), PROP_COLOR)); |
| prefs.add(new PrefProperty(new Preference.BooleanPref(null, getBoldKey()), PROP_BOLD)); |
| prefs.add(new PrefProperty(new Preference.BooleanPref(null, getItalicKey()), PROP_ITALIC)); |
| prefs.add(new PrefProperty(new Preference.BooleanPref(null, getUnderlineKey()), PROP_UNDERLINE)); |
| prefs.add(new PrefProperty(new Preference.BooleanPref(null, getStrikethroughKey()), PROP_STRIKETHROUGH)); |
| setPreferences(prefs); |
| } |
| |
| |
| private String getUseKey() { |
| return this.rootKey + ITextPresentationConstants.TEXTSTYLE_USE_SUFFIX; |
| } |
| private String getColorKey() { |
| return this.rootKey + ITextPresentationConstants.TEXTSTYLE_COLOR_SUFFIX; |
| } |
| private String getBoldKey() { |
| return this.rootKey + ITextPresentationConstants.TEXTSTYLE_BOLD_SUFFIX; |
| } |
| private String getItalicKey() { |
| return this.rootKey + ITextPresentationConstants.TEXTSTYLE_ITALIC_SUFFIX; |
| } |
| private String getUnderlineKey() { |
| return this.rootKey + ITextPresentationConstants.TEXTSTYLE_UNDERLINE_SUFFIX; |
| } |
| private String getStrikethroughKey() { |
| return this.rootKey + ITextPresentationConstants.TEXTSTYLE_STRIKETHROUGH_SUFFIX; |
| } |
| |
| |
| /*-- Property-Access --*/ |
| @Override |
| public void setUseStyle(final UseStyle useStyle) { |
| if (useStyle != null) { |
| getPreferenceStore().setValue(getUseKey(), useStyle.getRefRootKey()); |
| } |
| } |
| @Override |
| public UseStyle getUseStyle() { |
| return getUseStyle(getPreferenceStore().getString(getUseKey())); |
| } |
| |
| @Override |
| public RGB getColor() { |
| return PreferenceConverter.getColor(getPreferenceStore(), getColorKey()); |
| } |
| @Override |
| public void setColor(final RGB color) { |
| PreferenceConverter.setValue(getPreferenceStore(), getColorKey(), color); |
| } |
| |
| @Override |
| public boolean isBold() { |
| return getPreferenceStore().getBoolean(getBoldKey()); |
| } |
| @Override |
| public void setBold(final boolean enabled) { |
| getPreferenceStore().setValue(getBoldKey(), enabled); |
| } |
| |
| @Override |
| public boolean isItalic() { |
| return getPreferenceStore().getBoolean(getItalicKey()); |
| } |
| @Override |
| public void setItalic(final boolean enabled) { |
| getPreferenceStore().setValue(getItalicKey(), enabled); |
| } |
| |
| @Override |
| public boolean isStrikethrough() { |
| return getPreferenceStore().getBoolean(getStrikethroughKey()); |
| } |
| @Override |
| public void setStrikethrough(final boolean enabled) { |
| getPreferenceStore().setValue(getStrikethroughKey(), enabled); |
| } |
| |
| @Override |
| public boolean isUnderline() { |
| return getPreferenceStore().getBoolean(getUnderlineKey()); |
| } |
| @Override |
| public void setUnderline(final boolean enabled) { |
| getPreferenceStore().setValue(getUnderlineKey(), enabled); |
| } |
| |
| } |
| |
| protected static class BackgroundNode extends SyntaxNode { |
| |
| |
| private final String rootKey; |
| |
| |
| public BackgroundNode(final String name, final String description, final String rootKey) { |
| super(name, description, null, ImCollections.newList(createUseCustomStyle())); |
| this.rootKey= rootKey; |
| |
| final List<PrefProperty> prefs= new ArrayList<>(); |
| prefs.add(new PrefProperty(new RGBPref(null, getColorKey()), PROP_COLOR)); |
| setPreferences(prefs); |
| } |
| |
| |
| private String getColorKey() { |
| return this.rootKey + ITextPresentationConstants.TEXTSTYLE_COLOR_SUFFIX; |
| } |
| |
| @Override |
| public RGB getColor() { |
| return PreferenceConverter.getColor(getPreferenceStore(), getColorKey()); |
| } |
| @Override |
| public void setColor(final RGB color) { |
| PreferenceConverter.setValue(getPreferenceStore(), getColorKey(), color); |
| } |
| |
| } |
| |
| |
| private static class SyntaxNodeLabelProvider extends CellLabelProvider { |
| |
| @Override |
| public boolean useNativeToolTip(final Object object) { |
| return true; |
| } |
| @Override |
| public String getToolTipText(final Object element) { |
| return ((SyntaxNode) element).getDescription(); |
| } |
| |
| @Override |
| public void update(final ViewerCell cell) { |
| cell.setText(((Node) cell.getElement()).getName()); |
| } |
| |
| } |
| |
| private static class UseStyleLabelProvider extends LabelProvider { |
| |
| @Override |
| public String getText(final Object element) { |
| final UseStyle style= (UseStyle) element; |
| return style.getLabel(); |
| } |
| |
| } |
| |
| |
| private static void collectKeys(final List<OverlayStorePreference> keys, final Node[] nodes) { |
| for (final Node node : nodes) { |
| if (node instanceof SyntaxNode) { |
| ((SyntaxNode) node).gatherPreferenceKeys(keys); |
| } |
| final Node[] children= node.getChildren(); |
| if (children != null) { |
| collectKeys(keys, children); |
| } |
| } |
| } |
| |
| private static void connectStore(final Node[] nodes, final IPreferenceStore store) { |
| for (final Node node: nodes) { |
| if (node instanceof SyntaxNode) { |
| ((SyntaxNode) node).connectPreferenceStore(store); |
| } |
| final Node[] children= node.getChildren(); |
| if (children != null) { |
| connectStore(children, store); |
| } |
| } |
| } |
| |
| private static final Class<List<UseStyle>> List_UseStyle_TYPE= (Class)List.class; |
| |
| |
| private SyntaxNode[] rootNodes; |
| private DataBindingContext dbc; |
| |
| private TreeViewer selectionViewer; |
| |
| private Set<String> groupIds; |
| |
| private ComboViewer useViewer; |
| private Label colorLabel; |
| private ColorSelector colorEditor; |
| private Button boldCheckbox; |
| private Button italicCheckbox; |
| private Button strikethroughCheckbox; |
| private Button underlineCheckbox; |
| |
| private PreferenceStoreTextStyleManager<TextAttribute> textStyles; |
| |
| protected SourceViewer previewViewer; |
| private SourceEditorViewerConfiguration configuration; |
| |
| |
| public AbstractTextStylesConfigurationBlock() { |
| } |
| |
| |
| protected abstract SyntaxNode[] createItems(); |
| protected abstract String getSettingsGroup(); |
| |
| |
| @Override |
| protected Set<String> getChangedGroups() { |
| return this.groupIds; |
| } |
| |
| protected String getLinkMessage() { |
| return Messages.SyntaxColoring_link; |
| } |
| |
| /** |
| * If {@link TextAttribute}s (underline, strikethrough) is supported |
| */ |
| protected boolean isTextAttributesSupported() { |
| return true; |
| } |
| |
| @Override |
| protected void createBlockArea(final Composite pageComposite) { |
| // Prepare model |
| this.rootNodes= createItems(); |
| this.groupIds= new HashSet<>(); |
| this.groupIds.add(getSettingsGroup()); |
| final List<OverlayStorePreference> keys= new ArrayList<>(); |
| collectKeys(keys, this.rootNodes); |
| setupOverlayStore(keys.toArray(new OverlayStorePreference[keys.size()])); |
| connectStore(this.rootNodes, this.fOverlayStore); |
| |
| { final String message= getLinkMessage(); |
| if (message != null) { |
| addLinkHeader(pageComposite, Messages.SyntaxColoring_link); |
| } |
| } |
| |
| final Composite composite= new Composite(pageComposite, SWT.NONE); |
| composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true)); |
| composite.setLayout(LayoutUtils.newCompositeGrid(1)); |
| |
| // Tree / Options |
| { final Label label= new Label(composite, SWT.NONE); |
| label.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false)); |
| label.setText(Messages.SyntaxColoring_List_label); |
| } |
| |
| final Composite configComposite= new Composite(composite, SWT.NONE); |
| configComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false)); |
| configComposite.setLayout(LayoutUtils.newCompositeGrid(2)); |
| { final Control selectionControl= createTreeViewer(configComposite); |
| final GridData gd= new GridData(SWT.FILL, SWT.FILL, false, true); |
| final Point size= ViewerUtils.calculateTreeSizeHint(this.selectionViewer.getControl(), this.rootNodes, 9); |
| gd.widthHint= size.x; |
| gd.heightHint= size.y; |
| selectionControl.setLayoutData(gd); |
| } |
| { final Control optionControl= createOptionsControl(configComposite); |
| final GridData gd= new GridData(SWT.FILL, SWT.FILL, true, true); |
| gd.horizontalIndent= 5; |
| // gd.horizontalIndent= LayoutUtils.defaultSmallIndent(); |
| optionControl.setLayoutData(gd); |
| } |
| |
| // Previewer |
| { final Label label= new Label(composite, SWT.NONE); |
| label.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false)); |
| label.setText(Messages.SyntaxColoring_Preview); |
| } |
| { final Control previewerControl= createPreviewer(composite); |
| final GridData gd= new GridData(SWT.FILL, SWT.FILL, true, true); |
| gd.horizontalSpan= 2; |
| final PixelConverter conv= new PixelConverter(previewerControl); |
| gd.widthHint= conv.convertWidthInCharsToPixels(20); |
| gd.heightHint= conv.convertHeightInCharsToPixels(5); |
| previewerControl.setLayoutData(gd); |
| } |
| |
| initFields(); |
| initBindings(); |
| |
| UIAccess.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| if (UIAccess.isOkToUse(AbstractTextStylesConfigurationBlock.this.selectionViewer)) { |
| AbstractTextStylesConfigurationBlock.this.selectionViewer.setSelection(new StructuredSelection(AbstractTextStylesConfigurationBlock.this.rootNodes[0])); |
| } |
| } |
| }); |
| } |
| |
| |
| public Control createTreeViewer(final Composite parent) { |
| this.selectionViewer= new TreeViewer(parent, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); |
| |
| this.selectionViewer.setContentProvider(new ViewerUtils.NodeContentProvider()); |
| this.selectionViewer.setLabelProvider(new SyntaxNodeLabelProvider()); |
| ColumnViewerToolTipSupport.enableFor(this.selectionViewer); |
| |
| ViewerUtils.addDoubleClickExpansion(this.selectionViewer); |
| |
| return this.selectionViewer.getControl(); |
| } |
| |
| private Control createOptionsControl(final Composite parent) { |
| final Composite composite= new Composite(parent, SWT.NONE); |
| composite.setLayout(LayoutUtils.newCompositeGrid(2)); |
| { this.useViewer= new ComboViewer(composite, SWT.READ_ONLY | SWT.DROP_DOWN); |
| this.useViewer.setLabelProvider(new UseStyleLabelProvider()); |
| final GridData gd= new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1); |
| gd.widthHint= LayoutUtils.hintWidth(this.useViewer.getCombo(), new String[] { |
| "XXXXXXXXXXXXXXX", //$NON-NLS-1$ |
| Messages.SyntaxColoring_Use_CustomStyle_label, |
| Messages.SyntaxColoring_Use_NoExtraStyle_label }); |
| this.useViewer.getControl().setLayoutData(gd); |
| } |
| final int indent= LayoutUtils.defaultSmallIndent(); |
| { final Label label= new Label(composite, SWT.NONE); |
| final GridData gd= new GridData(SWT.FILL, SWT.CENTER, false, false); |
| gd.horizontalIndent= indent; |
| label.setLayoutData(gd); |
| label.setText(Messages.SyntaxColoring_Color); |
| this.colorLabel= label; |
| |
| this.colorEditor= new ColorSelector(composite); |
| final Button foregroundColorButton= this.colorEditor.getButton(); |
| foregroundColorButton.setLayoutData( |
| new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING) ); |
| } |
| { this.boldCheckbox= new Button(composite, SWT.CHECK); |
| final GridData gd= new GridData(SWT.FILL, SWT.CENTER, false, false); |
| gd.horizontalIndent= indent; |
| this.boldCheckbox.setLayoutData(gd); |
| this.boldCheckbox.setText(Messages.SyntaxColoring_Bold); |
| } |
| { this.italicCheckbox= new Button(composite, SWT.CHECK); |
| final GridData gd= new GridData(SWT.FILL, SWT.CENTER, false, false); |
| gd.horizontalIndent= indent; |
| this.italicCheckbox.setLayoutData(gd); |
| this.italicCheckbox.setText(Messages.SyntaxColoring_Italic); |
| } |
| { this.underlineCheckbox= new Button(composite, SWT.CHECK); |
| final GridData gd= new GridData(SWT.FILL, SWT.CENTER, false, false); |
| gd.horizontalIndent= indent; |
| this.underlineCheckbox.setLayoutData(gd); |
| this.underlineCheckbox.setText(Messages.SyntaxColoring_Underline); |
| } |
| { this.strikethroughCheckbox= new Button(composite, SWT.CHECK); |
| final GridData gd= new GridData(SWT.FILL, SWT.CENTER, false, false); |
| gd.horizontalIndent= indent; |
| this.strikethroughCheckbox.setLayoutData(gd); |
| this.strikethroughCheckbox.setText(Messages.SyntaxColoring_Strikethrough); |
| } |
| |
| return composite; |
| } |
| |
| private Control createPreviewer(final Composite parent) { |
| final IPreferenceStore store= new ChainedPreferenceStore(new IPreferenceStore[] { |
| this.fOverlayStore, EditorsUI.getPreferenceStore() }); |
| this.previewViewer= new SourceViewer(parent, null, null, false, SWT.V_SCROLL | SWT.H_SCROLL | SWT.BORDER); |
| this.previewViewer.setEditable(false); |
| this.configuration= getSourceViewerConfiguration(store); |
| this.previewViewer.configure(this.configuration); |
| new TextViewerJFaceUpdater(this.previewViewer, store); |
| new TextViewerEditorColorUpdater(this.previewViewer, store); |
| |
| final String content= loadPreviewContentFromFile(getPreviewFileName()); |
| final IDocument document= new Document(content); |
| getDocumentSetupParticipant().setup(document); |
| this.previewViewer.setDocument(document); |
| |
| return this.previewViewer.getControl(); |
| } |
| |
| protected abstract String getPreviewFileName(); |
| |
| protected SourceEditorViewerConfiguration getSourceViewerConfiguration( |
| final IPreferenceStore preferenceStore) { |
| this.textStyles= new JFaceTextStyleManager(preferenceStore, getSettingsGroup()); |
| return getSourceEditorViewerConfiguration(preferenceStore, this.textStyles); |
| } |
| |
| protected abstract SourceEditorViewerConfiguration getSourceEditorViewerConfiguration( |
| IPreferenceStore preferenceStore, |
| PreferenceStoreTextStyleManager<TextAttribute> textStyles); |
| |
| protected abstract IDocumentSetupParticipant getDocumentSetupParticipant(); |
| |
| private String loadPreviewContentFromFile(final String filename) { |
| String line; |
| final String separator= "\n"; //$NON-NLS-1$ |
| final StringBuffer buffer= new StringBuffer(512); |
| BufferedReader reader= null; |
| try { |
| reader= new BufferedReader(new InputStreamReader(getClass().getResourceAsStream(filename))); |
| while ((line= reader.readLine()) != null) { |
| buffer.append(line); |
| buffer.append(separator); |
| } |
| } |
| catch (final IOException e) { |
| StatusManager.getManager().handle(new Status(IStatus.ERROR, BUNDLE_ID, -1, |
| NLS.bind("An error occurred when loading the preview code from ''{0}''.", filename), e)); |
| } |
| finally { |
| if (reader != null) { |
| try { reader.close(); } catch (final IOException e) {} |
| } |
| } |
| return buffer.toString(); |
| } |
| |
| |
| public void initFields() { |
| this.selectionViewer.setInput(this.rootNodes); |
| } |
| |
| private void initBindings() { |
| final Realm realm= Realm.getDefault(); |
| this.dbc= new DataBindingContext(realm); |
| |
| // Observe changes in selection. |
| final IObservableValue<SyntaxNode> selectionValue= |
| ViewerProperties.singleSelection(SyntaxNode.class) |
| .observe(this.selectionViewer); |
| selectionValue.addValueChangeListener(new IValueChangeListener<SyntaxNode>() { |
| @Override |
| public void handleValueChange(final ValueChangeEvent<? extends SyntaxNode> event) { |
| final SyntaxNode newNode= event.diff.getNewValue(); |
| if (newNode != null) { |
| updateEnablement(newNode, newNode.getUseStyle()); |
| } |
| } |
| }); |
| // Bind use style selection |
| final IObservableList<UseStyle> list= MasterDetailObservables.detailList( |
| BeanProperties.value("availableUseStyles", List_UseStyle_TYPE) |
| .observeDetail(selectionValue), |
| new IObservableFactory<List<UseStyle>, IObservableList<UseStyle>>() { |
| @Override |
| public IObservableList<UseStyle> createObservable(final List<UseStyle> target) { |
| return Observables.staticObservableList(realm, target); |
| } |
| }, null ); |
| this.useViewer.setContentProvider(new ObservableListContentProvider<UseStyle>()); |
| this.useViewer.setInput(list); |
| final IObservableValue<UseStyle> useStyleValue= BeanProperties.value(SyntaxNode.PROP_USE, UseStyle.class) |
| .observeDetail(selectionValue); |
| useStyleValue.addValueChangeListener(new IValueChangeListener<UseStyle>() { |
| @Override |
| public void handleValueChange(final ValueChangeEvent<? extends UseStyle> event) { |
| final IStructuredSelection selection= (IStructuredSelection) AbstractTextStylesConfigurationBlock.this |
| .selectionViewer.getSelection(); |
| final UseStyle newUse= event.diff.getNewValue(); |
| updateEnablement((SyntaxNode) selection.getFirstElement(), newUse); |
| } |
| }); |
| this.dbc.bindValue( |
| ViewerProperties.singleSelection(UseStyle.class) |
| .observe(this.useViewer), |
| useStyleValue ); |
| // Bind option widgets to the properties of the current selection. |
| this.dbc.bindValue( |
| new ColorSelectorObservableValue(this.colorEditor), |
| BeanProperties.value(SyntaxNode.PROP_COLOR, RGB.class) |
| .observeDetail(selectionValue) ); |
| this.dbc.bindValue( |
| WidgetProperties.buttonSelection() |
| .observe(this.boldCheckbox), |
| BeanProperties.value(SyntaxNode.PROP_BOLD, Boolean.TYPE) |
| .observeDetail(selectionValue), |
| UpdateValueStrategy.create(ClassTypedConverter.createIdentity(Boolean.TYPE)), |
| UpdateValueStrategy.create(ClassTypedConverter.createIdentity(Boolean.TYPE)) ); |
| this.dbc.bindValue( |
| WidgetProperties.buttonSelection() |
| .observe(this.italicCheckbox), |
| BeanProperties.value(SyntaxNode.PROP_ITALIC, Boolean.TYPE) |
| .observeDetail(selectionValue), |
| UpdateValueStrategy.create(ClassTypedConverter.createIdentity(Boolean.TYPE)), |
| UpdateValueStrategy.create(ClassTypedConverter.createIdentity(Boolean.TYPE)) ); |
| if (isTextAttributesSupported()) { |
| this.dbc.bindValue( |
| WidgetProperties.buttonSelection() |
| .observe(this.strikethroughCheckbox), |
| BeanProperties.value(SyntaxNode.PROP_STRIKETHROUGH, Boolean.TYPE) |
| .observeDetail(selectionValue), |
| UpdateValueStrategy.create(ClassTypedConverter.createIdentity(Boolean.TYPE)), |
| UpdateValueStrategy.create(ClassTypedConverter.createIdentity(Boolean.TYPE)) ); |
| this.dbc.bindValue( |
| WidgetProperties.buttonSelection() |
| .observe(this.underlineCheckbox), |
| BeanProperties.value(SyntaxNode.PROP_UNDERLINE, Boolean.TYPE) |
| .observeDetail(selectionValue), |
| UpdateValueStrategy.create(ClassTypedConverter.createIdentity(Boolean.TYPE)), |
| UpdateValueStrategy.create(ClassTypedConverter.createIdentity(Boolean.TYPE)) ); |
| } |
| else { |
| this.strikethroughCheckbox.setVisible(false); |
| this.underlineCheckbox.setVisible(false); |
| } |
| } |
| |
| private void updateEnablement(final SyntaxNode node, final UseStyle useStyle) { |
| int showOptions; |
| boolean enableOptions; |
| if (node instanceof StyleNode) { |
| this.useViewer.getControl().setEnabled(node.getAvailableUseStyles().size() > 1); |
| showOptions= 2; |
| enableOptions= (useStyle != null && useStyle.getRefRootKey().equals("")); //$NON-NLS-1$ |
| } |
| else if (node instanceof BackgroundNode) { |
| this.useViewer.getControl().setEnabled(false); |
| showOptions= 1; |
| enableOptions= true; |
| } |
| else { |
| this.useViewer.getControl().setEnabled(false); |
| showOptions= 0; |
| enableOptions= false; |
| } |
| |
| this.colorLabel.setVisible(showOptions >= 1); |
| this.colorEditor.getButton().setVisible(showOptions >= 1); |
| this.colorLabel.setEnabled(enableOptions); |
| this.colorEditor.setEnabled(enableOptions); |
| |
| this.boldCheckbox.setVisible(showOptions >= 2); |
| this.boldCheckbox.setEnabled(enableOptions); |
| this.italicCheckbox.setVisible(showOptions >= 2); |
| this.italicCheckbox.setEnabled(enableOptions); |
| if (isTextAttributesSupported()) { |
| this.strikethroughCheckbox.setVisible(showOptions >= 2); |
| this.strikethroughCheckbox.setEnabled(enableOptions); |
| this.underlineCheckbox.setVisible(showOptions >= 2); |
| this.underlineCheckbox.setEnabled(enableOptions); |
| } |
| } |
| |
| @Override |
| protected void handlePropertyChange() { |
| if (UIAccess.isOkToUse(this.previewViewer)) { |
| final Map<String, Object> options= new HashMap<>(); |
| if (this.textStyles != null) { |
| this.textStyles.handleSettingsChanged(this.groupIds, options); |
| } |
| this.configuration.handleSettingsChanged(this.groupIds, options); |
| this.previewViewer.invalidateTextPresentation(); |
| } |
| } |
| |
| @Override |
| public void dispose() { |
| if (this.dbc != null) { |
| this.dbc.dispose(); |
| this.dbc= null; |
| } |
| super.dispose(); |
| } |
| |
| protected String addListToTooltip(final String tooltip, final String[] listItems) { |
| final StringBuilder description= new StringBuilder(tooltip); |
| final int end= Math.min(20, listItems.length); |
| for (int i= 0; i < end; i++) { |
| description.append("\n "); //$NON-NLS-1$ |
| description.append(listItems[i]); |
| } |
| if (end < listItems.length) { |
| description.append("\n ... (" + listItems.length + ')'); //$NON-NLS-1$ |
| } |
| return MessageUtils.escapeForTooltip(description); |
| } |
| |
| protected String addExtraStyleNoteToTooltip(final String tooltip) { |
| return NLS.bind(tooltip, Messages.SyntaxColoring_MindExtraStyle_tooltip); |
| } |
| |
| } |
