platform/lang-impl/src/com/intellij/application/options/colors/ColorAndFontOptions.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.intellij.application.options.colors;
  18
  19 import com.intellij.application.options.OptionsContainingConfigurable;
  20 import com.intellij.application.options.editor.EditorOptionsProvider;
  21 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
  22 import com.intellij.codeInsight.daemon.impl.DaemonCodeAnalyzerImpl;
  23 import com.intellij.openapi.Disposable;
  24 import com.intellij.openapi.application.ApplicationBundle;
  25 import com.intellij.openapi.diff.impl.settings.DiffOptionsPanel;
  26 import com.intellij.openapi.diff.impl.settings.DiffPreviewPanel;
  27 import com.intellij.openapi.editor.EditorFactory;
  28 import com.intellij.openapi.editor.colors.ColorKey;
  29 import com.intellij.openapi.editor.colors.EditorColorsManager;
  30 import com.intellij.openapi.editor.colors.EditorColorsScheme;
  31 import com.intellij.openapi.editor.colors.TextAttributesKey;
  32 import com.intellij.openapi.editor.colors.ex.DefaultColorSchemesManager;
  33 import com.intellij.openapi.editor.colors.impl.DefaultColorsScheme;
  34 import com.intellij.openapi.editor.colors.impl.EditorColorsSchemeImpl;
  35 import com.intellij.openapi.editor.colors.impl.ReadOnlyColorsScheme;
  36 import com.intellij.openapi.editor.markup.EffectType;
  37 import com.intellij.openapi.editor.markup.TextAttributes;
  38 import com.intellij.openapi.options.Configurable;
  39 import com.intellij.openapi.options.ConfigurationException;
  40 import com.intellij.openapi.options.ExternalizableScheme;
  41 import com.intellij.openapi.options.SearchableConfigurable;
  42 import com.intellij.openapi.options.colors.AttributesDescriptor;
  43 import com.intellij.openapi.options.colors.ColorDescriptor;
  44 import com.intellij.openapi.options.colors.ColorSettingsPage;
  45 import com.intellij.openapi.options.colors.ColorSettingsPages;
  46 import com.intellij.openapi.project.Project;
  47 import com.intellij.openapi.project.ProjectManager;
  48 import com.intellij.openapi.util.Comparing;
  49 import com.intellij.openapi.util.Disposer;
  50 import com.intellij.openapi.util.IconLoader;
  51 import com.intellij.openapi.util.Pair;
  52 import com.intellij.openapi.vcs.FileStatus;
  53 import com.intellij.openapi.vcs.FileStatusFactory;
  54 import com.intellij.openapi.vcs.FileStatusManager;
  55 import com.intellij.psi.search.scope.packageSet.NamedScope;
  56 import com.intellij.psi.search.scope.packageSet.NamedScopesHolder;
  57 import com.intellij.psi.search.scope.packageSet.PackageSet;
  58 import com.intellij.util.ArrayUtil;
  59 import com.intellij.util.containers.HashMap;
  60 import gnu.trove.THashSet;
  61 import gnu.trove.TObjectHashingStrategy;
  62 import org.jetbrains.annotations.Nls;
  63 import org.jetbrains.annotations.NotNull;
  64 import org.jetbrains.annotations.Nullable;
  65
  66 import javax.swing.*;
  67 import java.awt.*;
  68 import java.util.*;
  69 import java.util.List;
  70
  71 public class ColorAndFontOptions extends SearchableConfigurable.Parent.Abstract implements EditorOptionsProvider {
  72   private HashMap<String,MyColorScheme> mySchemes;
  73   private MyColorScheme mySelectedScheme;
  74   public static final String DIFF_GROUP = ApplicationBundle.message("title.diff");
  75   public static final String FILE_STATUS_GROUP = ApplicationBundle.message("title.file.status");
  76   public static final String SCOPES_GROUP = ApplicationBundle.message("title.scope.based");
  77
  78   private boolean mySomeSchemesDeleted = false;
  79   private Map<ColorAndFontPanelFactory, InnerSearchableConfigurable> mySubPanelFactories;
  80
  81   private SchemesPanel myRootSchemesPanel;
  82
  83   private boolean myInitResetCompleted = false;
  84   private boolean myInitResetInvoked = false;
  85
  86   private boolean myRevertChangesCompleted = false;
  87
  88   private boolean myApplyCompleted = false;
  89   private boolean myDisposeCompleted = false;
  90   private final Disposable myDisposable = Disposer.newDisposable();
  91
  92   public boolean isModified() {
  93     boolean listModified = isSchemeListModified();
  94     boolean schemeModified = isSomeSchemeModified();
  95
  96     if (listModified || schemeModified) {
  97       myApplyCompleted = false;
  98     }
  99
 100     return listModified;
 101   }
 102
 103   private boolean isSchemeListModified(){
 104     if (mySomeSchemesDeleted) return true;
 105
 106     if (!mySelectedScheme.getName().equals(EditorColorsManager.getInstance().getGlobalScheme().getName())) return true;
 107
 108     for (MyColorScheme scheme : mySchemes.values()) {
 109       if (scheme.isNew()) return true;
 110     }
 111
 112     return false;
 113   }
 114
 115   private boolean isSomeSchemeModified() {
 116     for (MyColorScheme scheme : mySchemes.values()) {
 117       if (scheme.isModified()) return true;
 118     }
 119     return false;
 120   }
 121
 122   public EditorColorsScheme selectScheme(@NotNull String name) {
 123     mySelectedScheme = getScheme(name);
 124     return mySelectedScheme;
 125   }
 126
 127   private MyColorScheme getScheme(String name) {
 128     return mySchemes.get(name);
 129   }
 130
 131   public EditorColorsScheme getSelectedScheme() {
 132     return mySelectedScheme;
 133   }
 134
 135   public EditorColorsScheme getOriginalSelectedScheme() {
 136     return mySelectedScheme == null ? null : mySelectedScheme.getOriginalScheme();
 137   }
 138
 139   public EditorSchemeAttributeDescriptor[] getCurrentDescriptions() {
 140     return mySelectedScheme.getDescriptors();
 141   }
 142
 143   public static boolean isReadOnly(final EditorColorsScheme scheme) {
 144     return ((MyColorScheme)scheme).isReadOnly();
 145   }
 146
 147   public String[] getSchemeNames() {
 148     ArrayList<MyColorScheme> schemes = new ArrayList<MyColorScheme>(mySchemes.values());
 149     Collections.sort(schemes, new Comparator<MyColorScheme>() {
 150       public int compare(MyColorScheme o1, MyColorScheme o2) {
 151         if (isReadOnly(o1) && !isReadOnly(o2)) return -1;
 152         if (!isReadOnly(o1) && isReadOnly(o2)) return 1;
 153
 154         return o1.getName().compareToIgnoreCase(o2.getName());
 155       }
 156     });
 157
 158     ArrayList<String> names = new ArrayList<String>(schemes.size());
 159     for (MyColorScheme scheme : schemes) {
 160       names.add(scheme.getName());
 161     }
 162
 163     return ArrayUtil.toStringArray(names);
 164   }
 165
 166   public Collection<EditorColorsScheme> getSchemes() {
 167     return new ArrayList<EditorColorsScheme>(mySchemes.values());
 168   }
 169
 170   public void saveSchemeAs(String name) {
 171     MyColorScheme scheme = mySelectedScheme;
 172     if (scheme == null) return;
 173
 174     EditorColorsScheme clone = (EditorColorsScheme)scheme.getOriginalScheme().clone();
 175
 176     scheme.apply(clone);
 177
 178     clone.setName(name);
 179     MyColorScheme newScheme = new MyColorScheme(clone);
 180     initScheme(newScheme);
 181
 182     newScheme.setIsNew();
 183
 184     mySchemes.put(name, newScheme);
 185     selectScheme(newScheme.getName());
 186     resetSchemesCombo(null);
 187   }
 188
 189   public void addImportedScheme(final EditorColorsScheme imported) {
 190     MyColorScheme newScheme = new MyColorScheme(imported);
 191     initScheme(newScheme);
 192
 193     mySchemes.put(imported.getName(), newScheme);
 194     selectScheme(newScheme.getName());
 195     resetSchemesCombo(null);
 196   }
 197
 198   public void removeScheme(String name) {
 199     if (mySelectedScheme.getName().equals(name)) {
 200       //noinspection HardCodedStringLiteral
 201       selectScheme("Default");
 202     }
 203
 204     boolean deletedNewlyCreated = false;
 205
 206     MyColorScheme toDelete = mySchemes.get(name);
 207
 208     if (toDelete != null) {
 209       deletedNewlyCreated = toDelete.isNew();
 210     }
 211
 212     mySchemes.remove(name);
 213     resetSchemesCombo(null);
 214     mySomeSchemesDeleted = mySomeSchemesDeleted || !deletedNewlyCreated;
 215   }
 216
 217   public void apply() throws ConfigurationException {
 218     if (!myApplyCompleted) {
 219       try {
 220         EditorColorsManager myColorsManager = EditorColorsManager.getInstance();
 221
 222         myColorsManager.removeAllSchemes();
 223         for (MyColorScheme scheme : mySchemes.values()) {
 224             if (!scheme.isDefault()) {
 225               scheme.apply();
 226               myColorsManager.addColorsScheme(scheme.getOriginalScheme());
 227             }
 228           }
 229
 230         EditorColorsScheme originalScheme = mySelectedScheme.getOriginalScheme();
 231         myColorsManager.setGlobalScheme(originalScheme);
 232
 233         applyChangesToEditors();
 234
 235         reset();
 236       }
 237       finally {
 238         myApplyCompleted = true;
 239
 240
 241       }
 242
 243
 244     }
 245
 246
 247 //    initAll();
 248 //    resetSchemesCombo();
 249
 250
 251   }
 252
 253   private static void applyChangesToEditors() {
 254     EditorFactory.getInstance().refreshAllEditors();
 255
 256     Project[] openProjects = ProjectManager.getInstance().getOpenProjects();
 257     for (Project openProject : openProjects) {
 258       FileStatusManager.getInstance(openProject).fileStatusesChanged();
 259       DaemonCodeAnalyzer.getInstance(openProject).restart();
 260     }
 261   }
 262
 263   private boolean myIsReset = false;
 264
 265   private void resetSchemesCombo(Object source) {
 266     myIsReset = true;
 267     try {
 268       myRootSchemesPanel.resetSchemesCombo(source);
 269       if (mySubPanelFactories != null) {
 270         for (NewColorAndFontPanel subPartialConfigurable : getPanels()) {
 271           subPartialConfigurable.reset(source);
 272         }
 273       }
 274     }
 275     finally {
 276       myIsReset = false;
 277     }
 278   }
 279
 280   @Override
 281   public JComponent createComponent() {
 282     if (myRootSchemesPanel == null) {
 283       ensureSchemesPanel();
 284     }
 285     return myRootSchemesPanel;
 286   }
 287
 288   @Override
 289   public boolean hasOwnContent() {
 290     return true;
 291   }
 292
 293   protected Configurable[] buildConfigurables() {
 294     myDisposeCompleted = false;
 295     initAll();
 296
 297     List<ColorAndFontPanelFactory> panelFactories = createPanelFactories();
 298
 299     List<Configurable> result = new ArrayList<Configurable>();
 300     mySubPanelFactories = new LinkedHashMap<ColorAndFontPanelFactory, InnerSearchableConfigurable>(panelFactories.size());
 301     for (ColorAndFontPanelFactory panelFactory : panelFactories) {
 302       mySubPanelFactories.put(panelFactory, new InnerSearchableConfigurable(panelFactory));
 303     }
 304
 305     result.addAll(new ArrayList<SearchableConfigurable>(mySubPanelFactories.values()));
 306
 307     return result.toArray(new Configurable[result.size()]);
 308   }
 309
 310   private Set<NewColorAndFontPanel> getPanels() {
 311     Set<NewColorAndFontPanel> result = new HashSet<NewColorAndFontPanel>();
 312     for (InnerSearchableConfigurable configurable : mySubPanelFactories.values()) {
 313       NewColorAndFontPanel panel = configurable.getSubPanelIfInitialized();
 314       if (panel != null) {
 315         result.add(panel);
 316       }
 317     }
 318     return result;
 319   }
 320
 321   private List<ColorAndFontPanelFactory> createPanelFactories() {
 322     ArrayList<ColorAndFontPanelFactory> result = new ArrayList<ColorAndFontPanelFactory>();
 323     result.add(new FontConfigurableFactory());
 324
 325     ColorSettingsPage[] pages = ColorSettingsPages.getInstance().getRegisteredPages();
 326     for (final ColorSettingsPage page : pages) {
 327       result.add(new ColorAndFontPanelFactory() {
 328         public NewColorAndFontPanel createPanel(ColorAndFontOptions options) {
 329           final SimpleEditorPreview preview = new SimpleEditorPreview(options, page);
 330           return NewColorAndFontPanel.create(preview, page.getDisplayName(), options, null, page);
 331         }
 332
 333         public String getPanelDisplayName() {
 334           return page.getDisplayName();
 335         }
 336       });
 337     }
 338     result.add(new DiffColorsPageFactory());
 339     result.add(new FileStatusColorsPageFactory());
 340     result.add(new ScopeColorsPageFactory());
 341
 342     return result;
 343   }
 344
 345   private static class FontConfigurableFactory implements ColorAndFontPanelFactory {
 346     public NewColorAndFontPanel createPanel(ColorAndFontOptions options) {
 347       return new NewColorAndFontPanel(new SchemesPanel(options), new FontOptions(options), new FontEditorPreview(options), "Font", null, null){
 348         @Override
 349         public boolean containsFontOptions() {
 350           return true;
 351         }
 352       };
 353     }
 354
 355     public String getPanelDisplayName() {
 356       return "Font";
 357     }
 358   }
 359
 360   private class DiffColorsPageFactory implements ColorAndFontPanelFactory {
 361     public NewColorAndFontPanel createPanel(ColorAndFontOptions options) {
 362       final DiffPreviewPanel diffPreviewPanel = new DiffPreviewPanel(myDisposable);
 363       diffPreviewPanel.setMergeRequest(null);
 364       final DiffOptionsPanel optionsPanel = new DiffOptionsPanel(options);
 365
 366       SchemesPanel schemesPanel = new SchemesPanel(options);
 367
 368       schemesPanel.addListener(new ColorAndFontSettingsListener.Abstract(){
 369         @Override
 370         public void schemeChanged(final Object source) {
 371           diffPreviewPanel.setColorScheme(getSelectedScheme());
 372           optionsPanel.updateOptionsList();
 373           diffPreviewPanel.updateView();
 374         }
 375       } );
 376
 377       return new NewColorAndFontPanel(schemesPanel, optionsPanel, diffPreviewPanel, DIFF_GROUP, null, null);
 378     }
 379
 380     public String getPanelDisplayName() {
 381       return DIFF_GROUP;
 382     }
 383   }
 384
 385   private void initAll() {
 386     EditorColorsManager colorsManager = EditorColorsManager.getInstance();
 387     EditorColorsScheme[] allSchemes = colorsManager.getAllSchemes();
 388
 389     mySchemes = new HashMap<String, MyColorScheme>();
 390     for (EditorColorsScheme allScheme : allSchemes) {
 391       MyColorScheme schemeDelegate = new MyColorScheme(allScheme);
 392       initScheme(schemeDelegate);
 393       mySchemes.put(schemeDelegate.getName(), schemeDelegate);
 394     }
 395
 396     mySelectedScheme = mySchemes.get(EditorColorsManager.getInstance().getGlobalScheme().getName());
 397     assert mySelectedScheme != null : EditorColorsManager.getInstance().getGlobalScheme().getName() + "; myschemes=" + mySchemes;
 398   }
 399
 400   private static void initScheme(MyColorScheme scheme) {
 401     ArrayList<EditorSchemeAttributeDescriptor> descriptions = new ArrayList<EditorSchemeAttributeDescriptor>();
 402     initPluggedDescriptions(descriptions, scheme);
 403     initDiffDescriptors(descriptions, scheme);
 404     initFileStatusDescriptors(descriptions, scheme);
 405     initScopesDescriptors(descriptions, scheme);
 406
 407     scheme.setDescriptors(descriptions.toArray(new EditorSchemeAttributeDescriptor[descriptions.size()]));
 408   }
 409
 410   private static void initPluggedDescriptions(ArrayList<EditorSchemeAttributeDescriptor> descriptions, MyColorScheme scheme) {
 411     ColorSettingsPage[] pages = ColorSettingsPages.getInstance().getRegisteredPages();
 412     for (ColorSettingsPage page : pages) {
 413       initDescriptions(page, descriptions, scheme);
 414     }
 415   }
 416
 417   private static void initDescriptions(ColorSettingsPage page,
 418                                        ArrayList<EditorSchemeAttributeDescriptor> descriptions,
 419                                        MyColorScheme scheme) {
 420     String group = page.getDisplayName();
 421     AttributesDescriptor[] attributeDescriptors = page.getAttributeDescriptors();
 422     for (AttributesDescriptor descriptor : attributeDescriptors) {
 423       addSchemedDescription(descriptions, descriptor.getDisplayName(), group, descriptor.getKey(), scheme, null, null);
 424     }
 425
 426     ColorDescriptor[] colorDescriptors = page.getColorDescriptors();
 427     for (ColorDescriptor descriptor : colorDescriptors) {
 428       ColorKey back = descriptor.getKind() == ColorDescriptor.Kind.BACKGROUND ? descriptor.getKey() : null;
 429       ColorKey fore = descriptor.getKind() == ColorDescriptor.Kind.FOREGROUND ? descriptor.getKey() : null;
 430       addEditorSettingDescription(descriptions, descriptor.getDisplayName(), group, back, fore, scheme);
 431     }
 432   }
 433
 434   private static void initDiffDescriptors(ArrayList<EditorSchemeAttributeDescriptor> descriptions, MyColorScheme scheme) {
 435     DiffOptionsPanel.addSchemeDescriptions(descriptions, scheme);
 436   }
 437
 438   private static void initFileStatusDescriptors(ArrayList<EditorSchemeAttributeDescriptor> descriptions, MyColorScheme scheme) {
 439
 440     FileStatus[] statuses = FileStatusFactory.SERVICE.getInstance().getAllFileStatuses();
 441
 442     for (FileStatus fileStatus : statuses) {
 443       addEditorSettingDescription(descriptions,
 444                                   fileStatus.getText(),
 445                                   FILE_STATUS_GROUP,
 446                                   null,
 447                                   fileStatus.getColorKey(),
 448                                   scheme);
 449
 450     }
 451   }
 452   private static void initScopesDescriptors(ArrayList<EditorSchemeAttributeDescriptor> descriptions, MyColorScheme scheme) {
 453     Set<Pair<NamedScope,NamedScopesHolder>> namedScopes = new THashSet<Pair<NamedScope,NamedScopesHolder>>(new TObjectHashingStrategy<Pair<NamedScope,NamedScopesHolder>>() {
 454       public int computeHashCode(final Pair<NamedScope, NamedScopesHolder> object) {
 455         return object.getFirst().getName().hashCode();
 456       }
 457
 458       public boolean equals(final Pair<NamedScope, NamedScopesHolder> o1, final Pair<NamedScope, NamedScopesHolder> o2) {
 459         return o1.getFirst().getName().equals(o2.getFirst().getName());
 460       }
 461     });
 462     Project[] projects = ProjectManager.getInstance().getOpenProjects();
 463     for (Project project : projects) {
 464       DaemonCodeAnalyzerImpl codeAnalyzer = (DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(project);
 465       List<Pair<NamedScope,NamedScopesHolder>> cachedScopes = codeAnalyzer.getScopeBasedHighlightingCachedScopes();
 466       namedScopes.addAll(cachedScopes);
 467     }
 468
 469     List<Pair<NamedScope, NamedScopesHolder>> list = new ArrayList<Pair<NamedScope, NamedScopesHolder>>(namedScopes);
 470
 471     Collections.sort(list, new Comparator<Pair<NamedScope,NamedScopesHolder>>() {
 472       public int compare(final Pair<NamedScope,NamedScopesHolder> o1, final Pair<NamedScope,NamedScopesHolder> o2) {
 473         return o1.getFirst().getName().compareToIgnoreCase(o2.getFirst().getName());
 474       }
 475     });
 476     for (Pair<NamedScope,NamedScopesHolder> pair : list) {
 477       NamedScope namedScope = pair.getFirst();
 478       String name = namedScope.getName();
 479       TextAttributesKey textAttributesKey = getScopeTextAttributeKey(name);
 480       if (scheme.getAttributes(textAttributesKey) == null) {
 481         scheme.setAttributes(textAttributesKey, new TextAttributes());
 482       }
 483       NamedScopesHolder holder = pair.getSecond();
 484
 485       PackageSet value = namedScope.getValue();
 486       String toolTip = holder.getDisplayName() + (value==null ? "" : ": "+ value.getText());
 487       addSchemedDescription(descriptions,
 488                             name,
 489                             SCOPES_GROUP,
 490                             textAttributesKey,
 491                             scheme, holder.getIcon(), toolTip);
 492     }
 493   }
 494
 495   public static TextAttributesKey getScopeTextAttributeKey(final String scope) {
 496     return TextAttributesKey.find("SCOPE_KEY_" + scope);
 497   }
 498
 499   private static void addEditorSettingDescription(ArrayList<EditorSchemeAttributeDescriptor> array,
 500                                                                      String name,
 501                                                                      String group,
 502                                                                      ColorKey backgroundKey,
 503                                                                      ColorKey foregroundKey,
 504                                                                      EditorColorsScheme scheme) {
 505     String type = null;
 506     if (foregroundKey != null) {
 507       type = foregroundKey.getExternalName();
 508     }
 509     else {
 510       if (backgroundKey != null) {
 511         type = backgroundKey.getExternalName();
 512       }
 513     }
 514     ColorAndFontDescription descr = new EditorSettingColorDescription(name, group, backgroundKey, foregroundKey, type, scheme);
 515     array.add(descr);
 516   }
 517
 518   private static void addSchemedDescription(ArrayList<EditorSchemeAttributeDescriptor> array, String name, String group, TextAttributesKey key,
 519                                             EditorColorsScheme scheme,
 520                                             Icon icon,
 521                                             String toolTip) {
 522     ColorAndFontDescription descr = new SchemeTextAttributesDescription(name, group, key, scheme, icon, toolTip);
 523     array.add(descr);
 524   }
 525
 526   public String getDisplayName() {
 527     return ApplicationBundle.message("title.colors.and.fonts");
 528   }
 529
 530   public Icon getIcon() {
 531     return IconLoader.getIcon("/general/configurableColorsAndFonts.png");
 532   }
 533
 534   private void revertChanges(){
 535     if (isSchemeListModified() || isSomeSchemeModified()) {
 536       myRevertChangesCompleted = false;
 537     }
 538
 539     if (!myRevertChangesCompleted) {
 540       ensureSchemesPanel();
 541
 542
 543       try {
 544         resetImpl();
 545       }
 546       finally {
 547         myRevertChangesCompleted = true;
 548       }
 549     }
 550
 551   }
 552
 553   private void resetImpl() {
 554     mySomeSchemesDeleted = false;
 555     initAll();
 556     resetSchemesCombo(null);
 557   }
 558
 559   public synchronized void reset() {
 560     if (!myInitResetInvoked) {
 561       try {
 562         super.reset();
 563         if (!myInitResetCompleted) {
 564           ensureSchemesPanel();
 565
 566           try {
 567             resetImpl();
 568           }
 569           finally {
 570             myInitResetCompleted = true;
 571           }
 572         }
 573       }
 574       finally {
 575         myInitResetInvoked = true;
 576       }
 577
 578     }
 579     else {
 580       revertChanges();
 581     }
 582
 583   }
 584
 585   public synchronized void resetFromChild() {
 586     if (!myInitResetCompleted) {
 587       ensureSchemesPanel();
 588
 589
 590       try {
 591         resetImpl();
 592       }
 593       finally {
 594         myInitResetCompleted = true;
 595       }
 596     }
 597
 598   }
 599
 600   private void ensureSchemesPanel() {
 601     if (myRootSchemesPanel == null) {
 602       myRootSchemesPanel = new SchemesPanel(this);
 603
 604       myRootSchemesPanel.addListener(new ColorAndFontSettingsListener.Abstract(){
 605         @Override
 606         public void schemeChanged(final Object source) {
 607           if (!myIsReset) {
 608             resetSchemesCombo(source);
 609           }
 610         }
 611       });
 612
 613     }
 614   }
 615
 616   public void disposeUIResources() {
 617     try {
 618       if (!myDisposeCompleted) {
 619         try {
 620           super.disposeUIResources();
 621           Disposer.dispose(myDisposable);
 622           if (myRootSchemesPanel != null) {
 623               myRootSchemesPanel.disposeUIResources();
 624             }
 625         }
 626         finally {
 627           myDisposeCompleted = true;
 628         }
 629       }
 630     }
 631     finally {
 632       mySubPanelFactories = null;
 633
 634       myInitResetCompleted = false;
 635       myInitResetInvoked = false;
 636       myRevertChangesCompleted = false;
 637
 638       myApplyCompleted = false;
 639       myRootSchemesPanel = null;
 640     }
 641   }
 642
 643   public boolean currentSchemeIsReadOnly() {
 644     return isReadOnly(mySelectedScheme);
 645   }
 646
 647   public boolean currentSchemeIsShared() {
 648     return ColorSettingsUtil.isSharedScheme(mySelectedScheme);
 649   }
 650
 651
 652   private static class SchemeTextAttributesDescription extends TextAttributesDescription {
 653     private final TextAttributes myAttributesToApply;
 654     private final TextAttributesKey key;
 655
 656     private SchemeTextAttributesDescription(String name, String group, TextAttributesKey key, EditorColorsScheme scheme, Icon icon,
 657                                            String toolTip) {
 658       super(name, group,
 659             scheme.getAttributes(key) == null
 660             ? new TextAttributes()
 661             : scheme.getAttributes(key).clone(),
 662             key, scheme, icon, toolTip);
 663       this.key = key;
 664       myAttributesToApply = scheme.getAttributes(key);
 665       initCheckedStatus();
 666     }
 667
 668     public void apply(EditorColorsScheme scheme) {
 669       if (scheme == null) scheme = getScheme();
 670       if (myAttributesToApply != null) {
 671         scheme.setAttributes(key, getTextAttributes());
 672       }
 673     }
 674
 675     public boolean isModified() {
 676       return !Comparing.equal(myAttributesToApply, getTextAttributes());
 677     }
 678
 679     public boolean isErrorStripeEnabled() {
 680       return true;
 681     }
 682   }
 683
 684   private static class GetSetColor {
 685     private final ColorKey myKey;
 686     private final EditorColorsScheme myScheme;
 687     private boolean isModified = false;
 688     private Color myColor;
 689
 690     private GetSetColor(ColorKey key, EditorColorsScheme scheme) {
 691       myKey = key;
 692       myScheme = scheme;
 693       myColor = myScheme.getColor(myKey);
 694     }
 695
 696     public Color getColor() {
 697       return myColor;
 698     }
 699
 700     public void setColor(Color col) {
 701       if (getColor() == null || !getColor().equals(col)) {
 702         isModified = true;
 703         myColor = col;
 704       }
 705     }
 706
 707     public void apply(EditorColorsScheme scheme) {
 708       if (scheme == null) scheme = myScheme;
 709       scheme.setColor(myKey, myColor);
 710     }
 711
 712     public boolean isModified() {
 713       return isModified;
 714     }
 715   }
 716
 717   private static class EditorSettingColorDescription extends ColorAndFontDescription {
 718     private GetSetColor myGetSetForeground;
 719     private GetSetColor myGetSetBackground;
 720
 721     private EditorSettingColorDescription(String name,
 722                                          String group,
 723                                          ColorKey backgroundKey,
 724                                          ColorKey foregroundKey,
 725                                          String type,
 726                                          EditorColorsScheme scheme) {
 727       super(name, group, type, scheme, null, null);
 728       if (backgroundKey != null) {
 729         myGetSetBackground = new GetSetColor(backgroundKey, scheme);
 730       }
 731       if (foregroundKey != null) {
 732         myGetSetForeground = new GetSetColor(foregroundKey, scheme);
 733       }
 734       initCheckedStatus();
 735     }
 736
 737     public int getFontType() {
 738       return 0;
 739     }
 740
 741     public void setFontType(int type) {
 742     }
 743
 744     public Color getExternalEffectColor() {
 745       return null;
 746     }
 747
 748     public void setExternalEffectColor(Color color) {
 749     }
 750
 751     public void setExternalEffectType(EffectType type) {
 752     }
 753
 754     public EffectType getExternalEffectType() {
 755       return EffectType.LINE_UNDERSCORE;
 756     }
 757
 758     public Color getExternalForeground() {
 759       if (myGetSetForeground == null) {
 760         return null;
 761       }
 762       return myGetSetForeground.getColor();
 763     }
 764
 765     public void setExternalForeground(Color col) {
 766       if (myGetSetForeground == null) {
 767         return;
 768       }
 769       myGetSetForeground.setColor(col);
 770     }
 771
 772     public Color getExternalBackground() {
 773       if (myGetSetBackground == null) {
 774         return null;
 775       }
 776       return myGetSetBackground.getColor();
 777     }
 778
 779     public void setExternalBackground(Color col) {
 780       if (myGetSetBackground == null) {
 781         return;
 782       }
 783       myGetSetBackground.setColor(col);
 784     }
 785
 786     public Color getExternalErrorStripe() {
 787       return null;
 788     }
 789
 790     public void setExternalErrorStripe(Color col) {
 791     }
 792
 793     public boolean isFontEnabled() {
 794       return false;
 795     }
 796
 797     public boolean isForegroundEnabled() {
 798       return myGetSetForeground != null;
 799     }
 800
 801     public boolean isBackgroundEnabled() {
 802       return myGetSetBackground != null;
 803     }
 804
 805     public boolean isEffectsColorEnabled() {
 806       return false;
 807     }
 808
 809     public boolean isModified() {
 810       return myGetSetBackground != null && myGetSetBackground.isModified()
 811              || myGetSetForeground != null && myGetSetForeground.isModified();
 812     }
 813
 814     public void apply(EditorColorsScheme scheme) {
 815       if (myGetSetBackground != null) {
 816         myGetSetBackground.apply(scheme);
 817       }
 818       if (myGetSetForeground != null) {
 819         myGetSetForeground.apply(scheme);
 820       }
 821     }
 822   }
 823
 824   public String getHelpTopic() {
 825     return "reference.settingsdialog.IDE.editor.colors";
 826   }
 827
 828   private static class MyColorScheme extends EditorColorsSchemeImpl {
 829     private int myFontSize;
 830     private float myLineSpacing;
 831     private String myFontName;
 832     private EditorSchemeAttributeDescriptor[] myDescriptors;
 833     private String myName;
 834     private boolean myIsNew = false;
 835
 836     private MyColorScheme(EditorColorsScheme parenScheme) {
 837       super(parenScheme, DefaultColorSchemesManager.getInstance());
 838       myFontSize = parenScheme.getEditorFontSize();
 839       myLineSpacing = parenScheme.getLineSpacing();
 840       myFontName = parenScheme.getEditorFontName();
 841       myName = parenScheme.getName();
 842       if (parenScheme instanceof ExternalizableScheme) {
 843         getExternalInfo().copy(((ExternalizableScheme)parenScheme).getExternalInfo());
 844       }
 845       initFonts();
 846     }
 847
 848     public String getName() {
 849       return myName;
 850     }
 851
 852     public void setName(String name) {
 853       myName = name;
 854     }
 855
 856     public void setDescriptors(EditorSchemeAttributeDescriptor[] descriptors) {
 857       myDescriptors = descriptors;
 858     }
 859
 860     public EditorSchemeAttributeDescriptor[] getDescriptors() {
 861       return myDescriptors;
 862     }
 863
 864     public boolean isDefault() {
 865       return myParentScheme instanceof DefaultColorsScheme;
 866     }
 867
 868     public boolean isReadOnly() {
 869       return myParentScheme instanceof ReadOnlyColorsScheme;
 870     }
 871
 872     public boolean isModified() {
 873       if (isFontModified()) return true;
 874
 875       for (EditorSchemeAttributeDescriptor descriptor : myDescriptors) {
 876         if (descriptor.isModified()) {
 877           return true;
 878         }
 879       }
 880
 881       return false;
 882     }
 883
 884     private boolean isFontModified() {
 885       if (myFontSize != myParentScheme.getEditorFontSize()) return true;
 886       if (myLineSpacing != myParentScheme.getLineSpacing()) return true;
 887       if (!myFontName.equals(myParentScheme.getEditorFontName())) return true;
 888       return false;
 889     }
 890
 891     public void apply() {
 892       apply(myParentScheme);
 893     }
 894
 895     public void apply(EditorColorsScheme scheme) {
 896       scheme.setEditorFontSize(myFontSize);
 897       scheme.setEditorFontName(myFontName);
 898       scheme.setLineSpacing(myLineSpacing);
 899
 900       for (EditorSchemeAttributeDescriptor descriptor : myDescriptors) {
 901         descriptor.apply(scheme);
 902       }
 903     }
 904
 905     public String getEditorFontName() {
 906       return myFontName;
 907     }
 908
 909     public int getEditorFontSize() {
 910       return myFontSize;
 911     }
 912
 913     public float getLineSpacing() {
 914       return myLineSpacing;
 915     }
 916
 917     public void setEditorFontSize(int fontSize) {
 918       myFontSize = fontSize;
 919       initFonts();
 920     }
 921
 922     public void setLineSpacing(float lineSpacing) {
 923       myLineSpacing = lineSpacing;
 924     }
 925
 926     public void setEditorFontName(String fontName) {
 927       myFontName = fontName;
 928       initFonts();
 929     }
 930
 931     public Object clone() {
 932       return null;
 933     }
 934
 935     public EditorColorsScheme getOriginalScheme() {
 936       return myParentScheme;
 937     }
 938
 939     public void setIsNew() {
 940       myIsNew = true;
 941     }
 942
 943     public boolean isNew() {
 944       return myIsNew;
 945     }
 946   }
 947
 948   public String getId() {
 949     return getHelpTopic();
 950   }
 951
 952   @Nullable
 953   public Runnable enableSearch(final String option) {
 954     return null;
 955   }
 956
 957   @Nullable
 958   public InnerSearchableConfigurable findSubConfigurable(final Class pageClass) {
 959     if (mySubPanelFactories == null) {
 960       buildConfigurables();
 961     }
 962     for (Map.Entry<ColorAndFontPanelFactory, InnerSearchableConfigurable> entry : mySubPanelFactories.entrySet()) {
 963       if (pageClass.isInstance(entry.getValue().createPanel().getSettingsPage())) {
 964         return entry.getValue();
 965       }
 966     }
 967     return null;
 968   }
 969
 970   @Nullable
 971   public NewColorAndFontPanel findPage(String pageName) {
 972     if (mySubPanelFactories == null) {
 973       buildConfigurables();
 974     }
 975     for (InnerSearchableConfigurable configurable : mySubPanelFactories.values()) {
 976       if (configurable.getDisplayName().equals(pageName)) {
 977         return configurable.createPanel();
 978       }
 979     }
 980     return null;
 981   }
 982
 983   private class InnerSearchableConfigurable implements SearchableConfigurable, OptionsContainingConfigurable, NoScroll {
 984     private NewColorAndFontPanel mySubPanel;
 985     private boolean mySubInitInvoked = false;
 986     private final ColorAndFontPanelFactory myFactory;
 987
 988     private InnerSearchableConfigurable(final ColorAndFontPanelFactory factory) {
 989       myFactory = factory;
 990     }
 991
 992     @Nls
 993     public String getDisplayName() {
 994       return myFactory.getPanelDisplayName();
 995     }
 996
 997     public NewColorAndFontPanel getSubPanelIfInitialized() {
 998       return mySubPanel;
 999     }
1000
1001     private NewColorAndFontPanel createPanel() {
1002       if (mySubPanel == null) {
1003         mySubPanel = myFactory.createPanel(ColorAndFontOptions.this);
1004         mySubPanel.reset(this);
1005         mySubPanel.addSchemesListener(new ColorAndFontSettingsListener.Abstract(){
1006           public void schemeChanged(final Object source) {
1007             if (!myIsReset) {
1008               resetSchemesCombo(source);
1009             }
1010           }
1011         });
1012
1013         mySubPanel.addDescriptionListener(new ColorAndFontSettingsListener.Abstract(){
1014           @Override
1015           public void fontChanged() {
1016             for (NewColorAndFontPanel panel : getPanels()) {
1017               panel.updatePreview();
1018             }
1019           }
1020         });
1021       }
1022       return mySubPanel;
1023     }
1024
1025     public Icon getIcon() {
1026       return null;
1027     }
1028
1029     public String getHelpTopic() {
1030       return null;
1031     }
1032
1033     public JComponent createComponent() {
1034       return createPanel().getPanel();
1035     }
1036
1037     public boolean isModified() {
1038       createPanel();
1039       for (MyColorScheme scheme : mySchemes.values()) {
1040         if (mySubPanel.containsFontOptions()) {
1041           if (scheme.isFontModified()) {
1042             myRevertChangesCompleted = false;
1043             return true;
1044           }
1045         }
1046         else {
1047           for (EditorSchemeAttributeDescriptor descriptor : scheme.getDescriptors()) {
1048             if (mySubPanel.contains(descriptor) && descriptor.isModified()) {
1049               myRevertChangesCompleted = false;
1050               return true;
1051             }
1052           }
1053         }
1054
1055       }
1056
1057       return false;
1058
1059     }
1060
1061     public void apply() throws ConfigurationException {
1062       ColorAndFontOptions.this.apply();
1063     }
1064
1065     public void reset() {
1066       if (!mySubInitInvoked) {
1067         if (!myInitResetCompleted) {
1068           resetFromChild();
1069         }
1070         mySubInitInvoked = true;
1071       }
1072       else {
1073         revertChanges();
1074       }
1075     }
1076
1077     public void disposeUIResources() {
1078       if (mySubPanel != null) {
1079         mySubPanel.disposeUIResources();
1080       }
1081     }
1082
1083     public String getId() {
1084       return ColorAndFontOptions.this.getId() + "." + getDisplayName();
1085     }
1086
1087     public Runnable enableSearch(final String option) {
1088       return createPanel().showOption(option);
1089     }
1090
1091     public Set<String> processListOptions() {
1092       return createPanel().processListOptions();
1093     }
1094   }
1095
1096 }