From 0b70cdebcd76fbf88f815cc841af10685ce24f09 Mon Sep 17 00:00:00 2001 From: Rustam Vishnyakov Date: Mon, 17 Apr 2017 17:06:30 +0300 Subject: [PATCH] Application-level default editor font [IDEA-CR-19148] --- .../colors/DelegatingFontPreferences.java | 32 +- .../editor/colors/EditorColorsScheme.java | 10 + .../editor/colors/EditorFontCache.java | 32 ++ .../colors/impl/AbstractColorsScheme.java | 140 ++++--- .../colors/impl/AppEditorFontOptions.java | 71 ++++ .../colors/impl/EditorFontCacheImpl.java | 100 +++++ .../colors/AbstractFontOptionsPanel.java | 357 ++++++++++++++++++ .../options/colors/ColorAndFontOptions.java | 24 +- .../options/colors/ConsoleFontOptions.java | 13 +- .../options/colors/FontEditorPreview.java | 17 +- .../options/colors/FontOptions.java | 341 ++--------------- .../options/colors/SimpleEditorPreview.java | 2 +- .../fonts/AppEditorFontConfigurable.java | 84 +++++ .../fonts/AppEditorFontOptionsPanel.java | 61 +++ .../editor/fonts/AppEditorFontPanel.java | 59 +++ .../src/META-INF/PlatformExtensions.xml | 8 + 16 files changed, 940 insertions(+), 411 deletions(-) create mode 100644 platform/editor-ui-api/src/com/intellij/openapi/editor/colors/EditorFontCache.java create mode 100644 platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/AppEditorFontOptions.java create mode 100644 platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/EditorFontCacheImpl.java create mode 100644 platform/lang-impl/src/com/intellij/application/options/colors/AbstractFontOptionsPanel.java create mode 100644 platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontConfigurable.java create mode 100644 platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontOptionsPanel.java create mode 100644 platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontPanel.java diff --git a/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/DelegatingFontPreferences.java b/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/DelegatingFontPreferences.java index b3425258650b..03975453dfda 100644 --- a/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/DelegatingFontPreferences.java +++ b/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/DelegatingFontPreferences.java @@ -18,67 +18,61 @@ package com.intellij.openapi.editor.colors; import org.jetbrains.annotations.NotNull; import java.util.List; +import java.util.function.Supplier; public class DelegatingFontPreferences implements FontPreferences { - private FontPreferences myDelegate; + private Supplier myDelegateSupplier; - public DelegatingFontPreferences(FontPreferences delegate) { - myDelegate = delegate; + public DelegatingFontPreferences(@NotNull Supplier delegateSupplier) { + myDelegateSupplier = delegateSupplier; } @NotNull @Override public List getEffectiveFontFamilies() { - return myDelegate.getEffectiveFontFamilies(); + return myDelegateSupplier.get().getEffectiveFontFamilies(); } @NotNull @Override public List getRealFontFamilies() { - return myDelegate.getRealFontFamilies(); + return myDelegateSupplier.get().getRealFontFamilies(); } @NotNull @Override public String getFontFamily() { - return myDelegate.getFontFamily(); + return myDelegateSupplier.get().getFontFamily(); } @Override public int getSize(@NotNull String fontFamily) { - return myDelegate.getSize(fontFamily); + return myDelegateSupplier.get().getSize(fontFamily); } @Override public void copyTo(@NotNull FontPreferences preferences) { - myDelegate.copyTo(preferences); + myDelegateSupplier.get().copyTo(preferences); } @Override public boolean useLigatures() { - return myDelegate.useLigatures(); + return myDelegateSupplier.get().useLigatures(); } @Override public boolean hasSize(@NotNull String fontName) { - return myDelegate.hasSize(fontName); + return myDelegateSupplier.get().hasSize(fontName); } @Override public float getLineSpacing() { - return myDelegate.getLineSpacing(); + return myDelegateSupplier.get().getLineSpacing(); } @Override public void setLineSpacing(float lineSpacing) { - myDelegate.setLineSpacing(lineSpacing); + myDelegateSupplier.get().setLineSpacing(lineSpacing); } - @Override - public boolean equals(Object obj) { - if (obj instanceof DelegatingFontPreferences) { - return myDelegate.equals(((DelegatingFontPreferences)obj).myDelegate); - } - return false; - } } diff --git a/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/EditorColorsScheme.java b/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/EditorColorsScheme.java index 1c03ce24419b..766f354326d4 100644 --- a/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/EditorColorsScheme.java +++ b/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/EditorColorsScheme.java @@ -77,7 +77,14 @@ public interface EditorColorsScheme extends Cloneable, TextAttributesScheme, Sch @Deprecated void setQuickDocFontSize(@NotNull FontSize fontSize); + @NotNull Font getFont(EditorFontType key); + + /** + * @deprecated Use {@link #getFontPreferences()} and {@link ModifiableFontPreferences} + * to change fonts. + */ + @Deprecated void setFont(EditorFontType key, Font font); float getLineSpacing(); @@ -103,6 +110,9 @@ public interface EditorColorsScheme extends Cloneable, TextAttributesScheme, Sch default void setUseEditorFontPreferencesInConsole() {} default boolean isUseEditorFontPreferencesInConsole() {return false;} + default void setUseAppFontPreferencesInEditor() {} + default boolean isUseAppFontPreferencesInEditor() {return false;} + String getConsoleFontName(); void setConsoleFontName(String fontName); diff --git a/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/EditorFontCache.java b/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/EditorFontCache.java new file mode 100644 index 000000000000..aafda796987e --- /dev/null +++ b/platform/editor-ui-api/src/com/intellij/openapi/editor/colors/EditorFontCache.java @@ -0,0 +1,32 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.openapi.editor.colors; + +import com.intellij.openapi.components.ServiceManager; +import org.jetbrains.annotations.NotNull; + +import java.awt.*; + +public abstract class EditorFontCache { + + public static EditorFontCache getInstance() { + return ServiceManager.getService(EditorFontCache.class); + } + + @NotNull + public abstract Font getFont(EditorFontType key); + public abstract void reset(); +} diff --git a/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/AbstractColorsScheme.java b/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/AbstractColorsScheme.java index 8a5944dd26f0..be98e808a10f 100644 --- a/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/AbstractColorsScheme.java +++ b/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/AbstractColorsScheme.java @@ -34,6 +34,7 @@ import com.intellij.util.JdomKt; import com.intellij.util.PlatformUtils; import com.intellij.util.containers.ContainerUtilRt; import com.intellij.util.containers.HashMap; +import com.intellij.util.ui.JBUI; import gnu.trove.THashMap; import org.jdom.Element; import org.jetbrains.annotations.NonNls; @@ -53,7 +54,7 @@ import static com.intellij.openapi.util.Couple.of; import static com.intellij.ui.ColorUtil.fromHex; @SuppressWarnings("UseJBColor") -public abstract class AbstractColorsScheme implements EditorColorsScheme, SerializableScheme { +public abstract class AbstractColorsScheme extends EditorFontCacheImpl implements EditorColorsScheme, SerializableScheme { private static final int CURR_VERSION = 142; private static final FontSize DEFAULT_FONT_SIZE = FontSize.SMALL; @@ -62,12 +63,11 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial protected FontSize myQuickDocFontSize = DEFAULT_FONT_SIZE; - @NotNull private final Map myFonts = new EnumMap<>(EditorFontType.class); - @NotNull private FontPreferencesImpl myFontPreferences = new FontPreferencesImpl(); - @NotNull private FontPreferences myConsoleFontPreferences = new DelegatingFontPreferences(myFontPreferences); + @NotNull private FontPreferences myFontPreferences + = new DelegatingFontPreferences(() -> AppEditorFontOptions.getInstance().getFontPreferences()); + @NotNull private FontPreferences myConsoleFontPreferences = new DelegatingFontPreferences(() -> myFontPreferences); private final ValueElementReader myValueReader = new TextAttributesReader(); - private String myFallbackFontName; private String mySchemeName; private boolean myIsSaveNeeded; @@ -124,7 +124,6 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial protected AbstractColorsScheme(EditorColorsScheme parentScheme) { myParentScheme = parentScheme; - myFontPreferences.setChangeListener(() -> initFonts()); } public AbstractColorsScheme() { @@ -161,14 +160,12 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial @Override public void setFont(EditorFontType key, Font font) { - myFonts.put(key, font); } @Override public abstract Object clone(); public void copyTo(AbstractColorsScheme newScheme) { - myFontPreferences.copyTo(newScheme.myFontPreferences); newScheme.myQuickDocFontSize = myQuickDocFontSize; if (myConsoleFontPreferences instanceof DelegatingFontPreferences) { newScheme.setUseEditorFontPreferencesInConsole(); @@ -176,11 +173,11 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial else { newScheme.setConsoleFontPreferences(myConsoleFontPreferences); } - - final Set types = myFonts.keySet(); - for (EditorFontType type : types) { - Font font = myFonts.get(type); - newScheme.setFont(type, font); + if (myFontPreferences instanceof DelegatingFontPreferences) { + newScheme.setUseAppFontPreferencesInEditor(); + } + else { + newScheme.setFontPreferences(myFontPreferences); } newScheme.myAttributesMap = new THashMap<>(myAttributesMap); @@ -191,18 +188,29 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial @Override public void setEditorFontName(String fontName) { int editorFontSize = getEditorFontSize(); - myFontPreferences.clear(); - myFontPreferences.register(fontName, editorFontSize); + ensureEditableFontPreferences().clear(); + ensureEditableFontPreferences().register(fontName, editorFontSize); initFonts(); } @Override public void setEditorFontSize(int fontSize) { fontSize = EditorFontsConstants.checkAndFixEditorFontSize(fontSize); - myFontPreferences.register(getEditorFontName(), fontSize); + ensureEditableFontPreferences().register(myFontPreferences.getFontFamily(), fontSize); initFonts(); } + @Override + public void setUseAppFontPreferencesInEditor() { + myFontPreferences = new DelegatingFontPreferences(()-> AppEditorFontOptions.getInstance().getFontPreferences()); + initFonts(); + } + + @Override + public boolean isUseAppFontPreferencesInEditor() { + return myFontPreferences instanceof DelegatingFontPreferences; + } + @Override public void setQuickDocFontSize(@NotNull FontSize fontSize) { if (myQuickDocFontSize != fontSize) { @@ -216,14 +224,10 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial myFontPreferences.setLineSpacing(lineSpacing); } + @NotNull @Override public Font getFont(EditorFontType key) { - UISettings uiSettings = UISettings.getInstance(); - if (uiSettings.getPresentationMode()) { - final Font font = myFonts.get(key); - return new Font(font.getName(), font.getStyle(), uiSettings.getPresentationModeFontSize()); - } - return myFonts.get(key); + return myFontPreferences instanceof DelegatingFontPreferences ? EditorFontCache.getInstance().getFont(key) : super.getFont(key); } @Override @@ -239,21 +243,18 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial @Override public void setFontPreferences(@NotNull FontPreferences preferences) { - preferences.copyTo(myFontPreferences); + preferences.copyTo(ensureEditableFontPreferences()); initFonts(); } @Override public String getEditorFontName() { - if (myFallbackFontName != null) { - return myFallbackFontName; - } - return myFontPreferences.getFontFamily(); + return getFont(EditorFontType.PLAIN).getFontName(); } @Override public int getEditorFontSize() { - return myFontPreferences.getSize(getEditorFontName()); + return myFontPreferences.getSize(myFontPreferences.getFontFamily()); } @NotNull @@ -268,35 +269,12 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial } protected void initFonts() { - String editorFontName = getEditorFontName(); - int editorFontSize = getEditorFontSize(); + reset(); + } - myFallbackFontName = FontPreferences.getFallbackName(editorFontName, editorFontSize, myParentScheme); - if (myFallbackFontName != null) { - editorFontName = myFallbackFontName; - } - Font plainFont = new Font(editorFontName, Font.PLAIN, editorFontSize); - Font boldFont = new Font(editorFontName, Font.BOLD, editorFontSize); - Font italicFont = new Font(editorFontName, Font.ITALIC, editorFontSize); - Font boldItalicFont = new Font(editorFontName, Font.BOLD | Font.ITALIC, editorFontSize); - - myFonts.put(EditorFontType.PLAIN, plainFont); - myFonts.put(EditorFontType.BOLD, boldFont); - myFonts.put(EditorFontType.ITALIC, italicFont); - myFonts.put(EditorFontType.BOLD_ITALIC, boldItalicFont); - - String consoleFontName = getConsoleFontName(); - int consoleFontSize = getConsoleFontSize(); - - Font consolePlainFont = new Font(consoleFontName, Font.PLAIN, consoleFontSize); - Font consoleBoldFont = new Font(consoleFontName, Font.BOLD, consoleFontSize); - Font consoleItalicFont = new Font(consoleFontName, Font.ITALIC, consoleFontSize); - Font consoleBoldItalicFont = new Font(consoleFontName, Font.BOLD | Font.ITALIC, consoleFontSize); - - myFonts.put(EditorFontType.CONSOLE_PLAIN, consolePlainFont); - myFonts.put(EditorFontType.CONSOLE_BOLD, consoleBoldFont); - myFonts.put(EditorFontType.CONSOLE_ITALIC, consoleItalicFont); - myFonts.put(EditorFontType.CONSOLE_BOLD_ITALIC, consoleBoldItalicFont); + @Override + protected EditorColorsScheme getFontCacheScheme() { + return this; } public String toString() { @@ -508,7 +486,7 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial } case EDITOR_LIGATURES: { Boolean value = myValueReader.read(Boolean.class, childNode); - if (value != null) myFontPreferences.setUseLigatures(value); + if (value != null) ensureEditableFontPreferences().setUseLigatures(value); break; } case CONSOLE_LIGATURES: { @@ -531,7 +509,7 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial } return UISettings.restoreFontSize(intSize, fontScale); } - + private FontPreferencesImpl readFontSettings(@NotNull Element element, boolean isDefaultScheme, @Nullable Float fontScale) { @@ -571,7 +549,9 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial * will be able to restore the font size according to its scale and the IDE HiDPI mode. The default * FONT_SCALE value should also be written by that reason. */ - JdomKt.addOptionTag(parentNode, FONT_SCALE, String.valueOf(UISettings.getNormalizingScale())); // must precede font options + if (!(myFontPreferences instanceof DelegatingFontPreferences) || !(myConsoleFontPreferences instanceof DelegatingFontPreferences)) { + JdomKt.addOptionTag(parentNode, FONT_SCALE, String.valueOf(JBUI.scale(1f))); // must precede font options + } if (myParentScheme != null && myParentScheme != EmptyColorScheme.INSTANCE) { parentNode.setAttribute(PARENT_SCHEME_ATTR, myParentScheme.getName()); @@ -589,13 +569,16 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial // to specify fonts sequence (see getFontPreferences()), there are big chances that many clients still will use a single font. // That's why we want to use old format when zero or one font is selected and 'extended' format otherwise. boolean useOldFontFormat = myFontPreferences.getEffectiveFontFamilies().size() <= 1; - if (useOldFontFormat) { - JdomKt.addOptionTag(parentNode, EDITOR_FONT_SIZE, String.valueOf(getEditorFontSize())); + if (!(myFontPreferences instanceof DelegatingFontPreferences)) { + if (useOldFontFormat) { + JdomKt.addOptionTag(parentNode, EDITOR_FONT_SIZE, String.valueOf(getEditorFontSize())); + JdomKt.addOptionTag(parentNode, EDITOR_FONT_NAME, myFontPreferences.getFontFamily()); + } + else { + writeFontPreferences(EDITOR_FONT, parentNode, myFontPreferences); + } + writeLigaturesPreferences(parentNode, myFontPreferences, EDITOR_LIGATURES); } - else { - writeFontPreferences(EDITOR_FONT, parentNode, myFontPreferences); - } - writeLigaturesPreferences(parentNode, myFontPreferences, EDITOR_LIGATURES); if (!(myConsoleFontPreferences instanceof DelegatingFontPreferences)) { if (myConsoleFontPreferences.getEffectiveFontFamilies().size() <= 1) { @@ -619,7 +602,7 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial } if (useOldFontFormat) { - JdomKt.addOptionTag(parentNode, EDITOR_FONT_NAME, getEditorFontName()); + JdomKt.addOptionTag(parentNode, EDITOR_FONT_NAME, myFontPreferences.getFontFamily()); } Element colorElements = new Element(COLORS_ELEMENT); @@ -762,6 +745,16 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial return true; } + private ModifiableFontPreferences ensureEditableFontPreferences() { + if (!(myFontPreferences instanceof ModifiableFontPreferences)) { + ModifiableFontPreferences editablePrefs = new FontPreferencesImpl(); + myFontPreferences.copyTo(editablePrefs); + myFontPreferences = editablePrefs; + ((FontPreferencesImpl)myFontPreferences).setChangeListener(() -> initFonts()); + } + return (ModifiableFontPreferences)myFontPreferences; + } + @NotNull @Override public FontPreferences getConsoleFontPreferences() { @@ -770,7 +763,7 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial @Override public void setUseEditorFontPreferencesInConsole() { - myConsoleFontPreferences = new DelegatingFontPreferences(myFontPreferences); + myConsoleFontPreferences = new DelegatingFontPreferences(() -> myFontPreferences); initFonts(); } @@ -939,13 +932,18 @@ public abstract class AbstractColorsScheme implements EditorColorsScheme, Serial } } - return myFontPreferences.equals(otherScheme.getFontPreferences()) && - myConsoleFontPreferences.equals(otherScheme.getConsoleFontPreferences()) && + return areDelegatingOrEqual(myFontPreferences, otherScheme.getFontPreferences()) && + areDelegatingOrEqual(myConsoleFontPreferences, otherScheme.getConsoleFontPreferences()) && attributesEqual(otherScheme) && - colorsEqual(otherScheme) && - myFontPreferences.equals(otherScheme.myFontPreferences); + colorsEqual(otherScheme); } + protected static boolean areDelegatingOrEqual(@NotNull FontPreferences preferences1, @NotNull FontPreferences preferences2) { + boolean isDelegating1 = preferences1 instanceof DelegatingFontPreferences; + boolean isDelegating2 = preferences2 instanceof DelegatingFontPreferences; + return isDelegating1 || isDelegating2 ? isDelegating1 && isDelegating2 : preferences1.equals(preferences2); + } + protected boolean attributesEqual(AbstractColorsScheme otherScheme) { return myAttributesMap.equals(otherScheme.myAttributesMap); } diff --git a/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/AppEditorFontOptions.java b/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/AppEditorFontOptions.java new file mode 100644 index 000000000000..15c3971b7091 --- /dev/null +++ b/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/AppEditorFontOptions.java @@ -0,0 +1,71 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.openapi.editor.colors.impl; + +import com.intellij.openapi.components.PersistentStateComponent; +import com.intellij.openapi.components.ServiceManager; +import com.intellij.openapi.components.State; +import com.intellij.openapi.components.Storage; +import com.intellij.openapi.editor.colors.EditorFontCache; +import com.intellij.openapi.editor.colors.FontPreferences; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +@State(name = "DefaultFont", storages = @Storage("editor.xml")) +public class AppEditorFontOptions implements PersistentStateComponent { + + private final FontPreferencesImpl myFontPreferences = new FontPreferencesImpl(); + + public static class PersistentFontPreferences { + /** + * Serialization constructor. + */ + @SuppressWarnings("unused") + private PersistentFontPreferences() { + } + + public PersistentFontPreferences(FontPreferences fontPreferences) { + FONT_FAMILY = fontPreferences.getFontFamily(); + FONT_SIZE = fontPreferences.getSize(FONT_FAMILY); + } + + public int FONT_SIZE; + public String FONT_FAMILY; + } + + + public static AppEditorFontOptions getInstance() { + return ServiceManager.getService(AppEditorFontOptions.class); + } + + @Nullable + @Override + public PersistentFontPreferences getState() { + return new PersistentFontPreferences(myFontPreferences); + } + + @Override + public void loadState(PersistentFontPreferences state) { + myFontPreferences.clear(); + myFontPreferences.register(state.FONT_FAMILY, state.FONT_SIZE); + myFontPreferences.setChangeListener(() -> EditorFontCache.getInstance().reset()); + } + + @NotNull + public FontPreferences getFontPreferences() { + return myFontPreferences; + } +} diff --git a/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/EditorFontCacheImpl.java b/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/EditorFontCacheImpl.java new file mode 100644 index 000000000000..f285578b0b35 --- /dev/null +++ b/platform/editor-ui-ex/src/com/intellij/openapi/editor/colors/impl/EditorFontCacheImpl.java @@ -0,0 +1,100 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.openapi.editor.colors.impl; + +import com.intellij.ide.ui.UISettings; +import com.intellij.openapi.editor.colors.*; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.awt.*; +import java.util.EnumMap; +import java.util.Map; + +public class EditorFontCacheImpl extends EditorFontCache { + @NotNull private final Map myFonts = new EnumMap<>(EditorFontType.class); + + @Override + @NotNull + public Font getFont(EditorFontType key) { + synchronized (myFonts) { + if (myFonts.isEmpty()) { + initFonts(); + } + final Font font = myFonts.get(key); + assert font != null : "Font " + key + " not found."; + UISettings uiSettings = UISettings.getInstance(); + if (uiSettings.getPresentationMode()) { + return new Font(font.getName(), font.getStyle(), uiSettings.getPresentationModeFontSize()); + } + return font; + } + } + + @Override + public void reset() { + synchronized (myFonts) { + myFonts.clear(); + } + } + + protected EditorColorsScheme getFontCacheScheme() { + return EditorColorsManager.getInstance().getGlobalScheme(); + } + + private void initFonts() { + EditorColorsScheme scheme = getFontCacheScheme(); + String editorFontName = scheme.getFontPreferences().getFontFamily(); + int editorFontSize = scheme.getEditorFontSize(); + String fallbackName = getFallbackName(editorFontName, editorFontSize); + if (fallbackName != null) { + editorFontName = fallbackName; + } + + Font plainFont = new Font(editorFontName, Font.PLAIN, editorFontSize); + Font boldFont = new Font(editorFontName, Font.BOLD, editorFontSize); + Font italicFont = new Font(editorFontName, Font.ITALIC, editorFontSize); + Font boldItalicFont = new Font(editorFontName, Font.BOLD | Font.ITALIC, editorFontSize); + + myFonts.put(EditorFontType.PLAIN, plainFont); + myFonts.put(EditorFontType.BOLD, boldFont); + myFonts.put(EditorFontType.ITALIC, italicFont); + myFonts.put(EditorFontType.BOLD_ITALIC, boldItalicFont); + + String consoleFontName = scheme.getConsoleFontName(); + int consoleFontSize = scheme.getConsoleFontSize(); + + Font consolePlainFont = new Font(consoleFontName, Font.PLAIN, consoleFontSize); + Font consoleBoldFont = new Font(consoleFontName, Font.BOLD, consoleFontSize); + Font consoleItalicFont = new Font(consoleFontName, Font.ITALIC, consoleFontSize); + Font consoleBoldItalicFont = new Font(consoleFontName, Font.BOLD | Font.ITALIC, consoleFontSize); + + myFonts.put(EditorFontType.CONSOLE_PLAIN, consolePlainFont); + myFonts.put(EditorFontType.CONSOLE_BOLD, consoleBoldFont); + myFonts.put(EditorFontType.CONSOLE_ITALIC, consoleItalicFont); + myFonts.put(EditorFontType.CONSOLE_BOLD_ITALIC, consoleBoldItalicFont); + } + + @Nullable + private static String getFallbackName(@NotNull String fontName, int fontSize) { + Font plainFont = new Font(fontName, Font.PLAIN, fontSize); + if (plainFont.getFamily().equals("Dialog") && !("Dialog".equals(fontName) || fontName.startsWith("Dialog."))) { + FontPreferences appPrefs = AppEditorFontOptions.getInstance().getFontPreferences(); + return appPrefs.getFontFamily(); + } + return null; + } +} diff --git a/platform/lang-impl/src/com/intellij/application/options/colors/AbstractFontOptionsPanel.java b/platform/lang-impl/src/com/intellij/application/options/colors/AbstractFontOptionsPanel.java new file mode 100644 index 000000000000..22b95d492cfd --- /dev/null +++ b/platform/lang-impl/src/com/intellij/application/options/colors/AbstractFontOptionsPanel.java @@ -0,0 +1,357 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.application.options.colors; + +import com.intellij.application.options.EditorFontsConstants; +import com.intellij.icons.AllIcons; +import com.intellij.ide.IdeTooltipManager; +import com.intellij.openapi.application.ApplicationBundle; +import com.intellij.openapi.application.ApplicationNamesInfo; +import com.intellij.openapi.editor.colors.EditorColorsManager; +import com.intellij.openapi.editor.colors.FontPreferences; +import com.intellij.openapi.editor.colors.ModifiableFontPreferences; +import com.intellij.openapi.ui.MessageType; +import com.intellij.openapi.util.SystemInfo; +import com.intellij.ui.DocumentAdapter; +import com.intellij.ui.FontComboBox; +import com.intellij.ui.FontInfoRenderer; +import com.intellij.ui.TooltipWithClickableLinks; +import com.intellij.ui.components.JBCheckBox; +import com.intellij.util.EventDispatcher; +import com.intellij.util.ui.JBUI; +import net.miginfocom.swing.MigLayout; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; +import javax.swing.event.DocumentEvent; +import java.awt.*; +import java.awt.event.ActionListener; +import java.awt.event.ItemListener; +import java.awt.event.KeyAdapter; +import java.awt.event.KeyEvent; +import java.util.HashSet; +import java.util.List; +import java.util.Locale; +import java.util.Set; + +public abstract class AbstractFontOptionsPanel extends JPanel implements OptionsPanel { + private static final FontInfoRenderer RENDERER = new FontInfoRenderer() { + @Override + protected boolean isEditorFont() { + return true; + } + }; + + private final EventDispatcher myDispatcher = EventDispatcher.create(ColorAndFontSettingsListener.class); + + @NotNull private final JTextField myEditorFontSizeField = new JTextField(4); + @NotNull private final JTextField myLineSpacingField = new JTextField(4); + private final FontComboBox myPrimaryCombo = new FontComboBox(); + private final JCheckBox myUseSecondaryFontCheckbox = new JCheckBox(ApplicationBundle.message("secondary.font")); + private final JCheckBox myEnableLigaturesCheckbox = new JCheckBox(ApplicationBundle.message("use.ligatures")); + private final FontComboBox mySecondaryCombo = new FontComboBox(false, false); + + @NotNull private final JBCheckBox myOnlyMonospacedCheckBox = + new JBCheckBox(ApplicationBundle.message("checkbox.show.only.monospaced.fonts")); + + private boolean myIsInSchemeChange; + private JLabel myPrimaryLabel; + private JLabel mySizeLabel; + + + protected AbstractFontOptionsPanel() { + setLayout(new MigLayout("ins 0, gap 5, flowx")); + initControls(); + } + + @SuppressWarnings("unchecked") + protected void initControls() { + add(myOnlyMonospacedCheckBox, "newline 10, sgx b, sx 2"); + + myPrimaryLabel = new JLabel(ApplicationBundle.message("primary.font")); + add(myPrimaryLabel, "newline, ax right"); + add(myPrimaryCombo, "sgx b"); + mySizeLabel = new JLabel(ApplicationBundle.message("editbox.font.size")); + add(mySizeLabel, "gapleft 20"); + add(myEditorFontSizeField); + add(new JLabel(ApplicationBundle.message("editbox.line.spacing")), "gapleft 20"); + add(myLineSpacingField); + + add(new JLabel(ApplicationBundle.message("label.fallback.fonts.list.description"), + MessageType.INFO.getDefaultIcon(), + SwingConstants.LEFT), "newline, sx 5"); + add(myUseSecondaryFontCheckbox, "newline, ax right"); + add(mySecondaryCombo, "sgx b"); + JPanel panel = new JPanel(new FlowLayout(FlowLayout.CENTER, 0, 0)); + myEnableLigaturesCheckbox.setBorder(null); + panel.add(myEnableLigaturesCheckbox); + JLabel warningIcon = new JLabel(AllIcons.General.BalloonWarning); + IdeTooltipManager.getInstance().setCustomTooltip( + warningIcon, + new TooltipWithClickableLinks.ForBrowser(warningIcon, + ApplicationBundle.message("ligatures.jre.warning", + ApplicationNamesInfo.getInstance().getFullProductName()))); + warningIcon.setBorder(JBUI.Borders.emptyLeft(5)); + warningIcon.setVisible(!SystemInfo.isJetbrainsJvm); + panel.add(warningIcon); + add(panel, "newline, sx 2"); + + myOnlyMonospacedCheckBox.setBorder(null); + myUseSecondaryFontCheckbox.setBorder(null); + mySecondaryCombo.setEnabled(false); + + myOnlyMonospacedCheckBox.setSelected(EditorColorsManager.getInstance().isUseOnlyMonospacedFonts()); + myOnlyMonospacedCheckBox.addActionListener(e -> { + EditorColorsManager.getInstance().setUseOnlyMonospacedFonts(myOnlyMonospacedCheckBox.isSelected()); + myPrimaryCombo.setMonospacedOnly(myOnlyMonospacedCheckBox.isSelected()); + mySecondaryCombo.setMonospacedOnly(myOnlyMonospacedCheckBox.isSelected()); + }); + myPrimaryCombo.setMonospacedOnly(myOnlyMonospacedCheckBox.isSelected()); + myPrimaryCombo.setRenderer(RENDERER); + + mySecondaryCombo.setMonospacedOnly(myOnlyMonospacedCheckBox.isSelected()); + mySecondaryCombo.setRenderer(RENDERER); + + myUseSecondaryFontCheckbox.addActionListener(e -> { + mySecondaryCombo.setEnabled(myUseSecondaryFontCheckbox.isSelected()); + syncFontFamilies(); + }); + ItemListener itemListener = this::syncFontFamilies; + myPrimaryCombo.addItemListener(itemListener); + mySecondaryCombo.addItemListener(itemListener); + + ActionListener actionListener = this::syncFontFamilies; + myPrimaryCombo.addActionListener(actionListener); + mySecondaryCombo.addActionListener(actionListener); + + myEditorFontSizeField.getDocument().addDocumentListener(new DocumentAdapter() { + @Override + public void textChanged(DocumentEvent event) { + if (myIsInSchemeChange || !SwingUtilities.isEventDispatchThread()) return; + String selectedFont = myPrimaryCombo.getFontName(); + if (selectedFont != null) { + setFontSize(getFontSizeFromField()); + } + updateDescription(true); + } + }); + myEditorFontSizeField.addKeyListener(new KeyAdapter() { + @Override + public void keyPressed(KeyEvent e) { + if (e.getKeyCode() != KeyEvent.VK_UP && e.getKeyCode() != KeyEvent.VK_DOWN) return; + boolean up = e.getKeyCode() == KeyEvent.VK_UP; + try { + int value = Integer.parseInt(myEditorFontSizeField.getText()); + value += (up ? 1 : -1); + value = Math.min(EditorFontsConstants.getMaxEditorFontSize(), Math.max(EditorFontsConstants.getMinEditorFontSize(), value)); + myEditorFontSizeField.setText(String.valueOf(value)); + } + catch (NumberFormatException ignored) { + } + } + }); + + myLineSpacingField.getDocument().addDocumentListener(new DocumentAdapter() { + @Override + public void textChanged(DocumentEvent event) { + if (myIsInSchemeChange) return; + float lineSpacing = getLineSpacingFromField(); + if (getLineSpacing() != lineSpacing) { + setCurrentLineSpacing(lineSpacing); + } + updateDescription(true); + } + }); + myLineSpacingField.addKeyListener(new KeyAdapter() { + @Override + public void keyPressed(KeyEvent e) { + if (e.getKeyCode() != KeyEvent.VK_UP && e.getKeyCode() != KeyEvent.VK_DOWN) return; + boolean up = e.getKeyCode() == KeyEvent.VK_UP; + try { + float value = Float.parseFloat(myLineSpacingField.getText()); + value += (up ? 1 : -1) * .1F; + value = Math.min(EditorFontsConstants.getMaxEditorLineSpacing(), Math.max(EditorFontsConstants.getMinEditorLineSpacing(), value)); + myLineSpacingField.setText(String.format(Locale.ENGLISH, "%.1f", value)); + } + catch (NumberFormatException ignored) { + } + } + }); + myEnableLigaturesCheckbox.addActionListener(e -> { + FontPreferences preferences = getFontPreferences(); + if (preferences instanceof ModifiableFontPreferences) { + ((ModifiableFontPreferences)preferences).setUseLigatures(myEnableLigaturesCheckbox.isSelected()); + updateDescription(true); + } + }); + } + + protected void setDelegatingPreferences(boolean isDelegating) { + } + + private int getFontSizeFromField() { + try { + return Math.min(EditorFontsConstants.getMaxEditorFontSize(), + Math.max(EditorFontsConstants.getMinEditorFontSize(), Integer.parseInt(myEditorFontSizeField.getText()))); + } + catch (NumberFormatException e) { + return EditorFontsConstants.getDefaultEditorFontSize(); + } + } + + private float getLineSpacingFromField() { + try { + return Math.min(EditorFontsConstants.getMaxEditorLineSpacing(), + Math.max(EditorFontsConstants.getMinEditorLineSpacing(), Float.parseFloat(myLineSpacingField.getText()))); + } + catch (NumberFormatException e) { + return EditorFontsConstants.getDefaultEditorLineSpacing(); + } + } + + /** + * Processes an event from {@code FontComboBox} + * if it is enabled and its item is selected. + * + * @param event the event to process + */ + private void syncFontFamilies(AWTEvent event) { + Object source = event.getSource(); + if (source instanceof FontComboBox) { + FontComboBox combo = (FontComboBox)source; + if (combo.isEnabled() && combo.isShowing() && combo.getSelectedItem() != null) { + syncFontFamilies(); + } + } + } + + private void syncFontFamilies() { + if (myIsInSchemeChange) { + return; + } + FontPreferences fontPreferences = getFontPreferences(); + if (fontPreferences instanceof ModifiableFontPreferences) { + ModifiableFontPreferences modifiableFontPreferences = (ModifiableFontPreferences)fontPreferences; + modifiableFontPreferences.clearFonts(); + String primaryFontFamily = myPrimaryCombo.getFontName(); + String secondaryFontFamily = mySecondaryCombo.isEnabled() ? mySecondaryCombo.getFontName() : null; + int fontSize = getFontSizeFromField(); + if (primaryFontFamily != null) { + if (!FontPreferences.DEFAULT_FONT_NAME.equals(primaryFontFamily)) { + modifiableFontPreferences.addFontFamily(primaryFontFamily); + } + modifiableFontPreferences.register(primaryFontFamily, fontSize); + } + if (secondaryFontFamily != null) { + if (!FontPreferences.DEFAULT_FONT_NAME.equals(secondaryFontFamily)) { + modifiableFontPreferences.addFontFamily(secondaryFontFamily); + } + modifiableFontPreferences.register(secondaryFontFamily, fontSize); + } + updateDescription(true); + } + } + + @Override + public void updateOptionsList() { + myIsInSchemeChange = true; + + myLineSpacingField.setText(Float.toString(getLineSpacing())); + FontPreferences fontPreferences = getFontPreferences(); + List fontFamilies = fontPreferences.getEffectiveFontFamilies(); + myPrimaryCombo.setFontName(fontPreferences.getFontFamily()); + boolean isThereSecondaryFont = fontFamilies.size() > 1; + myUseSecondaryFontCheckbox.setSelected(isThereSecondaryFont); + mySecondaryCombo.setFontName(isThereSecondaryFont ? fontFamilies.get(1) : null); + myEditorFontSizeField.setText(String.valueOf(fontPreferences.getSize(fontPreferences.getFontFamily()))); + + boolean isReadOnlyColorScheme = isReadOnly(); + updateCustomOptions(); + boolean readOnly = isReadOnlyColorScheme || !(getFontPreferences() instanceof ModifiableFontPreferences); + myPrimaryCombo.setEnabled(!readOnly); + myPrimaryLabel.setEnabled(!readOnly); + mySecondaryCombo.setEnabled(isThereSecondaryFont && !readOnly); + myOnlyMonospacedCheckBox.setEnabled(!readOnly); + myLineSpacingField.setEnabled(!readOnly); + myEditorFontSizeField.setEnabled(!readOnly); + mySizeLabel.setEnabled(!readOnly); + myUseSecondaryFontCheckbox.setEnabled(!readOnly); + + myEnableLigaturesCheckbox.setEnabled(!readOnly && SystemInfo.isJetbrainsJvm); + myEnableLigaturesCheckbox.setSelected(fontPreferences.useLigatures()); + + myIsInSchemeChange = false; + } + + protected void updateCustomOptions() { + } + + protected abstract boolean isReadOnly(); + + protected abstract boolean isDelegating(); + + @NotNull + protected abstract FontPreferences getFontPreferences(); + + protected abstract void setFontSize(int fontSize); + + protected abstract float getLineSpacing(); + + protected abstract void setCurrentLineSpacing(float lineSpacing); + + @Override + @Nullable + public Runnable showOption(final String option) { + return null; + } + + @Override + public void applyChangesToScheme() { + } + + @Override + public void selectOption(final String typeToSelect) { + } + + public boolean updateDescription(boolean modified) { + if (modified && isReadOnly()) { + return false; + } + fireFontChanged(); + return true; + } + + @Override + public void addListener(ColorAndFontSettingsListener listener) { + myDispatcher.addListener(listener); + } + + public void fireFontChanged() { + myDispatcher.getMulticaster().fontChanged(); + } + + @Override + public JPanel getPanel() { + return this; + } + + @Override + public Set processListOptions() { + return new HashSet<>(); + } + +} diff --git a/platform/lang-impl/src/com/intellij/application/options/colors/ColorAndFontOptions.java b/platform/lang-impl/src/com/intellij/application/options/colors/ColorAndFontOptions.java index dbea5da7dd00..e056e762eb14 100644 --- a/platform/lang-impl/src/com/intellij/application/options/colors/ColorAndFontOptions.java +++ b/platform/lang-impl/src/com/intellij/application/options/colors/ColorAndFontOptions.java @@ -512,7 +512,7 @@ public class ColorAndFontOptions extends SearchableConfigurable.Parent.Abstract @Override @NotNull public NewColorAndFontPanel createPanel(@NotNull ColorAndFontOptions options) { - FontEditorPreview previewPanel = new FontEditorPreview(options, true); + FontEditorPreview previewPanel = new FontEditorPreview(()->options.getSelectedScheme(), true); return new NewColorAndFontPanel(new SchemesPanel(options), new FontOptions(options), previewPanel, "Font", null, null){ @Override public boolean containsFontOptions() { @@ -532,7 +532,7 @@ public class ColorAndFontOptions extends SearchableConfigurable.Parent.Abstract @Override @NotNull public NewColorAndFontPanel createPanel(@NotNull ColorAndFontOptions options) { - FontEditorPreview previewPanel = new FontEditorPreview(options, false) { + FontEditorPreview previewPanel = new FontEditorPreview(()->options.getSelectedScheme(), false) { @Override protected EditorColorsScheme updateOptionsScheme(EditorColorsScheme selectedScheme) { return ConsoleViewUtil.updateConsoleColorScheme(selectedScheme); @@ -1082,8 +1082,6 @@ public class ColorAndFontOptions extends SearchableConfigurable.Parent.Abstract private MyColorScheme(@NotNull EditorColorsScheme parentScheme) { super(parentScheme); - parentScheme.getFontPreferences().copyTo(getFontPreferences()); - if (parentScheme.isUseEditorFontPreferencesInConsole()) { setUseEditorFontPreferencesInConsole(); } @@ -1092,6 +1090,13 @@ public class ColorAndFontOptions extends SearchableConfigurable.Parent.Abstract } setConsoleLineSpacing(parentScheme.getConsoleLineSpacing()); + if (parentScheme.isUseAppFontPreferencesInEditor()) { + setUseAppFontPreferencesInEditor(); + } + else { + setFontPreferences(parentScheme.getFontPreferences()); + } + setQuickDocFontSize(parentScheme.getQuickDocFontSize()); myName = parentScheme.getName(); @@ -1149,11 +1154,11 @@ public class ColorAndFontOptions extends SearchableConfigurable.Parent.Abstract } private boolean isFontModified() { - return !getFontPreferences().equals(myParentScheme.getFontPreferences()); + return !areDelegatingOrEqual(getFontPreferences(), myParentScheme.getFontPreferences()); } private boolean isConsoleFontModified() { - return !getConsoleFontPreferences().equals(myParentScheme.getConsoleFontPreferences()); + return !areDelegatingOrEqual(getConsoleFontPreferences(), myParentScheme.getConsoleFontPreferences()); } private boolean apply() { @@ -1166,7 +1171,12 @@ public class ColorAndFontOptions extends SearchableConfigurable.Parent.Abstract private boolean apply(@NotNull EditorColorsScheme scheme) { boolean isModified = isFontModified() || isConsoleFontModified(); - scheme.setFontPreferences(getFontPreferences()); + if (isUseAppFontPreferencesInEditor()) { + scheme.setUseAppFontPreferencesInEditor(); + } + else { + scheme.setFontPreferences(getFontPreferences()); + } if (isUseEditorFontPreferencesInConsole()) { scheme.setUseEditorFontPreferencesInConsole(); diff --git a/platform/lang-impl/src/com/intellij/application/options/colors/ConsoleFontOptions.java b/platform/lang-impl/src/com/intellij/application/options/colors/ConsoleFontOptions.java index a3ecb00c9048..133243d0bd08 100644 --- a/platform/lang-impl/src/com/intellij/application/options/colors/ConsoleFontOptions.java +++ b/platform/lang-impl/src/com/intellij/application/options/colors/ConsoleFontOptions.java @@ -18,13 +18,18 @@ package com.intellij.application.options.colors; import com.intellij.openapi.editor.colors.DelegatingFontPreferences; import com.intellij.openapi.editor.colors.FontPreferences; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; -/** - * User: anna - */ public class ConsoleFontOptions extends FontOptions { public ConsoleFontOptions(ColorAndFontOptions options) { - super(options, "Use editor font preferences"); + super(options); + } + + + @Nullable + @Override + protected String getInheritFontTitle() { + return "Use editor font preferences"; } @NotNull diff --git a/platform/lang-impl/src/com/intellij/application/options/colors/FontEditorPreview.java b/platform/lang-impl/src/com/intellij/application/options/colors/FontEditorPreview.java index 22b90391fc8e..68f30e8b5757 100644 --- a/platform/lang-impl/src/com/intellij/application/options/colors/FontEditorPreview.java +++ b/platform/lang-impl/src/com/intellij/application/options/colors/FontEditorPreview.java @@ -24,28 +24,27 @@ import com.intellij.openapi.editor.*; import com.intellij.openapi.editor.colors.EditorColorsScheme; import com.intellij.openapi.editor.ex.EditorEx; import com.intellij.openapi.editor.ex.EditorMarkupModel; -import com.intellij.openapi.editor.impl.EditorImpl; import com.intellij.openapi.util.Disposer; import com.intellij.util.EventDispatcher; -import com.intellij.util.ui.JBUI; import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import java.awt.*; +import java.util.function.Supplier; public class FontEditorPreview implements PreviewPanel{ private final EditorEx myEditor; - private final ColorAndFontOptions myOptions; + private final Supplier mySchemeSupplier; private final EventDispatcher myDispatcher = EventDispatcher.create(ColorAndFontSettingsListener.class); - FontEditorPreview(final ColorAndFontOptions options, boolean editable) { - myOptions = options; + public FontEditorPreview(final Supplier schemeSupplier, boolean editable) { + mySchemeSupplier = schemeSupplier; @Nls String text = getIDEDemoText(); - myEditor = (EditorEx)createPreviewEditor(text, 10, 3, -1, myOptions, editable); + myEditor = (EditorEx)createPreviewEditor(text, 10, 3, -1, mySchemeSupplier.get(), editable); installTrafficLights(myEditor); } @@ -82,11 +81,11 @@ public class FontEditorPreview implements PreviewPanel{ ((EditorMarkupModel)editor.getMarkupModel()).setErrorStripeVisible(true); } - static Editor createPreviewEditor(String text, int column, int line, int selectedLine, ColorAndFontOptions options, boolean editable) { + static Editor createPreviewEditor(String text, int column, int line, int selectedLine, EditorColorsScheme scheme, boolean editable) { EditorFactory editorFactory = EditorFactory.getInstance(); Document editorDocument = editorFactory.createDocument(text); EditorEx editor = (EditorEx) (editable ? editorFactory.createEditor(editorDocument) : editorFactory.createViewer(editorDocument)); - editor.setColorsScheme(options.getSelectedScheme()); + editor.setColorsScheme(scheme); EditorSettings settings = editor.getSettings(); settings.setLineNumbersShown(true); settings.setWhitespacesShown(true); @@ -115,7 +114,7 @@ public class FontEditorPreview implements PreviewPanel{ @Override public void updateView() { - EditorColorsScheme scheme = updateOptionsScheme(myOptions.getSelectedScheme()); + EditorColorsScheme scheme = updateOptionsScheme(mySchemeSupplier.get()); myEditor.setColorsScheme(scheme); myEditor.reinitSettings(); diff --git a/platform/lang-impl/src/com/intellij/application/options/colors/FontOptions.java b/platform/lang-impl/src/com/intellij/application/options/colors/FontOptions.java index cd2ca0dd8802..f98822a8e4d0 100644 --- a/platform/lang-impl/src/com/intellij/application/options/colors/FontOptions.java +++ b/platform/lang-impl/src/com/intellij/application/options/colors/FontOptions.java @@ -16,74 +16,36 @@ package com.intellij.application.options.colors; -import com.intellij.application.options.EditorFontsConstants; -import com.intellij.icons.AllIcons; -import com.intellij.ide.IdeTooltipManager; -import com.intellij.openapi.application.ApplicationBundle; -import com.intellij.openapi.application.ApplicationNamesInfo; -import com.intellij.openapi.editor.colors.*; -import com.intellij.openapi.ui.MessageType; -import com.intellij.openapi.util.SystemInfo; -import com.intellij.ui.DocumentAdapter; -import com.intellij.ui.FontComboBox; -import com.intellij.ui.FontInfoRenderer; -import com.intellij.ui.TooltipWithClickableLinks; -import com.intellij.ui.components.JBCheckBox; -import com.intellij.util.EventDispatcher; -import com.intellij.util.ui.JBUI; -import net.miginfocom.swing.MigLayout; +import com.intellij.openapi.editor.colors.DelegatingFontPreferences; +import com.intellij.openapi.editor.colors.EditorColorsScheme; +import com.intellij.openapi.editor.colors.FontPreferences; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import javax.swing.*; -import javax.swing.event.DocumentEvent; -import java.awt.*; -import java.awt.event.*; -import java.util.HashSet; -import java.util.List; -import java.util.Locale; -import java.util.Set; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; -public class FontOptions extends JPanel implements OptionsPanel{ - private static final FontInfoRenderer RENDERER = new FontInfoRenderer() { - @Override - protected boolean isEditorFont() { - return true; - } - }; - - private final EventDispatcher myDispatcher = EventDispatcher.create(ColorAndFontSettingsListener.class); +public class FontOptions extends AbstractFontOptionsPanel { @NotNull private final ColorAndFontOptions myOptions; - @NotNull private final JTextField myEditorFontSizeField = new JTextField(4); - @NotNull private final JTextField myLineSpacingField = new JTextField(4); - private final FontComboBox myPrimaryCombo = new FontComboBox(); - private final JCheckBox myUseSecondaryFontCheckbox = new JCheckBox(ApplicationBundle.message("secondary.font")); - private final JCheckBox myEnableLigaturesCheckbox = new JCheckBox(ApplicationBundle.message("use.ligatures")); - private final FontComboBox mySecondaryCombo = new FontComboBox(false, false); + private @Nullable JCheckBox myInheritFontCheckbox; - private final JCheckBox myInheritFontCheckbox; - - @NotNull private final JBCheckBox myOnlyMonospacedCheckBox = - new JBCheckBox(ApplicationBundle.message("checkbox.show.only.monospaced.fonts")); - - private boolean myIsInSchemeChange; - private JLabel myPrimaryLabel; - private JLabel mySizeLabel; - - public FontOptions(@NotNull ColorAndFontOptions options) { - this(options, null); - } - - public FontOptions(@NotNull ColorAndFontOptions options, @Nullable String inheritFontTitle) { - setLayout(new MigLayout("ins 0, gap 5, flowx")); myOptions = options; - myInheritFontCheckbox = inheritFontTitle != null ? new JCheckBox(inheritFontTitle) : null; + } + + @Nullable + protected String getInheritFontTitle() { + return "Use default font preferences"; + } + + @Override + protected void initControls() { + myInheritFontCheckbox = getInheritFontTitle() != null ? new JCheckBox(getInheritFontTitle()) : null; if (myInheritFontCheckbox != null) { add(myInheritFontCheckbox, "newline, sx 2"); - myInheritFontCheckbox.setSelected(getFontPreferences() instanceof DelegatingFontPreferences); myInheritFontCheckbox.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { @@ -92,284 +54,63 @@ public class FontOptions extends JPanel implements OptionsPanel{ }); add(new JSeparator(), "newline, growx, span"); } - - add(myOnlyMonospacedCheckBox, "newline 10, sgx b, sx 2"); - - myPrimaryLabel = new JLabel(ApplicationBundle.message("primary.font")); - add(myPrimaryLabel, "newline, ax right"); - add(myPrimaryCombo, "sgx b"); - mySizeLabel = new JLabel(ApplicationBundle.message("editbox.font.size")); - add(mySizeLabel, "gapleft 20"); - add(myEditorFontSizeField); - add(new JLabel(ApplicationBundle.message("editbox.line.spacing")), "gapleft 20"); - add(myLineSpacingField); - - add(new JLabel(ApplicationBundle.message("label.fallback.fonts.list.description"), - MessageType.INFO.getDefaultIcon(), - SwingConstants.LEFT), "newline, sx 5"); - add(myUseSecondaryFontCheckbox, "newline, ax right"); - add(mySecondaryCombo, "sgx b"); - JPanel panel = new JPanel(new FlowLayout(FlowLayout.CENTER, 0, 0)); - myEnableLigaturesCheckbox.setBorder(null); - panel.add(myEnableLigaturesCheckbox); - JLabel warningIcon = new JLabel(AllIcons.General.BalloonWarning); - IdeTooltipManager.getInstance().setCustomTooltip( - warningIcon, - new TooltipWithClickableLinks.ForBrowser(warningIcon, - ApplicationBundle.message("ligatures.jre.warning", - ApplicationNamesInfo.getInstance().getFullProductName()))); - warningIcon.setBorder(JBUI.Borders.emptyLeft(5)); - warningIcon.setVisible(!SystemInfo.isJetbrainsJvm); - panel.add(warningIcon); - add(panel, "newline, sx 2"); - - myOnlyMonospacedCheckBox.setBorder(null); - myUseSecondaryFontCheckbox.setBorder(null); - mySecondaryCombo.setEnabled(false); - - myOnlyMonospacedCheckBox.setSelected(EditorColorsManager.getInstance().isUseOnlyMonospacedFonts()); - myOnlyMonospacedCheckBox.addActionListener(e -> { - EditorColorsManager.getInstance().setUseOnlyMonospacedFonts(myOnlyMonospacedCheckBox.isSelected()); - myPrimaryCombo.setMonospacedOnly(myOnlyMonospacedCheckBox.isSelected()); - mySecondaryCombo.setMonospacedOnly(myOnlyMonospacedCheckBox.isSelected()); - }); - myPrimaryCombo.setMonospacedOnly(myOnlyMonospacedCheckBox.isSelected()); - myPrimaryCombo.setRenderer(RENDERER); - - mySecondaryCombo.setMonospacedOnly(myOnlyMonospacedCheckBox.isSelected()); - mySecondaryCombo.setRenderer(RENDERER); - - myUseSecondaryFontCheckbox.addActionListener(e -> { - mySecondaryCombo.setEnabled(myUseSecondaryFontCheckbox.isSelected()); - syncFontFamilies(); - }); - ItemListener itemListener = this::syncFontFamilies; - myPrimaryCombo.addItemListener(itemListener); - mySecondaryCombo.addItemListener(itemListener); - - ActionListener actionListener = this::syncFontFamilies; - myPrimaryCombo.addActionListener(actionListener); - mySecondaryCombo.addActionListener(actionListener); - - myEditorFontSizeField.getDocument().addDocumentListener(new DocumentAdapter() { - @Override - public void textChanged(DocumentEvent event) { - if (myIsInSchemeChange || !SwingUtilities.isEventDispatchThread()) return; - String selectedFont = myPrimaryCombo.getFontName(); - if (selectedFont != null) { - setFontSize(getFontSizeFromField()); - } - updateDescription(true); - } - }); - myEditorFontSizeField.addKeyListener(new KeyAdapter() { - @Override - public void keyPressed(KeyEvent e) { - if (e.getKeyCode() != KeyEvent.VK_UP && e.getKeyCode() != KeyEvent.VK_DOWN) return; - boolean up = e.getKeyCode() == KeyEvent.VK_UP; - try { - int value = Integer.parseInt(myEditorFontSizeField.getText()); - value += (up ? 1 : -1); - value = Math.min(EditorFontsConstants.getMaxEditorFontSize(), Math.max(EditorFontsConstants.getMinEditorFontSize(), value)); - myEditorFontSizeField.setText(String.valueOf(value)); - } - catch (NumberFormatException ignored) { - } - } - }); - - myLineSpacingField.getDocument().addDocumentListener(new DocumentAdapter() { - @Override - public void textChanged(DocumentEvent event) { - if (myIsInSchemeChange) return; - float lineSpacing = getLineSpacingFromField(); - if (getLineSpacing() != lineSpacing) { - setCurrentLineSpacing(lineSpacing); - } - updateDescription(true); - } - }); - myLineSpacingField.addKeyListener(new KeyAdapter() { - @Override - public void keyPressed(KeyEvent e) { - if (e.getKeyCode() != KeyEvent.VK_UP && e.getKeyCode() != KeyEvent.VK_DOWN) return; - boolean up = e.getKeyCode() == KeyEvent.VK_UP; - try { - float value = Float.parseFloat(myLineSpacingField.getText()); - value += (up ? 1 : -1) * .1F; - value = Math.min(EditorFontsConstants.getMaxEditorLineSpacing(), Math.max(EditorFontsConstants.getMinEditorLineSpacing(), value)); - myLineSpacingField.setText(String.format(Locale.ENGLISH, "%.1f", value)); - } - catch (NumberFormatException ignored) { - } - } - }); - myEnableLigaturesCheckbox.addActionListener(e -> { - FontPreferences preferences = getFontPreferences(); - if (preferences instanceof ModifiableFontPreferences) { - ((ModifiableFontPreferences)preferences).setUseLigatures(myEnableLigaturesCheckbox.isSelected()); - updateDescription(true); - } - }); + super.initControls(); } protected void setDelegatingPreferences(boolean isDelegating) { - } - - private int getFontSizeFromField() { - try { - return Math.min(EditorFontsConstants.getMaxEditorFontSize(), - Math.max(EditorFontsConstants.getMinEditorFontSize(), Integer.parseInt(myEditorFontSizeField.getText()))); + FontPreferences currPrefs = getCurrentScheme().getFontPreferences(); + if (currPrefs instanceof DelegatingFontPreferences == isDelegating) return; + if (isDelegating) { + getCurrentScheme().setUseAppFontPreferencesInEditor(); } - catch (NumberFormatException e) { - return EditorFontsConstants.getDefaultEditorFontSize(); - } - } - - private float getLineSpacingFromField() { - try { - return Math.min(EditorFontsConstants.getMaxEditorLineSpacing(), Math.max(EditorFontsConstants.getMinEditorLineSpacing(), Float.parseFloat(myLineSpacingField.getText()))); - } catch (NumberFormatException e){ - return EditorFontsConstants.getDefaultEditorLineSpacing(); - } - } - - /** - * Processes an event from {@code FontComboBox} - * if it is enabled and its item is selected. - * - * @param event the event to process - */ - private void syncFontFamilies(AWTEvent event) { - Object source = event.getSource(); - if (source instanceof FontComboBox) { - FontComboBox combo = (FontComboBox)source; - if (combo.isEnabled() && combo.isShowing() && combo.getSelectedItem() != null) { - syncFontFamilies(); - } - } - } - - private void syncFontFamilies() { - if (myIsInSchemeChange) { - return; - } - FontPreferences fontPreferences = getFontPreferences(); - if (fontPreferences instanceof ModifiableFontPreferences) { - ModifiableFontPreferences modifiableFontPreferences = (ModifiableFontPreferences)fontPreferences; - modifiableFontPreferences.clearFonts(); - String primaryFontFamily = myPrimaryCombo.getFontName(); - String secondaryFontFamily = mySecondaryCombo.isEnabled() ? mySecondaryCombo.getFontName() : null; - int fontSize = getFontSizeFromField(); - if (primaryFontFamily != null) { - if (!FontPreferences.DEFAULT_FONT_NAME.equals(primaryFontFamily)) { - modifiableFontPreferences.addFontFamily(primaryFontFamily); - } - modifiableFontPreferences.register(primaryFontFamily, fontSize); - } - if (secondaryFontFamily != null) { - if (!FontPreferences.DEFAULT_FONT_NAME.equals(secondaryFontFamily)) { - modifiableFontPreferences.addFontFamily(secondaryFontFamily); - } - modifiableFontPreferences.register(secondaryFontFamily, fontSize); - } - updateDescription(true); + else { + getCurrentScheme().setFontPreferences(getFontPreferences()); } + updateOptionsList(); + updateDescription(true); } @Override - public void updateOptionsList() { - myIsInSchemeChange = true; + protected boolean isReadOnly() { + return ColorAndFontOptions.isReadOnly(myOptions.getSelectedScheme()); + } - myLineSpacingField.setText(Float.toString(getLineSpacing())); - FontPreferences fontPreferences = getFontPreferences(); - List fontFamilies = fontPreferences.getEffectiveFontFamilies(); - myPrimaryCombo.setFontName(fontPreferences.getFontFamily()); - boolean isThereSecondaryFont = fontFamilies.size() > 1; - myUseSecondaryFontCheckbox.setSelected(isThereSecondaryFont); - mySecondaryCombo.setFontName(isThereSecondaryFont ? fontFamilies.get(1) : null); - myEditorFontSizeField.setText(String.valueOf(fontPreferences.getSize(fontPreferences.getFontFamily()))); - - boolean isReadOnlyColorScheme = ColorAndFontOptions.isReadOnly(myOptions.getSelectedScheme()); - if (myInheritFontCheckbox != null) { - myInheritFontCheckbox.setEnabled(!isReadOnlyColorScheme); - myInheritFontCheckbox.setSelected(myOptions.getSelectedScheme().getConsoleFontPreferences() instanceof DelegatingFontPreferences); - } - boolean readOnly = isReadOnlyColorScheme || !(getFontPreferences() instanceof ModifiableFontPreferences); - myPrimaryCombo.setEnabled(!readOnly); - myPrimaryLabel.setEnabled(!readOnly); - mySecondaryCombo.setEnabled(isThereSecondaryFont && !readOnly); - myOnlyMonospacedCheckBox.setEnabled(!readOnly); - myLineSpacingField.setEnabled(!readOnly); - myEditorFontSizeField.setEnabled(!readOnly); - mySizeLabel.setEnabled(!readOnly); - myUseSecondaryFontCheckbox.setEnabled(!readOnly); - - myEnableLigaturesCheckbox.setEnabled(!readOnly && SystemInfo.isJetbrainsJvm); - myEnableLigaturesCheckbox.setSelected(fontPreferences.useLigatures()); - - myIsInSchemeChange = false; + @Override + protected boolean isDelegating() { + return getFontPreferences() instanceof DelegatingFontPreferences; } @NotNull + @Override protected FontPreferences getFontPreferences() { return getCurrentScheme().getFontPreferences(); } + @Override protected void setFontSize(int fontSize) { getCurrentScheme().setEditorFontSize(fontSize); } + @Override protected float getLineSpacing() { return getCurrentScheme().getLineSpacing(); } + @Override protected void setCurrentLineSpacing(float lineSpacing) { getCurrentScheme().setLineSpacing(lineSpacing); } - @Override - @Nullable - public Runnable showOption(final String option) { - return null; - } - - @Override - public void applyChangesToScheme() { - } - - @Override - public void selectOption(final String typeToSelect) { - } - protected EditorColorsScheme getCurrentScheme() { return myOptions.getSelectedScheme(); } - public boolean updateDescription(boolean modified) { - EditorColorsScheme scheme = myOptions.getSelectedScheme(); - - if (modified && ColorAndFontOptions.isReadOnly(scheme)) { - return false; + @Override + protected void updateCustomOptions() { + if (myInheritFontCheckbox != null) { + myInheritFontCheckbox.setEnabled(!isReadOnly()); + myInheritFontCheckbox.setSelected(isDelegating()); } - - myDispatcher.getMulticaster().fontChanged(); - - return true; } - @Override - public void addListener(ColorAndFontSettingsListener listener) { - myDispatcher.addListener(listener); - } - - @Override - public JPanel getPanel() { - return this; - } - - @Override - public Set processListOptions() { - return new HashSet<>(); - } } diff --git a/platform/lang-impl/src/com/intellij/application/options/colors/SimpleEditorPreview.java b/platform/lang-impl/src/com/intellij/application/options/colors/SimpleEditorPreview.java index 5ecf40f45011..353898b4826d 100644 --- a/platform/lang-impl/src/com/intellij/application/options/colors/SimpleEditorPreview.java +++ b/platform/lang-impl/src/com/intellij/application/options/colors/SimpleEditorPreview.java @@ -80,7 +80,7 @@ public class SimpleEditorPreview implements PreviewPanel { myHighlightsExtractor = new HighlightsExtractor(page.getAdditionalHighlightingTagToDescriptorMap(), INLINE_ELEMENTS); myEditor = (EditorEx)FontEditorPreview.createPreviewEditor( myHighlightsExtractor.extractHighlights(page.getDemoText(), myHighlightData), // text without tags - 10, 3, -1, myOptions, false); + 10, 3, -1, myOptions.getSelectedScheme(), false); FontEditorPreview.installTrafficLights(myEditor); myBlinkingAlarm = new Alarm().setActivationComponent(myEditor.getComponent()); diff --git a/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontConfigurable.java b/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontConfigurable.java new file mode 100644 index 000000000000..ccde0bc19ea6 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontConfigurable.java @@ -0,0 +1,84 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.application.options.editor.fonts; + +import com.intellij.application.options.editor.EditorOptionsPanel; +import com.intellij.openapi.editor.colors.EditorColorsManager; +import com.intellij.openapi.editor.colors.EditorFontCache; +import com.intellij.openapi.editor.colors.FontPreferences; +import com.intellij.openapi.editor.colors.impl.AppEditorFontOptions; +import com.intellij.openapi.editor.colors.impl.EditorColorsManagerImpl; +import com.intellij.openapi.options.ConfigurationException; +import com.intellij.openapi.options.SearchableConfigurable; +import org.jetbrains.annotations.Nls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; + +public class AppEditorFontConfigurable implements SearchableConfigurable { + + private AppEditorFontPanel myFontPanel; + + @NotNull + @Override + public String getId() { + return "editor.preferences.fonts.default"; + } + + @Nullable + @Override + public JComponent createComponent() { + myFontPanel = new AppEditorFontPanel(); + return myFontPanel; + } + + @Override + public boolean isModified() { + return !getStoredPreferences().equals(getUIFontPreferences()); + } + + @Override + public void apply() throws ConfigurationException { + FontPreferences fontPreferences = getUIFontPreferences(); + fontPreferences.copyTo(getStoredPreferences()); + EditorFontCache.getInstance().reset(); + ((EditorColorsManagerImpl)EditorColorsManager.getInstance()).schemeChangedOrSwitched(null); + EditorOptionsPanel.reinitAllEditors(); + } + + @NotNull + private FontPreferences getUIFontPreferences() { + return myFontPanel.getOptionsPanel().getFontPreferences(); + } + + @Override + public void reset() { + getStoredPreferences().copyTo(getUIFontPreferences()); + myFontPanel.getOptionsPanel().updateOptionsList(); + } + + @NotNull + private static FontPreferences getStoredPreferences() { + return AppEditorFontOptions.getInstance().getFontPreferences(); + } + + @Nls + @Override + public String getDisplayName() { + return "Default Font"; + } +} diff --git a/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontOptionsPanel.java b/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontOptionsPanel.java new file mode 100644 index 000000000000..9076bf69daf1 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontOptionsPanel.java @@ -0,0 +1,61 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.application.options.editor.fonts; + +import com.intellij.application.options.colors.AbstractFontOptionsPanel; +import com.intellij.openapi.editor.colors.EditorColorsScheme; +import com.intellij.openapi.editor.colors.FontPreferences; +import org.jetbrains.annotations.NotNull; + +public class AppEditorFontOptionsPanel extends AbstractFontOptionsPanel { + private final EditorColorsScheme myScheme; + + protected AppEditorFontOptionsPanel(EditorColorsScheme scheme) { + myScheme = scheme; + updateOptionsList(); + } + + @Override + protected boolean isReadOnly() { + return false; + } + + @Override + protected boolean isDelegating() { + return false; + } + + @NotNull + @Override + protected FontPreferences getFontPreferences() { + return myScheme.getFontPreferences(); + } + + @Override + protected void setFontSize(int fontSize) { + myScheme.setEditorFontSize(fontSize); + } + + @Override + protected float getLineSpacing() { + return getFontPreferences().getLineSpacing(); + } + + @Override + protected void setCurrentLineSpacing(float lineSpacing) { + getFontPreferences().setLineSpacing(lineSpacing); + } +} diff --git a/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontPanel.java b/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontPanel.java new file mode 100644 index 000000000000..a172a4894892 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/application/options/editor/fonts/AppEditorFontPanel.java @@ -0,0 +1,59 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.application.options.editor.fonts; + +import com.intellij.application.options.colors.ColorAndFontSettingsListener; +import com.intellij.application.options.colors.FontEditorPreview; +import com.intellij.openapi.editor.colors.EditorColorsManager; +import com.intellij.openapi.editor.colors.EditorColorsScheme; +import com.intellij.openapi.editor.colors.impl.FontPreferencesImpl; + +import javax.swing.*; +import java.awt.*; + +public class AppEditorFontPanel extends JPanel { + + private final AppEditorFontOptionsPanel myOptionsPanel; + private final FontEditorPreview myPreview; + private final EditorColorsScheme myPreviewScheme; + + public AppEditorFontPanel() { + super(new BorderLayout(0,10)); + myPreviewScheme = createPreviewScheme(); + myOptionsPanel = new AppEditorFontOptionsPanel(myPreviewScheme); + add(myOptionsPanel, BorderLayout.NORTH); + myPreview = new FontEditorPreview(()-> myPreviewScheme, true); + add(myPreview.getPanel(), BorderLayout.CENTER); + myOptionsPanel.addListener( + new ColorAndFontSettingsListener.Abstract() { + @Override + public void fontChanged() { + myPreview.updateView(); + } + } + ); + } + + private static EditorColorsScheme createPreviewScheme() { + EditorColorsScheme scheme = (EditorColorsScheme)EditorColorsManager.getInstance().getSchemeForCurrentUITheme().clone(); + scheme.setFontPreferences(new FontPreferencesImpl()); + return scheme; + } + + public AppEditorFontOptionsPanel getOptionsPanel() { + return myOptionsPanel; + } +} diff --git a/platform/platform-resources/src/META-INF/PlatformExtensions.xml b/platform/platform-resources/src/META-INF/PlatformExtensions.xml index 623a97fbaf10..a14f69b1bed8 100644 --- a/platform/platform-resources/src/META-INF/PlatformExtensions.xml +++ b/platform/platform-resources/src/META-INF/PlatformExtensions.xml @@ -326,6 +326,14 @@ serviceImplementation="com.intellij.openapi.actionSystem.impl.AbbreviationManagerImpl"/> + + + +