platform/lang-impl/src/com/intellij/ide/fileTemplates/impl/AllFileTemplatesConfigurable.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.ide.fileTemplates.impl;
  18
  19 import com.intellij.ide.IdeBundle;
  20 import com.intellij.ide.fileTemplates.*;
  21 import com.intellij.ide.util.PropertiesComponent;
  22 import com.intellij.openapi.Disposable;
  23 import com.intellij.openapi.actionSystem.*;
  24 import com.intellij.openapi.application.ApplicationManager;
  25 import com.intellij.openapi.diagnostic.Logger;
  26 import com.intellij.openapi.extensions.Extensions;
  27 import com.intellij.openapi.options.ConfigurationException;
  28 import com.intellij.openapi.options.SearchableConfigurable;
  29 import com.intellij.openapi.ui.DialogWrapper;
  30 import com.intellij.openapi.ui.Messages;
  31 import com.intellij.openapi.util.Comparing;
  32 import com.intellij.openapi.util.Disposer;
  33 import com.intellij.openapi.util.IconLoader;
  34 import com.intellij.openapi.vfs.VirtualFile;
  35 import com.intellij.ui.TabbedPaneWrapper;
  36 import com.intellij.util.ArrayUtil;
  37 import com.intellij.util.Function;
  38 import com.intellij.util.containers.ContainerUtil;
  39 import gnu.trove.THashSet;
  40 import org.jetbrains.annotations.NonNls;
  41 import org.jetbrains.annotations.NotNull;
  42 import org.jetbrains.annotations.Nullable;
  43
  44 import javax.swing.*;
  45 import javax.swing.event.ChangeEvent;
  46 import javax.swing.event.ChangeListener;
  47 import java.awt.*;
  48 import java.text.MessageFormat;
  49 import java.util.*;
  50 import java.util.List;
  51
  52 /*
  53  * @author: MYakovlev
  54  * Date: Jul 26, 2002
  55  * Time: 12:44:56 PM
  56  */
  57
  58 public class AllFileTemplatesConfigurable implements SearchableConfigurable {
  59   private static final Logger LOG = Logger.getInstance("#com.intellij.ide.fileTemplates.impl.AllFileTemplatesConfigurable");
  60   private JPanel myMainPanel;
  61   private FileTemplateTab myCurrentTab;
  62   private FileTemplateTab myTemplatesList;
  63   private FileTemplateTab myIncludesList;
  64   private FileTemplateTab myCodeTemplatesList;
  65   private FileTemplateTab myJ2eeTemplatesList;
  66   private JComponent myToolBar;
  67   private TabbedPaneWrapper myTabbedPane;
  68   private FileTemplateConfigurable myEditor;
  69   private boolean myModified = false;
  70   private JComponent myEditorComponent;
  71   private static final int TEMPLATE_ID = 0;
  72   private static final int PATTERN_ID = 1;
  73   private static final int CODE_ID = 2;
  74   private static final int J2EE_ID = 3;
  75   private static final Icon ourIcon = IconLoader.getIcon("/general/fileTemplates.png");
  76   private FileTemplateTab[] myTabs;
  77   private static final String TEMPLATES_TITLE = IdeBundle.message("tab.filetemplates.templates");
  78   private static final String INCLUDES_TITLE = IdeBundle.message("tab.filetemplates.includes");
  79   private static final String CODE_TITLE = IdeBundle.message("tab.filetemplates.code");
  80   private static final String J2EE_TITLE = IdeBundle.message("tab.filetemplates.j2ee");
  81   private Disposable myUIDisposable;
  82
  83   @NonNls private static final String CURRENT_TAB = "FileTemplates.CurrentTab";
  84   @NonNls private static final String SELECTED_TEMPLATE = "FileTemplates.SelectedTemplate";
  85
  86   public Icon getIcon() {
  87     return ourIcon;
  88   }
  89
  90   private void onRemove() {
  91     myCurrentTab.removeSelected();
  92     myModified = true;
  93   }
  94
  95   private void onAdd() {
  96     String ext = "java";
  97     final FileTemplateDefaultExtension[] defaultExtensions = Extensions.getExtensions(FileTemplateDefaultExtension.EP_NAME);
  98     if (defaultExtensions.length > 0) {
  99       ext = defaultExtensions [0].value;
 100     }
 101     createTemplate(IdeBundle.message("template.unnamed"), ext, "");
 102   }
 103
 104   private FileTemplate createTemplate(@NotNull String prefName, @NotNull @NonNls String extension, @NotNull String content) {
 105     FileTemplate[] templates = myCurrentTab.getTemplates();
 106     ArrayList<String> names = new ArrayList<String>(templates.length);
 107     for (FileTemplate template : templates) {
 108       names.add(template.getName());
 109     }
 110     String name = prefName;
 111     int i = 0;
 112     while (names.contains(name)) {
 113       name = prefName + " (" + ++i + ")";
 114     }
 115     FileTemplate newTemplate = new FileTemplateImpl(content, name, extension);
 116     myCurrentTab.addTemplate(newTemplate);
 117     myModified = true;
 118     myCurrentTab.selectTemplate(newTemplate);
 119     fireListChanged();
 120     myEditor.focusToNameField();
 121     return newTemplate;
 122   }
 123
 124   private void onClone() {
 125     FileTemplate selected = myCurrentTab.getSelectedTemplate();
 126     if (selected == null) return;
 127
 128     final FileTemplate[] templates = myCurrentTab.getTemplates();
 129     ArrayList<String> names = new ArrayList<String>(templates.length);
 130     for (FileTemplate template : templates) {
 131       names.add(template.getName());
 132     }
 133     @SuppressWarnings({"UnresolvedPropertyKey"})
 134     String nameTemplate = IdeBundle.message("template.copy.N.of.T");
 135     String name = MessageFormat.format(nameTemplate, "", selected.getName());
 136     int i = 0;
 137     while (names.contains(name)) {
 138       name = MessageFormat.format(nameTemplate, ++i + " ", selected.getName());
 139     }
 140     FileTemplate newTemplate = new FileTemplateImpl(selected.getText(), name, selected.getExtension());
 141     myCurrentTab.addTemplate(newTemplate);
 142     myModified = true;
 143     myCurrentTab.selectTemplate(newTemplate);
 144     fireListChanged();
 145   }
 146
 147   public String getDisplayName() {
 148     return IdeBundle.message("title.file.templates");
 149   }
 150
 151   public String getHelpTopic() {
 152     int index = myTabbedPane.getSelectedIndex();
 153     switch (index) {
 154       case 0:
 155         return "fileTemplates.templates";
 156       case 1:
 157         return "fileTemplates.includes";
 158       case 2:
 159         return "fileTemplates.code";
 160       case 3:
 161         return "fileTemplates.j2ee";
 162       default:
 163         throw new IllegalStateException("wrong index: " + index);
 164     }
 165   }
 166
 167   public JComponent createComponent() {
 168     myUIDisposable = Disposer.newDisposable();
 169     myTemplatesList = new FileTemplateTabAsList(TEMPLATES_TITLE) {
 170       public void onTemplateSelected() {
 171         onListSelectionChanged();
 172       }
 173     };
 174     myIncludesList = new FileTemplateTabAsList(INCLUDES_TITLE) {
 175       public void onTemplateSelected() {
 176         onListSelectionChanged();
 177       }
 178     };
 179     myCodeTemplatesList = new FileTemplateTabAsList(CODE_TITLE) {
 180       public void onTemplateSelected() {
 181         onListSelectionChanged();
 182       }
 183     };
 184     myCurrentTab = myTemplatesList;
 185
 186     List<FileTemplateTab> allTabs = new ArrayList<FileTemplateTab>(Arrays.asList(myTemplatesList, myIncludesList, myCodeTemplatesList));
 187
 188     final Set<FileTemplateGroupDescriptorFactory> factories = new THashSet<FileTemplateGroupDescriptorFactory>();
 189     factories.addAll(Arrays.asList(ApplicationManager.getApplication().getComponents(FileTemplateGroupDescriptorFactory.class)));
 190     factories.addAll(Arrays.asList(Extensions.getExtensions(FileTemplateGroupDescriptorFactory.EXTENSION_POINT_NAME)));
 191
 192     if (!factories.isEmpty()) {
 193       myJ2eeTemplatesList = new FileTemplateTabAsTree(J2EE_TITLE) {
 194         public void onTemplateSelected() {
 195           onListSelectionChanged();
 196         }
 197
 198         protected FileTemplateNode initModel() {
 199           SortedSet<FileTemplateGroupDescriptor> categories = new TreeSet<FileTemplateGroupDescriptor>(new Comparator<FileTemplateGroupDescriptor>() {
 200             public int compare(FileTemplateGroupDescriptor o1, FileTemplateGroupDescriptor o2) {
 201               return o1.getTitle().compareTo(o2.getTitle());
 202             }
 203           });
 204
 205
 206           for (FileTemplateGroupDescriptorFactory templateGroupFactory : factories) {
 207             ContainerUtil.addIfNotNull(templateGroupFactory.getFileTemplatesDescriptor(), categories);
 208           }
 209
 210           //noinspection HardCodedStringLiteral
 211           return new FileTemplateNode("ROOT", null, ContainerUtil.map2List(categories, new Function<FileTemplateGroupDescriptor, FileTemplateNode>() {
 212             public FileTemplateNode fun(FileTemplateGroupDescriptor s) {
 213               return new FileTemplateNode(s);
 214             }
 215           }));
 216         }
 217       };
 218       allTabs.add(myJ2eeTemplatesList);
 219     }
 220     myTabs = allTabs.toArray(new FileTemplateTab[allTabs.size()]);
 221     myTabbedPane = new TabbedPaneWrapper(myUIDisposable);
 222     myTabbedPane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
 223     for (FileTemplateTab tab : myTabs) {
 224       myTabbedPane.addTab(tab.getTitle(), new JScrollPane(tab.getComponent()));
 225     }
 226
 227     myTabbedPane.addChangeListener(new ChangeListener() {
 228       public void stateChanged(ChangeEvent e) {
 229         onTabChanged();
 230       }
 231     });
 232
 233     DefaultActionGroup group = new DefaultActionGroup();
 234     AnAction removeAction = new AnAction(IdeBundle.message("action.remove.template"), null, IconLoader.getIcon("/general/remove.png")) {
 235       public void actionPerformed(AnActionEvent e) {
 236         onRemove();
 237       }
 238
 239       public void update(AnActionEvent e) {
 240         super.update(e);
 241         FileTemplate selectedItem = myCurrentTab.getSelectedTemplate();
 242         e.getPresentation().setEnabled(selectedItem != null && !isInternalTemplate(selectedItem.getName(), myCurrentTab.getTitle()));
 243       }
 244     };
 245     AnAction addAction = new AnAction(IdeBundle.message("action.create.template"), null, IconLoader.getIcon("/general/add.png")) {
 246       public void actionPerformed(AnActionEvent e) {
 247         onAdd();
 248       }
 249
 250       public void update(AnActionEvent e) {
 251         super.update(e);
 252         e.getPresentation().setEnabled(!(myCurrentTab == myCodeTemplatesList || myCurrentTab == myJ2eeTemplatesList));
 253       }
 254     };
 255     AnAction cloneAction = new AnAction(IdeBundle.message("action.copy.template"), null, IconLoader.getIcon("/actions/copy.png")) {
 256       public void actionPerformed(AnActionEvent e) {
 257         onClone();
 258       }
 259
 260       public void update(AnActionEvent e) {
 261         super.update(e);
 262         e.getPresentation().setEnabled(myCurrentTab != myCodeTemplatesList
 263                                        && myCurrentTab != myJ2eeTemplatesList
 264                                        && myCurrentTab.getSelectedTemplate() != null);
 265       }
 266     };
 267     AnAction resetAction = new AnAction(IdeBundle.message("action.reset.to.default"), null, IconLoader.getIcon("/actions/reset.png")) {
 268       public void actionPerformed(AnActionEvent e) {
 269         onReset();
 270       }
 271
 272       public void update(AnActionEvent e) {
 273         super.update(e);
 274         FileTemplate selectedItem = myCurrentTab.getSelectedTemplate();
 275         FileTemplateManagerImpl manager = FileTemplateManagerImpl.getInstanceImpl();
 276         e.getPresentation().setEnabled(selectedItem != null
 277                                        && !selectedItem.isDefault()
 278                                        &&
 279                                        manager.getDefaultTemplate(selectedItem.getName(), selectedItem.getExtension()) !=
 280                                        null);
 281       }
 282     };
 283     group.add(addAction);
 284     group.add(removeAction);
 285     group.add(cloneAction);
 286     group.add(resetAction);
 287     addAction.registerCustomShortcutSet(CommonShortcuts.INSERT, myCurrentTab.getComponent());
 288     removeAction.registerCustomShortcutSet(CommonShortcuts.DELETE,
 289                                            myCurrentTab.getComponent());
 290
 291     myToolBar = ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, group, true).getComponent();
 292
 293     myEditor = new FileTemplateConfigurable();
 294
 295     myEditor.addChangeListener(new ChangeListener() {
 296       public void stateChanged(ChangeEvent e) {
 297         onEditorChanged();
 298       }
 299     });
 300     myMainPanel = new JPanel(new GridBagLayout()) {
 301       public void doLayout() {
 302         doMainPanelLayout();
 303       }
 304     };
 305     // Layout manager is ignored
 306     myMainPanel.add(myToolBar,
 307                     new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.WEST,
 308                                            GridBagConstraints.HORIZONTAL, new Insets(2, 2, 2, 2), 0, 0));
 309     myMainPanel.add(myTabbedPane.getComponent(),
 310                     new GridBagConstraints(0, 1, 1, 1, 0.0, 1.0, GridBagConstraints.NORTHWEST, GridBagConstraints.BOTH,
 311                                            new Insets(2, 2, 2, 2), 0, 0));
 312     myEditorComponent = myEditor.createComponent();
 313     myMainPanel.add(myEditorComponent,
 314                     new GridBagConstraints(1, 0, 1, 2, 1.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
 315                                            new Insets(2, 2, 2, 2), 0, 0));
 316
 317     myMainPanel.setMinimumSize(new Dimension(400, 300));
 318     myMainPanel.setPreferredSize(new Dimension(700, 500));
 319
 320     return myMainPanel;
 321   }
 322
 323   private void onReset() {
 324     FileTemplate selected = myCurrentTab.getSelectedTemplate();
 325     if (selected != null) {
 326       if (Messages.showOkCancelDialog(IdeBundle.message("prompt.reset.to.original.template"),
 327                                       IdeBundle.message("title.reset.template"), Messages.getQuestionIcon()) !=
 328           DialogWrapper.OK_EXIT_CODE) {
 329         return;
 330       }
 331       FileTemplateImpl template = (FileTemplateImpl)selected;
 332
 333       template.resetToDefault();
 334       myEditor.reset();
 335       myModified = true;
 336     }
 337   }
 338
 339   private void onEditorChanged() {
 340     fireListChanged();
 341   }
 342
 343
 344   private void onTabChanged() {
 345     int selectedIndex = myTabbedPane.getSelectedIndex();
 346     if (0 <= selectedIndex && selectedIndex < myTabs.length) {
 347       myCurrentTab = myTabs[selectedIndex];
 348     }
 349     onListSelectionChanged();
 350   }
 351
 352   private void onListSelectionChanged() {
 353     FileTemplate selectedValue = myCurrentTab.getSelectedTemplate();
 354     FileTemplate prevTemplate = myEditor == null ? null : myEditor.getTemplate();
 355     if (prevTemplate != selectedValue) {
 356       LOG.assertTrue(myEditor != null, "selected:" + selectedValue + "; prev:" + prevTemplate);
 357       //selection has changed
 358       if (myEditor.isModified()) {
 359         try {
 360           myModified = true;
 361           myEditor.apply();
 362           fireListChanged();
 363         }
 364         catch (ConfigurationException e) {
 365           myCurrentTab.selectTemplate(prevTemplate);
 366           Messages.showErrorDialog(myMainPanel, e.getMessage(), IdeBundle.message("title.cannot.save.current.template"));
 367           return;
 368         }
 369       }
 370       if (selectedValue == null) {
 371         myEditor.setTemplate(null, FileTemplateManagerImpl.getInstanceImpl().getDefaultTemplateDescription());
 372       }
 373       else {
 374         selectTemplate(selectedValue);
 375       }
 376     }
 377   }
 378
 379   private void selectTemplate(FileTemplate template) {
 380     VirtualFile defDesc = null;
 381     if (myCurrentTab == myTemplatesList) {
 382       defDesc = FileTemplateManagerImpl.getInstanceImpl().getDefaultTemplateDescription();
 383     }
 384     else if (myCurrentTab == myIncludesList) {
 385       defDesc = FileTemplateManagerImpl.getInstanceImpl().getDefaultIncludeDescription();
 386     }
 387     if (myEditor.getTemplate() != template) {
 388       myEditor.setTemplate(template, defDesc);
 389       final boolean isInternal = isInternalTemplate(template.getName(), myCurrentTab.getTitle());
 390       myEditor.setShowInternalMessage(isInternal ? " " : null);
 391       myEditor.setShowAdjustCheckBox(myTemplatesList == myCurrentTab);
 392     }
 393   }
 394
 395   // internal template could not be removed and should be rendered bold
 396   @SuppressWarnings({"SimplifiableIfStatement"})
 397   public static boolean isInternalTemplate(String templateName, String templateTabTitle) {
 398     if (templateName == null) return false;
 399     if (Comparing.strEqual(templateTabTitle, TEMPLATES_TITLE)) {
 400       return isInternalTemplateName(templateName);
 401     }
 402     if (Comparing.strEqual(templateTabTitle, CODE_TITLE)) {
 403       return true;
 404     }
 405     if (Comparing.strEqual(templateTabTitle, J2EE_TITLE)) {
 406       return true;
 407     }
 408     if (Comparing.strEqual(templateTabTitle, INCLUDES_TITLE)) {
 409       return Comparing.strEqual(templateName, FileTemplateManager.FILE_HEADER_TEMPLATE_NAME);
 410     }
 411
 412     return false;
 413   }
 414
 415   private static boolean isInternalTemplateName(final String templateName) {
 416     for(InternalTemplateBean bean: Extensions.getExtensions(InternalTemplateBean.EP_NAME)) {
 417       if (Comparing.strEqual(templateName, bean.name)) return true;
 418     }
 419     return false;
 420   }
 421
 422   private void doMainPanelLayout() {
 423     Dimension toolbarPreferredSize = myToolBar.getPreferredSize();
 424     Dimension mainPanelSize = myMainPanel.getSize();
 425     Dimension scrollPanePreferedSize = myTabbedPane.getComponent().getPreferredSize();
 426     if (mainPanelSize.width < 1 || mainPanelSize.height < 1) {
 427       return;
 428     }
 429     int leftWidth = scrollPanePreferedSize.width;
 430     leftWidth = Math.min(leftWidth, mainPanelSize.width / 5);
 431     leftWidth = Math.max(leftWidth, 300); //to prevent tabs from scrolling
 432     //todo[myakovlev] Calculate tabs preferred size
 433     leftWidth = Math.max(leftWidth, toolbarPreferredSize.width);
 434     int x = 2;
 435     int y = 2;
 436     int width = toolbarPreferredSize.width;
 437     int height = toolbarPreferredSize.height;
 438     myToolBar.setBounds(x, y, width, height);
 439     y += height + 2;
 440     width = leftWidth + 2;
 441     height = Math.max(1, mainPanelSize.height - 2 - y);
 442     myTabbedPane.getComponent().setBounds(x, y, width, height);
 443     x += width + 4;
 444     y = 2;
 445     width = Math.max(1, mainPanelSize.width - 2 - x);
 446     height = Math.max(1, mainPanelSize.height - 2 - y);
 447     myEditorComponent.setBounds(x, y, width, height);
 448     myEditorComponent.revalidate();
 449   }
 450
 451   private void initLists() {
 452     FileTemplateManager templateManager = FileTemplateManager.getInstance();
 453     FileTemplate[] templates = templateManager.getAllTemplates();
 454     FileTemplate[] internals = templateManager.getInternalTemplates();
 455     FileTemplate[] templatesAndInternals = ArrayUtil.mergeArrays(internals, templates, FileTemplate.class);
 456     myTemplatesList.init(templatesAndInternals);
 457     myIncludesList.init(templateManager.getAllPatterns());
 458     myCodeTemplatesList.init(templateManager.getAllCodeTemplates());
 459     if (myJ2eeTemplatesList != null) {
 460       myJ2eeTemplatesList.init(templateManager.getAllJ2eeTemplates());
 461     }
 462   }
 463
 464   public boolean isModified() {
 465     return myModified || myEditor != null && myEditor.isModified();
 466   }
 467
 468   /**
 469    * If apply is acceptable, returns true. If no, returns false and fills error string.
 470    */
 471   private boolean canApply(final boolean showErrorDialog, String[] errorString) {
 472     for (FileTemplateTab list : myTabs) {
 473       if (!canApply(showErrorDialog, errorString, list)) return false;
 474     }
 475     return true;
 476   }
 477
 478   private boolean canApply(final boolean showErrorDialog, String[] errorString, FileTemplateTab list) {
 479     final FileTemplate[] templates = myCurrentTab.getTemplates();
 480     ArrayList<String> allNames = new ArrayList<String>();
 481     FileTemplate itemWithError = null;
 482     String errorMessage = null;
 483     String errorTitle = null;
 484     boolean errorInName = true;
 485     for (FileTemplate template : templates) {
 486       if (isInternalTemplateName(template.getName())) continue;
 487       String currName = template.getName();
 488       String currExt = template.getExtension();
 489       if (currName.length() == 0) {
 490         itemWithError = template;
 491         errorMessage = IdeBundle.message("error.please.specify.a.name.for.this.template");
 492         errorTitle = IdeBundle.message("title.template.name.not.specified");
 493         errorString[0] = IdeBundle.message("error.please.specify.template.name");
 494         break;
 495       }
 496       if (allNames.contains(currName)) {
 497         itemWithError = template;
 498         errorMessage = IdeBundle.message("error.please.specify.a.different.name.for.this.template");
 499         errorTitle = IdeBundle.message("title.template.already.exists");
 500         errorString[0] = IdeBundle.message("error.template.with.such.name.already.exists");
 501         break;
 502       }
 503       if (currExt.length() == 0) {
 504         itemWithError = template;
 505         errorMessage = IdeBundle.message("error.please.specify.extension");
 506         errorTitle = IdeBundle.message("title.template.extension.not.specified");
 507         errorString[0] = IdeBundle.message("error.please.specify.template.extension");
 508         errorInName = false;
 509         break;
 510       }
 511       allNames.add(currName);
 512     }
 513     if (itemWithError == null) {
 514       return true;
 515     }
 516     else {
 517       final String _errorString = errorMessage;
 518       final String _errorTitle = errorTitle;
 519       final boolean _errorInName = errorInName;
 520       myTabbedPane.setSelectedIndex(Arrays.asList(myTabs).indexOf(list));
 521       selectTemplate(itemWithError);
 522       list.selectTemplate(itemWithError);
 523       ApplicationManager.getApplication().invokeLater(new Runnable() {
 524           public void run() {
 525             if (showErrorDialog) {
 526               Messages.showMessageDialog(myMainPanel, _errorString, _errorTitle, Messages.getErrorIcon());
 527             }
 528             if (_errorInName) {
 529               myEditor.focusToNameField();
 530             }
 531             else {
 532               myEditor.focusToExtensionField();
 533             }
 534           }
 535         });
 536       return false;
 537     }
 538   }
 539
 540   private void fireListChanged() {
 541     myCurrentTab.fireDataChanged();
 542     if (myMainPanel != null) {
 543       myMainPanel.revalidate();
 544     }
 545   }
 546
 547   public void apply() throws ConfigurationException {
 548     if (myEditor != null && myEditor.isModified()) {
 549       myModified = true;
 550       myEditor.apply();
 551     }
 552     String[] errorString = new String[1];
 553     if (!canApply(false, errorString)) {
 554       throw new ConfigurationException(errorString[0]);
 555     }
 556
 557     // Apply templates
 558     ArrayList<FileTemplate> newModifiedItems = new ArrayList<FileTemplate>();
 559     FileTemplate[] templates = myTemplatesList.getTemplates();
 560     newModifiedItems.addAll(Arrays.asList(templates));
 561     FileTemplateManager templatesManager = FileTemplateManager.getInstance();
 562     apply(newModifiedItems, myTemplatesList.savedTemplates, TEMPLATE_ID, templatesManager.getAllTemplates());
 563
 564     // Apply patterns
 565     newModifiedItems = new ArrayList<FileTemplate>();
 566     templates = myIncludesList.getTemplates();
 567     newModifiedItems.addAll(Arrays.asList(templates));
 568     apply(newModifiedItems, myIncludesList.savedTemplates, PATTERN_ID, templatesManager.getAllPatterns());
 569
 570     //Apply code templates
 571     newModifiedItems = new ArrayList<FileTemplate>();
 572     templates = myCodeTemplatesList.getTemplates();
 573     newModifiedItems.addAll(Arrays.asList(templates));
 574     apply(newModifiedItems, myCodeTemplatesList.savedTemplates, CODE_ID, templatesManager.getAllCodeTemplates());
 575
 576     //Apply J2EE templates
 577     if (myJ2eeTemplatesList != null) {
 578       newModifiedItems = new ArrayList<FileTemplate>();
 579       templates = myJ2eeTemplatesList.getTemplates();
 580       newModifiedItems.addAll(Arrays.asList(templates));
 581       apply(newModifiedItems, myJ2eeTemplatesList.savedTemplates, J2EE_ID, templatesManager.getAllJ2eeTemplates());
 582     }
 583
 584     FileTemplateManager.getInstance().saveAll();
 585
 586     if (myEditor != null) {
 587       myModified = false;
 588       fireListChanged();
 589       reset();
 590     }
 591   }
 592
 593   private static void removeTemplate(FileTemplate aTemplate, int listId, boolean fromDiskOnly) {
 594     FileTemplateManager manager = FileTemplateManager.getInstance();
 595     if (listId == TEMPLATE_ID) {
 596       if (!aTemplate.isInternal()) {
 597         manager.removeTemplate(aTemplate, fromDiskOnly);
 598       } else {
 599         manager.removeInternal(aTemplate);
 600       }
 601     }
 602     else if (listId == PATTERN_ID) {
 603       manager.removePattern(aTemplate, fromDiskOnly);
 604     }
 605     else if (listId == CODE_ID) {
 606       manager.removeCodeTemplate(aTemplate, fromDiskOnly);
 607     }
 608     else if (listId == J2EE_ID) {
 609       manager.removeJ2eeTemplate(aTemplate, fromDiskOnly);
 610     }
 611   }
 612
 613   private static void apply(ArrayList<FileTemplate> newModifiedItems,
 614                             Map<FileTemplate,FileTemplate> savedTemplate2ModifiedTemplate,
 615                             int listId,
 616                             FileTemplate[] templates) {
 617     FileTemplateManager templatesManager = FileTemplateManager.getInstance();
 618     if (listId == TEMPLATE_ID) {
 619       FileTemplate[] internals = templatesManager.getInternalTemplates();
 620       templates = ArrayUtil.mergeArrays(internals, templates, FileTemplate.class);
 621     }
 622     ArrayList<FileTemplate> savedTemplates = new ArrayList<FileTemplate>();
 623     // Delete removed and fill savedTemplates
 624     for (FileTemplate aTemplate : templates) {
 625       FileTemplate aModifiedTemplate = savedTemplate2ModifiedTemplate.get(aTemplate);
 626       if (newModifiedItems.contains(aModifiedTemplate)) {
 627         savedTemplates.add(aTemplate);
 628       } else {
 629         removeTemplate(aTemplate, listId, false);
 630         savedTemplate2ModifiedTemplate.remove(aTemplate);
 631       }
 632     }
 633     // Now all removed templates deleted from table, savedTemplates contains all templates in table
 634     for (FileTemplate aTemplate : savedTemplates) {
 635       FileTemplate aModifiedTemplate = savedTemplate2ModifiedTemplate.get(aTemplate);
 636       LOG.assertTrue(aModifiedTemplate != null);
 637       aTemplate.setAdjust(aModifiedTemplate.isAdjust());
 638       if (!aModifiedTemplate.isDefault()) {
 639         FileTemplateUtil.copyTemplate(aModifiedTemplate, aTemplate);
 640       } else {
 641         if (!aTemplate.isDefault()) {
 642           removeTemplate(aTemplate, listId, true);
 643         }
 644       }
 645     }
 646
 647     // Add new templates to table
 648     for (FileTemplate aModifiedTemplate : newModifiedItems) {
 649       LOG.assertTrue(aModifiedTemplate != null);
 650       if (!savedTemplate2ModifiedTemplate.containsValue(aModifiedTemplate)) {
 651         if (listId == TEMPLATE_ID) {
 652           templatesManager.addTemplate(aModifiedTemplate.getName(), aModifiedTemplate.getExtension()).setText(aModifiedTemplate.getText());
 653         }
 654         else if (listId == PATTERN_ID) {
 655           templatesManager.addPattern(aModifiedTemplate.getName(), aModifiedTemplate.getExtension()).setText(aModifiedTemplate.getText());
 656         }
 657         else if (listId == CODE_ID) {
 658           templatesManager.addCodeTemplate(aModifiedTemplate.getName(), aModifiedTemplate.getExtension()).setText(aModifiedTemplate.getText());
 659         }
 660         else if (listId == J2EE_ID) {
 661           templatesManager.addJ2eeTemplate(aModifiedTemplate.getName(), aModifiedTemplate.getExtension()).setText(aModifiedTemplate.getText());
 662         }
 663       }
 664     }
 665   }
 666
 667   public void reset() {
 668     myEditor.reset();
 669     initLists();
 670     final PropertiesComponent component = PropertiesComponent.getInstance();
 671     final String tabName = component.getValue(CURRENT_TAB);
 672     int idx = 0;
 673     for (FileTemplateTab tab : myTabs) {
 674       if (Comparing.strEqual(tab.getTitle(), tabName)) {
 675         myCurrentTab = tab;
 676         myTabbedPane.setSelectedIndex(idx);
 677         final String selectedTemplate = component.getValue(SELECTED_TEMPLATE);
 678         final FileTemplate[] templates = myCurrentTab.getTemplates();
 679         for (FileTemplate template : templates) {
 680           if (Comparing.strEqual(template.getName(), selectedTemplate)) {
 681             tab.selectTemplate(template);
 682             break;
 683           }
 684         }
 685         break;
 686       }
 687       idx++;
 688     }
 689     myModified = false;
 690   }
 691
 692   public void disposeUIResources() {
 693     if (myCurrentTab != null) {
 694       final PropertiesComponent propertiesComponent = PropertiesComponent.getInstance();
 695       propertiesComponent.setValue(CURRENT_TAB, myCurrentTab.getTitle());
 696       final FileTemplate template = myCurrentTab.getSelectedTemplate();
 697       if (template != null) {
 698         propertiesComponent.setValue(SELECTED_TEMPLATE, template.getName());
 699       }
 700     }
 701
 702     if (myEditor != null) {
 703       myEditor.disposeUIResources();
 704       myEditor = null;
 705       myEditorComponent = null;
 706     }
 707     myMainPanel = null;
 708     if (myUIDisposable != null) {
 709       Disposer.dispose(myUIDisposable);
 710       myUIDisposable = null;
 711     }
 712     myTabbedPane = null;
 713     myToolBar = null;
 714     myTabs = null;
 715     myCurrentTab = null;
 716     myTemplatesList = null;
 717     myCodeTemplatesList = null;
 718     myIncludesList = null;
 719     myJ2eeTemplatesList = null;
 720   }
 721
 722   public void createNewTemplate(@NotNull String preferredName, @NotNull String extension, @NotNull String text) {
 723     createTemplate(preferredName, extension, text);
 724   }
 725
 726   public String getId() {
 727     return "fileTemplates";
 728   }
 729
 730   @Nullable
 731   public Runnable enableSearch(String option) {
 732     return null;
 733   }
 734 }