private void writeAttributes(Element attrElements) throws WriteExternalException {
List<TextAttributesKey> list = new ArrayList<TextAttributesKey>(myAttributesMap.keySet());
Collections.sort(list);
for (TextAttributesKey key : list) {
TextAttributes defaultAttr =
myParentScheme != null ? myParentScheme.getAttributes(key) : new TextAttributes();
TextAttributesKey baseKey = key.getFallbackAttributeKey();
TextAttributes defaultFallbackAttr =
baseKey != null && myParentScheme instanceof AbstractColorsScheme
? ((AbstractColorsScheme) myParentScheme).getFallbackAttributes(baseKey)
: null;
TextAttributes value = myAttributesMap.get(key);
if (!value.equals(defaultAttr) || defaultAttr == defaultFallbackAttr) {
Element element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, key.getExternalName());
if (baseKey == null || !value.isFallbackEnabled()) {
Element valueElement = new Element(VALUE_ELEMENT);
value.writeExternal(valueElement);
element.addContent(valueElement);
attrElements.addContent(element);
} else if (defaultAttr != defaultFallbackAttr) {
element.setAttribute(BASE_ATTRIBUTES_ATTR, baseKey.getExternalName());
attrElements.addContent(element);
}
}
}
}
@Override
public Font getFont(EditorFontType key) {
if (UISettings.getInstance().PRESENTATION_MODE) {
final Font font = myFonts.get(key);
return new Font(
font.getName(), font.getStyle(), UISettings.getInstance().PRESENTATION_MODE_FONT_SIZE);
}
return myFonts.get(key);
}
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);
}
private void writeColors(Element colorElements) {
List<ColorKey> list = new ArrayList<ColorKey>(myColorsMap.keySet());
Collections.sort(list);
for (ColorKey key : list) {
if (haveToWrite(key)) {
Color value = myColorsMap.get(key);
Element element = new Element(OPTION_ELEMENT);
element.setAttribute(NAME_ATTR, key.getExternalName());
element.setAttribute(
VALUE_ELEMENT, value != null ? Integer.toString(value.getRGB() & 0xFFFFFF, 16) : "");
colorElements.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;
}
/**
* Looks for explicitly specified attributes either in the scheme or its parent scheme. No
* fallback keys are used.
*
* @param key The key to use for search.
* @return Explicitly defined attribute or <code>null</code> if not found.
*/
@Nullable
public TextAttributes getDirectlyDefinedAttributes(@NotNull TextAttributesKey key) {
TextAttributes attributes = myAttributesMap.get(key);
if (attributes != null) {
return attributes;
}
return myParentScheme instanceof AbstractColorsScheme
? ((AbstractColorsScheme) myParentScheme).getDirectlyDefinedAttributes(key)
: null;
}
public void readAttributes(@NotNull Element childNode) {
for (Element e : childNode.getChildren(OPTION_ELEMENT)) {
TextAttributesKey name = TextAttributesKey.find(e.getAttributeValue(NAME_ATTR));
Element valueElement = e.getChild(VALUE_ELEMENT);
TextAttributes attr =
valueElement != null ? new TextAttributes(valueElement) : new TextAttributes();
myAttributesMap.put(name, attr);
migrateErrorStripeColorFrom14(name, attr);
}
}
private void readColors(Element childNode) {
for (final Object o : childNode.getChildren(OPTION_ELEMENT)) {
Element colorElement = (Element) o;
Color valueColor = readColorValue(colorElement);
final String colorName = colorElement.getAttributeValue(NAME_ATTR);
if (BACKGROUND_COLOR_NAME.equals(colorName)) {
// This setting has been deprecated to usages of HighlighterColors.TEXT attributes.
myDeprecatedBackgroundColor = valueColor;
}
ColorKey name = ColorKey.find(colorName);
myColorsMap.put(name, valueColor);
}
}
private boolean haveToWrite(final ColorKey key) {
Color value = myColorsMap.get(key);
if (myParentScheme != null) {
if (myParentScheme instanceof AbstractColorsScheme) {
if (Comparing.equal(((AbstractColorsScheme) myParentScheme).getOwnColor(key), value)
&& ((AbstractColorsScheme) myParentScheme).myColorsMap.containsKey(key)) {
return false;
}
} else {
if (Comparing.equal((myParentScheme).getColor(key), value)) {
return false;
}
}
}
return true;
}
protected Color getOwnColor(ColorKey key) {
return myColorsMap.get(key);
}
@Override
public void setFont(EditorFontType key, Font font) {
myFonts.put(key, font);
}