FileColorManagerImpl.java

/*
 * Copyright 2000-2012 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.ui.tabs;

import com.intellij.ide.util.PropertiesComponent;
import com.intellij.openapi.components.*;
import com.intellij.openapi.components.StoragePathMacros;
import com.intellij.openapi.fileEditor.FileEditorManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiManager;
import com.intellij.ui.ColorUtil;
import com.intellij.ui.FileColorManager;
import com.intellij.ui.LightColors;
import com.intellij.util.containers.hash.LinkedHashMap;
import com.intellij.util.ui.UIUtil;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.awt.*;
import java.util.*;
import java.util.List;

/**
 * @author spleaner
 * @author Konstantin Bulenkov
 */
@State(
  name = "FileColors",
  storages = {@Storage( file = StoragePathMacros.WORKSPACE_FILE)})
public class FileColorManagerImpl extends FileColorManager implements PersistentStateComponent<Element> {
  public static final String FC_ENABLED = "FileColorsEnabled";
  public static final String FC_TABS_ENABLED = "FileColorsForTabsEnabled";
  public static final String FC_PROJECT_VIEW_ENABLED = "FileColorsForProjectViewEnabled";
  private final Project myProject;
  private final FileColorsModel myModel;
  private FileColorSharedConfigurationManager mySharedConfigurationManager;

  private static final Map<String, Color> ourDefaultColors;
  private static final Map<String, Color> ourDefaultDarkColors;

  static {
    ourDefaultColors = new LinkedHashMap<String, Color>();
    ourDefaultColors.put("Blue", new Color(0xdcf0ff));
    ourDefaultColors.put("Green", new Color(231, 250, 219));
    ourDefaultColors.put("Orange", new Color(246, 224, 202));
    ourDefaultColors.put("Rose", new Color(242, 206, 202));
    ourDefaultColors.put("Violet", new Color(222, 213, 241));
    ourDefaultColors.put("Yellow", new Color(255, 255, 228));
    ourDefaultDarkColors = new LinkedHashMap<String, Color>();
    ourDefaultDarkColors.put("Blue", new Color(0x2B3557));
    ourDefaultDarkColors.put("Green", new Color(0x2A3B2C));
    ourDefaultDarkColors.put("Orange", new Color(0x823B1C));
    ourDefaultDarkColors.put("Rose", new Color(0x542F3A));
    ourDefaultDarkColors.put("Violet", new Color(0x4f4056));
    ourDefaultDarkColors.put("Yellow", new Color(0x494539));
  }

  public FileColorManagerImpl(@NotNull final Project project) {
    myProject = project;
    myModel = new FileColorsModel(project);
  }

  private void initProjectLevelConfigurations() {
    if (mySharedConfigurationManager == null) {
      mySharedConfigurationManager = ServiceManager.getService(myProject, FileColorSharedConfigurationManager.class);
    }
  }

  @Override
  public boolean isEnabled() {
    return _isEnabled();
  }

  public static boolean _isEnabled() {
    return PropertiesComponent.getInstance().getBoolean(FC_ENABLED, true);
  }

  @Override
  public void setEnabled(boolean enabled) {
    PropertiesComponent.getInstance().setValue(FC_ENABLED, Boolean.toString(enabled));
  }

  public void setEnabledForTabs(boolean enabled) {
    PropertiesComponent.getInstance().setValue(FC_TABS_ENABLED, Boolean.toString(enabled));
  }

  @Override
  public boolean isEnabledForTabs() {
    return _isEnabledForTabs();
  }

  public static boolean _isEnabledForTabs() {
    return PropertiesComponent.getInstance().getBoolean(FC_TABS_ENABLED, true);
  }

  @Override
  public boolean isEnabledForProjectView() {
    return _isEnabledForProjectView();
  }

  public static boolean _isEnabledForProjectView() {
    return PropertiesComponent.getInstance().getBoolean(FC_PROJECT_VIEW_ENABLED, true);
  }

  public static void setEnabledForProjectView(boolean enabled) {
    PropertiesComponent.getInstance().setValue(FC_PROJECT_VIEW_ENABLED, Boolean.toString(enabled));
  }

  public Element getState(final boolean shared) {
    Element element = new Element("state");
    //if (!shared) {
    //  element.setAttribute("enabled", Boolean.toString(myEnabled));
    //  element.setAttribute("enabledForTabs", Boolean.toString(myEnabledForTabs));
    //}

    myModel.save(element, shared);
    //if (!shared) {
    //  final boolean exists = findConfigurationByName(NonProjectFilesScope.NAME, myModel.getLocalConfigurations()) != null;
    //  if (myEnabledForNonProject && !exists) {
    //    myEnabledForNonProject = false;
    //  } else if (!myEnabledForNonProject && exists) {
    //    myEnabledForNonProject = true;
    //  }
    //
    //  element.setAttribute("showNonProject", Boolean.toString(myEnabledForNonProject));
    //}

    return element;
  }

  @Override
  @SuppressWarnings({"MethodMayBeStatic"})
  @Nullable
  public Color getColor(@NotNull final String name) {
    final Color color = UIUtil.isUnderDarcula() ? ourDefaultDarkColors.get(name) : ourDefaultColors.get(name);
    return color == null ? ColorUtil.fromHex(name, null) : color;
  }

  @Override
  public Element getState() {
    initProjectLevelConfigurations();
    return getState(false);
  }

  @SuppressWarnings({"AutoUnboxing"})
  void loadState(Element state, final boolean shared) {
    if (!shared) {
      //final String enabled = state.getAttributeValue("enabled");
      //myEnabled = enabled == null ? true : Boolean.valueOf(enabled);
      //
      //final String enabledForTabs = state.getAttributeValue("enabledForTabs");
      //myEnabledForTabs = enabledForTabs == null ? true : Boolean.valueOf(enabledForTabs);

      //final String showNonProject = state.getAttributeValue("showNonProject");
      //myEnabledForNonProject = showNonProject == null ? true : Boolean.valueOf(showNonProject);
    }

    myModel.load(state, shared);
    //final List<FileColorConfiguration> local = myModel.getLocalConfigurations();
    //if (!shared && myEnabledForNonProject && findConfigurationByName(NonProjectFilesScope.NAME, local) == null) {
    //  local.add(new FileColorConfiguration(NonProjectFilesScope.NAME, NonProjectFilesScope.DEFAULT_COLOR));
    //}
  }

  @Override
  @SuppressWarnings({"MethodMayBeStatic"})
  public Collection<String> getColorNames() {
    final Set<String> names = ourDefaultColors.keySet();
    final List<String> sorted = new ArrayList<String>(names);
    Collections.sort(sorted);
    return sorted;
  }

  @Override
  @SuppressWarnings({"AutoUnboxing"})
  public void loadState(Element state) {
    initProjectLevelConfigurations();
    loadState(state, false);
  }

  @Override
  public boolean isColored(@NotNull final String scopeName, final boolean shared) {
    return myModel.isColored(scopeName, shared);
  }

  @Nullable
  @Override
  public Color getRendererBackground(VirtualFile file) {
    return getRendererBackground(PsiManager.getInstance(myProject).findFile(file));
  }

  @Nullable
  @Override
  public Color getRendererBackground(PsiFile file) {
    if (file == null) return null;

    if (isEnabled()) {
      final Color fileColor = getFileColor(file);
      if (fileColor != null) return fileColor;
    }

    final VirtualFile vFile = file.getVirtualFile();
    if (vFile == null) return null;

    //todo[kb] slightly_green for darcula
    return FileEditorManager.getInstance(myProject).isFileOpen(vFile) && !UIUtil.isUnderDarcula() ? LightColors.SLIGHTLY_GREEN : null;
  }

  @Override
  @Nullable
  public Color getFileColor(@NotNull final PsiFile file) {
    initProjectLevelConfigurations();

    final String colorName = myModel.getColor(file);
    return colorName == null ? null : getColor(colorName);
  }

  @Override
  @Nullable
  public Color getFileColor(@NotNull final VirtualFile file) {
    initProjectLevelConfigurations();
    final PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(file);
    if (psiFile != null) {
      return getFileColor(psiFile);
    } else {
      final String colorName = myModel.getColor(file, getProject());
      return colorName == null ? null : getColor(colorName);
    }
  }

  @Nullable
  public Color getScopeColor(@NotNull String scopeName) {
    initProjectLevelConfigurations();

    final String colorName = myModel.getScopeColor(scopeName, getProject());
    return colorName == null ? null : getColor(colorName);
  }

  @Override
  public boolean isShared(@NotNull final String scopeName) {
    return myModel.isShared(scopeName);
  }

  FileColorsModel getModel() {
    return myModel;
  }

  boolean isShared(FileColorConfiguration configuration) {
    return myModel.isShared(configuration);
  }

  @Override
  public Project getProject() {
    return myProject;
  }

  public List<FileColorConfiguration> getLocalConfigurations() {
    return myModel.getProjectLevelConfigurations();
  }

  public List<FileColorConfiguration> getSharedConfigurations() {
    return myModel.getLocalConfigurations();
  }

  @Nullable
  public static String getColorName(Color color) {
    for (String name : ourDefaultColors.keySet()) {
      if (color.equals(ourDefaultColors.get(name))) {
        return name;
      }
    }
    return null;
  }

  @Nullable
  private static FileColorConfiguration findConfigurationByName(String name, List<FileColorConfiguration> configurations) {
    for (FileColorConfiguration configuration : configurations) {
      if (name.equals(configuration.getScopeName())) {
        return configuration;
      }
    }
    return null;
  }

  static String getAlias(String text) {
    if (UIUtil.isUnderDarcula()) {
      if (text.equals("Yellow")) return "Brown";
    }
    return text;
  }

}