private static void readFontSettings(
@NotNull Element element, @NotNull FontPreferences preferences, boolean isDefaultScheme) {
List children = element.getChildren(OPTION_ELEMENT);
String fontFamily = null;
int size = -1;
for (Object child : children) {
Element e = (Element) child;
if (EDITOR_FONT_NAME.equals(e.getAttributeValue(NAME_ATTR))) {
fontFamily = getValue(e);
} else if (EDITOR_FONT_SIZE.equals(e.getAttributeValue(NAME_ATTR))) {
try {
size = Integer.parseInt(getValue(e));
if (isDefaultScheme) {
size = JBUI.scale(size);
}
} catch (NumberFormatException ex) {
// ignore
}
}
}
if (fontFamily != null && size > 1) {
preferences.register(fontFamily, size);
} else if (fontFamily != null) {
preferences.addFontFamily(fontFamily);
}
}
@Override
public void setEditorFontName(String fontName) {
int editorFontSize = getEditorFontSize();
myFontPreferences.clear();
myFontPreferences.register(fontName, editorFontSize);
initFonts();
}
@Override
public int getConsoleFontSize() {
String font = getConsoleFontName();
UISettings uiSettings = UISettings.getInstance();
if ((uiSettings == null || !uiSettings.PRESENTATION_MODE)
&& myConsoleFontPreferences.hasSize(font)) {
return myConsoleFontPreferences.getSize(font);
}
return getEditorFontSize();
}
private void readScheme(Element node) {
myDeprecatedBackgroundColor = null;
if (!SCHEME_ELEMENT.equals(node.getName())) {
return;
}
setName(node.getAttributeValue(NAME_ATTR));
int readVersion = Integer.parseInt(node.getAttributeValue(VERSION_ATTR, "0"));
if (readVersion > CURR_VERSION) {
throw new IllegalStateException("Unsupported color scheme version: " + readVersion);
}
myVersion = readVersion;
String isDefaultScheme = node.getAttributeValue(DEFAULT_SCHEME_ATTR);
boolean isDefault = isDefaultScheme != null && Boolean.parseBoolean(isDefaultScheme);
if (!isDefault) {
myParentScheme =
DefaultColorSchemesManager.getInstance()
.getScheme(node.getAttributeValue(PARENT_SCHEME_ATTR, DEFAULT_SCHEME_NAME));
}
for (final Object o : node.getChildren()) {
Element childNode = (Element) o;
String childName = childNode.getName();
if (OPTION_ELEMENT.equals(childName)) {
readSettings(childNode, isDefault);
} else if (EDITOR_FONT.equals(childName)) {
readFontSettings(childNode, myFontPreferences, isDefault);
} else if (CONSOLE_FONT.equals(childName)) {
readFontSettings(childNode, myConsoleFontPreferences, isDefault);
} else if (COLORS_ELEMENT.equals(childName)) {
readColors(childNode);
} else if (ATTRIBUTES_ELEMENT.equals(childName)) {
readAttributes(childNode);
}
}
if (myDeprecatedBackgroundColor != null) {
TextAttributes textAttributes = myAttributesMap.get(HighlighterColors.TEXT);
if (textAttributes == null) {
textAttributes =
new TextAttributes(
Color.black, myDeprecatedBackgroundColor, null, EffectType.BOXED, Font.PLAIN);
myAttributesMap.put(HighlighterColors.TEXT, textAttributes);
} else {
textAttributes.setBackgroundColor(myDeprecatedBackgroundColor);
}
}
if (myConsoleFontPreferences.getEffectiveFontFamilies().isEmpty()) {
myFontPreferences.copyTo(myConsoleFontPreferences);
}
initFonts();
}
protected void initFonts() {
String editorFontName = getEditorFontName();
int editorFontSize = getEditorFontSize();
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
public String getEditorFontName() {
if (myFallbackFontName != null) {
return myFallbackFontName;
}
return myFontPreferences.getFontFamily();
}
private static void writeFontPreferences(
@NotNull String key, @NotNull Element parent, @NotNull FontPreferences preferences) {
for (String fontFamily : preferences.getRealFontFamilies()) {
Element element = new Element(key);
Element e = new Element(OPTION_ELEMENT);
e.setAttribute(NAME_ATTR, EDITOR_FONT_NAME);
e.setAttribute(VALUE_ELEMENT, fontFamily);
element.addContent(e);
e = new Element(OPTION_ELEMENT);
e.setAttribute(NAME_ATTR, EDITOR_FONT_SIZE);
e.setAttribute(VALUE_ELEMENT, String.valueOf(preferences.getSize(fontFamily)));
element.addContent(e);
parent.addContent(element);
}
}
public void copyTo(AbstractColorsScheme newScheme) {
myFontPreferences.copyTo(newScheme.myFontPreferences);
newScheme.myLineSpacing = myLineSpacing;
newScheme.myQuickDocFontSize = myQuickDocFontSize;
myConsoleFontPreferences.copyTo(newScheme.myConsoleFontPreferences);
newScheme.myConsoleLineSpacing = myConsoleLineSpacing;
final Set<EditorFontType> types = myFonts.keySet();
for (EditorFontType type : types) {
Font font = myFonts.get(type);
newScheme.setFont(type, font);
}
newScheme.myAttributesMap = new HashMap<TextAttributesKey, TextAttributes>(myAttributesMap);
newScheme.myColorsMap = new HashMap<ColorKey, Color>(myColorsMap);
newScheme.myVersion = myVersion;
}
protected void initFonts() {
String consoleFontName = getConsoleFontName();
int consoleFontSize = getConsoleFontSize();
myFontPreferences.clear();
myFontPreferences.register(consoleFontName, consoleFontSize);
myFontsMap = new EnumMap<EditorFontType, Font>(EditorFontType.class);
Font plainFont = new Font(consoleFontName, Font.PLAIN, consoleFontSize);
Font boldFont = new Font(consoleFontName, Font.BOLD, consoleFontSize);
Font italicFont = new Font(consoleFontName, Font.ITALIC, consoleFontSize);
Font boldItalicFont = new Font(consoleFontName, Font.BOLD | Font.ITALIC, consoleFontSize);
myFontsMap.put(EditorFontType.PLAIN, plainFont);
myFontsMap.put(EditorFontType.BOLD, boldFont);
myFontsMap.put(EditorFontType.ITALIC, italicFont);
myFontsMap.put(EditorFontType.BOLD_ITALIC, boldItalicFont);
}
protected AbstractColorsScheme(EditorColorsScheme parentScheme) {
myParentScheme = parentScheme;
myFontPreferences.setChangeListener(
new Runnable() {
@Override
public void run() {
initFonts();
}
});
}
@Override
public void setConsoleFontPreferences(@NotNull FontPreferences preferences) {
preferences.copyTo(myFontPreferences);
initFonts();
}
@Override
public void setConsoleFontSize(int fontSize) {
myConsoleFontPreferences.register(getConsoleFontName(), fontSize);
initFonts();
}
@Override
public void setConsoleFontName(String fontName) {
int consoleFontSize = getConsoleFontSize();
myConsoleFontPreferences.clear();
myConsoleFontPreferences.register(fontName, consoleFontSize);
}
@Override
public String getConsoleFontName() {
return myConsoleFontPreferences.getFontFamily();
}
public void writeExternal(Element parentNode) throws WriteExternalException {
parentNode.setAttribute(NAME_ATTR, getName());
parentNode.setAttribute(VERSION_ATTR, Integer.toString(myVersion));
if (myParentScheme != null) {
parentNode.setAttribute(PARENT_SCHEME_ATTR, myParentScheme.getName());
}
Element element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, LINE_SPACING);
element.setAttribute(VALUE_ELEMENT, String.valueOf(getLineSpacing()));
parentNode.addContent(element);
// IJ has used a 'single customizable font' mode for ages. That's why we want to support that
// format now, when it's possible
// 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) {
element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, EDITOR_FONT_SIZE);
element.setAttribute(VALUE_ELEMENT, String.valueOf(getEditorFontSize() / JBUI.scale(1)));
parentNode.addContent(element);
} else {
writeFontPreferences(EDITOR_FONT, parentNode, myFontPreferences);
}
if (!myFontPreferences.equals(myConsoleFontPreferences)) {
if (myConsoleFontPreferences.getEffectiveFontFamilies().size() <= 1) {
element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, CONSOLE_FONT_NAME);
element.setAttribute(VALUE_ELEMENT, getConsoleFontName());
parentNode.addContent(element);
if (getConsoleFontSize() != getEditorFontSize()) {
element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, CONSOLE_FONT_SIZE);
element.setAttribute(
VALUE_ELEMENT, Integer.toString(getConsoleFontSize() / JBUI.scale(1)));
parentNode.addContent(element);
}
} else {
writeFontPreferences(CONSOLE_FONT, parentNode, myConsoleFontPreferences);
}
}
if (getConsoleLineSpacing() != getLineSpacing()) {
element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, CONSOLE_LINE_SPACING);
element.setAttribute(VALUE_ELEMENT, Float.toString(getConsoleLineSpacing()));
parentNode.addContent(element);
}
if (DEFAULT_FONT_SIZE != getQuickDocFontSize()) {
element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, EDITOR_QUICK_JAVADOC_FONT_SIZE);
element.setAttribute(VALUE_ELEMENT, getQuickDocFontSize().toString());
parentNode.addContent(element);
}
if (useOldFontFormat) {
element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, EDITOR_FONT_NAME);
element.setAttribute(VALUE_ELEMENT, getEditorFontName());
parentNode.addContent(element);
}
Element colorElements = new Element(COLORS_ELEMENT);
Element attrElements = new Element(ATTRIBUTES_ELEMENT);
writeColors(colorElements);
writeAttributes(attrElements);
if (colorElements.getChildren().size() > 0) {
parentNode.addContent(colorElements);
}
if (attrElements.getChildren().size() > 0) {
parentNode.addContent(attrElements);
}
}
@Override
public int getEditorFontSize() {
return myFontPreferences.getSize(getEditorFontName());
}
@Override
public void setEditorFontSize(int fontSize) {
myFontPreferences.register(getEditorFontName(), fontSize);
initFonts();
}