platform-impl/src/com/intellij/openapi/editor/colors/impl/EditorColorsManagerImpl.java

   1 /**
   2  * @author Yura Cangea
   3  */
   4 package com.intellij.openapi.editor.colors.impl;
   5
   6 import com.intellij.openapi.application.PathManager;
   7 import com.intellij.openapi.components.ExportableApplicationComponent;
   8 import com.intellij.openapi.components.RoamingType;
   9 import com.intellij.openapi.diagnostic.Logger;
  10 import com.intellij.openapi.editor.colors.EditorColorsListener;
  11 import com.intellij.openapi.editor.colors.EditorColorsManager;
  12 import com.intellij.openapi.editor.colors.EditorColorsScheme;
  13 import com.intellij.openapi.editor.colors.ex.DefaultColorSchemesManager;
  14 import com.intellij.openapi.options.*;
  15 import com.intellij.openapi.util.DefaultJDOMExternalizer;
  16 import com.intellij.openapi.util.InvalidDataException;
  17 import com.intellij.openapi.util.NamedJDOMExternalizable;
  18 import com.intellij.openapi.util.WriteExternalException;
  19 import org.jdom.Document;
  20 import org.jdom.Element;
  21 import org.jdom.JDOMException;
  22 import org.jetbrains.annotations.NonNls;
  23 import org.jetbrains.annotations.NotNull;
  24
  25 import java.io.File;
  26 import java.io.IOException;
  27 import java.util.ArrayList;
  28 import java.util.Collection;
  29 import java.util.Collections;
  30 import java.util.Comparator;
  31
  32 public class EditorColorsManagerImpl extends EditorColorsManager
  33     implements NamedJDOMExternalizable, ExportableApplicationComponent {
  34   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.editor.colors.impl.EditorColorsManagerImpl");
  35
  36   private Collection<EditorColorsListener> myListeners = new ArrayList<EditorColorsListener>();
  37
  38
  39   @NonNls private static final String NODE_NAME = "global_color_scheme";
  40   @NonNls private static final String SCHEME_NODE_NAME = "scheme";
  41
  42   private String myGlobalSchemeName;
  43   public boolean USE_ONLY_MONOSPACED_FONTS = true;
  44   private DefaultColorSchemesManager myDefaultColorSchemesManager;
  45   private final SchemesManager<EditorColorsScheme, EditorColorsSchemeImpl> mySchemesManager;
  46   @NonNls private static final String NAME_ATTR = "name";
  47   private static final String FILE_SPEC = "$ROOT_CONFIG$/colors";
  48
  49   public EditorColorsManagerImpl(DefaultColorSchemesManager defaultColorSchemesManager, SchemesManagerFactory schemesManagerFactory) {
  50     myDefaultColorSchemesManager = defaultColorSchemesManager;
  51
  52         mySchemesManager = schemesManagerFactory.createSchemesManager(
  53         FILE_SPEC,
  54         new SchemeProcessor<EditorColorsSchemeImpl>() {
  55           public EditorColorsSchemeImpl readScheme(final Document document)
  56               throws InvalidDataException, IOException, JDOMException {
  57             Element root = document.getRootElement();
  58
  59             if (root == null || !SCHEME_NODE_NAME.equals(root.getName())) {
  60               throw new InvalidDataException();
  61             }
  62
  63             EditorColorsSchemeImpl scheme = new EditorColorsSchemeImpl(null, DefaultColorSchemesManager.getInstance());
  64             scheme.readExternal(root);
  65             return scheme;
  66           }
  67
  68           public Document writeScheme(final EditorColorsSchemeImpl scheme) throws WriteExternalException {
  69             Element root = new Element(SCHEME_NODE_NAME);
  70             try {
  71               scheme.writeExternal(root);
  72             }
  73             catch (WriteExternalException e) {
  74               LOG.error(e);
  75               return null;
  76             }
  77
  78             return new Document(root);
  79           }
  80
  81           public void renameScheme(final String name, final EditorColorsScheme scheme) {
  82             scheme.setName(name);
  83           }
  84
  85           public boolean shouldBeSaved(final EditorColorsSchemeImpl scheme) {
  86             return true;
  87           }
  88
  89           public void initScheme(final EditorColorsSchemeImpl scheme) {
  90
  91           }
  92
  93           public void onSchemeAdded(final EditorColorsSchemeImpl scheme) {
  94
  95           }
  96
  97           public void onSchemeDeleted(final EditorColorsSchemeImpl scheme) {
  98           }
  99
 100           public void onCurrentSchemeChanged(final Scheme newCurrentScheme) {
 101             fireChanges(mySchemesManager.getCurrentScheme());
 102           }
 103         }, RoamingType.PER_USER);
 104
 105
 106     addDefaultSchemes();
 107     loadAllSchemes();
 108     setGlobalScheme(myDefaultColorSchemesManager.getAllSchemes()[0]);
 109   }
 110
 111   // -------------------------------------------------------------------------
 112   // ApplicationComponent interface implementation
 113   // -------------------------------------------------------------------------
 114
 115   public void disposeComponent() {
 116   }
 117
 118   public void initComponent() {
 119   }
 120
 121   // -------------------------------------------------------------------------
 122   // Schemes manipulation routines
 123   // -------------------------------------------------------------------------
 124
 125   public void addColorsScheme(EditorColorsScheme scheme) {
 126     if (!isDefaultScheme(scheme) && scheme.getName().trim().length() > 0) {
 127       mySchemesManager.addNewScheme(scheme, true);
 128     }
 129   }
 130
 131   public void removeAllSchemes() {
 132     mySchemesManager.clearAllSchemes();
 133     addDefaultSchemes();
 134   }
 135
 136   private void addDefaultSchemes() {
 137     DefaultColorsScheme[] allDefaultSchemes = myDefaultColorSchemesManager.getAllSchemes();
 138     for (DefaultColorsScheme defaultScheme : allDefaultSchemes) {
 139       mySchemesManager.addNewScheme(defaultScheme, true);
 140     }
 141   }
 142
 143   // -------------------------------------------------------------------------
 144   // Getters & Setters
 145   // -------------------------------------------------------------------------
 146
 147   public EditorColorsScheme[] getAllSchemes() {
 148     ArrayList<EditorColorsScheme> schemes = new ArrayList<EditorColorsScheme>(mySchemesManager.getAllSchemes());
 149     Collections.sort(schemes, new Comparator<EditorColorsScheme>() {
 150       public int compare(EditorColorsScheme s1, EditorColorsScheme s2) {
 151         if (isDefaultScheme(s1) && !isDefaultScheme(s2)) return -1;
 152         if (!isDefaultScheme(s1) && isDefaultScheme(s2)) return 1;
 153
 154         return s1.getName().compareToIgnoreCase(s2.getName());
 155       }
 156     });
 157
 158     return schemes.toArray(new EditorColorsScheme[schemes.size()]);
 159   }
 160
 161   public void setGlobalScheme(EditorColorsScheme scheme) {
 162     mySchemesManager.setCurrentSchemeName(scheme == null ? DefaultColorSchemesManager.getInstance().getAllSchemes()[0].getName() : scheme.getName());
 163     fireChanges(scheme);
 164   }
 165
 166   public EditorColorsScheme getGlobalScheme() {
 167     return mySchemesManager.getCurrentScheme();
 168   }
 169
 170   public EditorColorsScheme getScheme(String schemeName) {
 171     return mySchemesManager.findSchemeByName(schemeName);
 172   }
 173
 174   private void fireChanges(EditorColorsScheme scheme) {
 175     EditorColorsListener[] colorsListeners = myListeners.toArray(new EditorColorsListener[myListeners.size()]);
 176     for (EditorColorsListener colorsListener : colorsListeners) {
 177       colorsListener.globalSchemeChange(scheme);
 178     }
 179   }
 180
 181   // -------------------------------------------------------------------------
 182   // Routines responsible for loading & saving colors schemes.
 183   // -------------------------------------------------------------------------
 184
 185   private void loadAllSchemes() {
 186     mySchemesManager.loadSchemes();
 187   }
 188
 189   private static File getColorsDir(boolean create) {
 190     @NonNls String directoryPath = PathManager.getConfigPath() + File.separator + "colors";
 191     File directory = new File(directoryPath);
 192     if (!directory.exists()) {
 193       if (!create) return null;
 194       if (!directory.mkdir()) {
 195         LOG.error("Cannot create directory: " + directory.getAbsolutePath());
 196         return null;
 197       }
 198     }
 199     return directory;
 200   }
 201
 202
 203   public void addEditorColorsListener(EditorColorsListener listener) {
 204     myListeners.add(listener);
 205   }
 206
 207   public void removeEditorColorsListener(EditorColorsListener listener) {
 208     myListeners.remove(listener);
 209   }
 210
 211   public void setUseOnlyMonospacedFonts(boolean b) {
 212     USE_ONLY_MONOSPACED_FONTS = b;
 213   }
 214
 215   public boolean isUseOnlyMonospacedFonts() {
 216     return USE_ONLY_MONOSPACED_FONTS;
 217   }
 218
 219   public String getExternalFileName() {
 220     return "colors.scheme";
 221   }
 222
 223   @NotNull
 224   public File[] getExportFiles() {
 225     return new File[]{getColorsDir(true), PathManager.getOptionsFile(this)};
 226   }
 227
 228   @NotNull
 229   public String getPresentableName() {
 230     return OptionsBundle.message("options.color.schemes.presentable.name");
 231   }
 232
 233   public void readExternal(Element parentNode) throws InvalidDataException {
 234     DefaultJDOMExternalizer.readExternal(this, parentNode);
 235     Element element = parentNode.getChild(NODE_NAME);
 236     if (element != null) {
 237       String name = element.getAttributeValue(NAME_ATTR);
 238       if (name != null && !"".equals(name.trim())) {
 239         myGlobalSchemeName = name;
 240       }
 241     }
 242
 243     initGlobalScheme();
 244   }
 245
 246   private void initGlobalScheme() {
 247     if (myGlobalSchemeName != null) {
 248       setGlobalSchemeByName(myGlobalSchemeName);
 249     }
 250     else {
 251       setGlobalScheme(myDefaultColorSchemesManager.getAllSchemes()[0]);
 252     }
 253   }
 254
 255   private void setGlobalSchemeByName(String schemeName) {
 256     setGlobalScheme(mySchemesManager.findSchemeByName(schemeName));
 257   }
 258
 259   public void writeExternal(Element parentNode) throws WriteExternalException {
 260     DefaultJDOMExternalizer.writeExternal(this, parentNode);
 261     if (mySchemesManager.getCurrentScheme() != null) {
 262       Element element = new Element(NODE_NAME);
 263       element.setAttribute(NAME_ATTR, mySchemesManager.getCurrentScheme().getName());
 264       parentNode.addContent(element);
 265     }
 266   }
 267
 268   public boolean isDefaultScheme(EditorColorsScheme scheme) {
 269     return scheme instanceof DefaultColorsScheme;
 270   }
 271
 272   public String getComponentName() {
 273     return "EditorColorsManagerImpl";
 274   }
 275
 276   public SchemesManager<EditorColorsScheme, EditorColorsSchemeImpl> getSchemesManager() {
 277     return mySchemesManager;
 278   }
 279 }