platform/platform-api/src/com/intellij/openapi/ui/NamedItemsListEditor.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 /*
  18  * @author max
  19  */
  20 package com.intellij.openapi.ui;
  21
  22 import com.intellij.openapi.actionSystem.AnAction;
  23 import com.intellij.openapi.actionSystem.AnActionEvent;
  24 import com.intellij.openapi.actionSystem.CommonShortcuts;
  25 import com.intellij.openapi.actionSystem.CustomShortcutSet;
  26 import com.intellij.openapi.options.ConfigurationException;
  27 import com.intellij.openapi.options.UnnamedConfigurable;
  28 import com.intellij.openapi.project.DumbAwareAction;
  29 import com.intellij.openapi.util.*;
  30 import com.intellij.util.Icons;
  31 import com.intellij.util.ui.tree.TreeUtil;
  32 import gnu.trove.Equality;
  33 import org.jetbrains.annotations.Nullable;
  34
  35 import javax.swing.*;
  36 import javax.swing.tree.DefaultMutableTreeNode;
  37 import javax.swing.tree.TreeNode;
  38 import java.awt.event.KeyEvent;
  39 import java.text.MessageFormat;
  40 import java.util.ArrayList;
  41 import java.util.Collections;
  42 import java.util.List;
  43
  44 public abstract class NamedItemsListEditor<T> extends MasterDetailsComponent {
  45     private final Namer<T> myNamer;
  46     private final Factory<T> myFactory;
  47     private final Cloner<T> myCloner;
  48     private final List<T> myItems = new ArrayList<T>();
  49     private final Equality<T> myComparer;
  50     private List<T> myResultItems;
  51     private final List<T> myOriginalItems;
  52
  53     protected NamedItemsListEditor(Namer<T> namer,
  54                                    Factory<T> factory,
  55                                    Cloner<T> cloner,
  56                                    Equality<T> comparer,
  57                                    List<T> items) {
  58         myNamer = namer;
  59         myFactory = factory;
  60         myCloner = cloner;
  61         myComparer = comparer;
  62
  63         myOriginalItems = items;
  64         myResultItems = items;
  65         reset();
  66
  67         initTree();
  68     }
  69
  70     public void reset() {
  71         myResultItems = myOriginalItems;
  72         myItems.clear();
  73
  74         myRoot.removeAllChildren();
  75         for (T item : myOriginalItems) {
  76             addNewNode(myCloner.cloneOf(item));
  77         }
  78
  79         super.reset();
  80     }
  81
  82     protected void processRemovedItems() {
  83     }
  84
  85     protected boolean wasObjectStored(Object editableObject) {
  86         return true;
  87     }
  88
  89     protected String subjDisplayName() {
  90         return "item";
  91     }
  92
  93     @Nullable
  94     public String askForProfileName(String titlePattern) {
  95         String title = MessageFormat.format(titlePattern, subjDisplayName());
  96         return Messages.showInputDialog("New " + subjDisplayName() + " name:", title, Messages.getQuestionIcon(), "", new InputValidator() {
  97             public boolean checkInput(String s) {
  98                 return s.length() > 0 && findByName(s) == null;
  99             }
 100
 101             public boolean canClose(String s) {
 102                 return checkInput(s);
 103             }
 104         });
 105     }
 106
 107     @Nullable
 108     private T findByName(String name) {
 109         for (T item : myItems) {
 110             if (Comparing.equal(name, myNamer.getName(item))) return item;
 111         }
 112
 113         return null;
 114     }
 115
 116     @Nullable
 117     protected ArrayList<AnAction> createActions(boolean fromPopup) {
 118         ArrayList<AnAction> result = new ArrayList<AnAction>();
 119         result.add(new AddAction());
 120
 121         result.add(new MyDeleteAction(new Condition<Object>() {
 122             @SuppressWarnings({"unchecked"})
 123             public boolean value(Object o) {
 124                 return canDelete((T) ((MyNode) o).getConfigurable().getEditableObject());
 125             }
 126         }));
 127
 128         result.add(new CopyAction());
 129
 130         return result;
 131     }
 132
 133     private void addNewNode(T item) {
 134         addNode(new MyNode(new ItemConfigurable(item)), myRoot);
 135         myItems.add(item);
 136     }
 137
 138     protected boolean canDelete(T item) {
 139         return true;
 140     }
 141
 142     protected abstract UnnamedConfigurable createConfigurable(T item);
 143
 144     @Override
 145     protected void onItemDeleted(Object item) {
 146         myItems.remove((T)item);
 147     }
 148
 149     protected void setDisplayName(T item, String name) {
 150       myNamer.setName(item, name);
 151     }
 152
 153     @Nullable
 154     protected UnnamedConfigurable getItemConfigurable(final T item) {
 155       final Ref<UnnamedConfigurable> result = new Ref<UnnamedConfigurable>();
 156       TreeUtil.traverse((TreeNode)myTree.getModel().getRoot(), new TreeUtil.Traverse() {
 157         public boolean accept(Object node) {
 158           final NamedConfigurable configurable = (NamedConfigurable)((DefaultMutableTreeNode)node).getUserObject();
 159           if (configurable.getEditableObject() == item) {
 160             result.set(((ItemConfigurable)configurable).myConfigurable);
 161             return false;
 162           }
 163           else {
 164             return true;
 165           }
 166         }
 167       });
 168       return result.get();
 169     }
 170
 171   private class ItemConfigurable extends NamedConfigurable {
 172         private final T myItem;
 173         private final UnnamedConfigurable myConfigurable;
 174
 175         public ItemConfigurable(T item) {
 176             super(myNamer.canRename(item), TREE_UPDATER);
 177             myItem = item;
 178             myConfigurable = createConfigurable(item);
 179         }
 180
 181         public void setDisplayName(String name) {
 182           NamedItemsListEditor.this.setDisplayName(myItem, name);
 183         }
 184
 185         public Object getEditableObject() {
 186             return myItem;
 187         }
 188
 189         public String getBannerSlogan() {
 190             return myNamer.getName(myItem);
 191         }
 192
 193         public JComponent createOptionsPanel() {
 194             return myConfigurable.createComponent();
 195         }
 196
 197         public String getDisplayName() {
 198             return myNamer.getName(myItem);
 199         }
 200
 201         public Icon getIcon() {
 202             if (myConfigurable instanceof Iconable) {
 203               return ((Iconable)myConfigurable).getIcon(0);
 204             }
 205             return null;
 206         }
 207
 208         public String getHelpTopic() {
 209             return null;
 210         }
 211
 212         public boolean isModified() {
 213             return myConfigurable.isModified();
 214         }
 215
 216         public void apply() throws ConfigurationException {
 217             myConfigurable.apply();
 218         }
 219
 220         public void reset() {
 221             myConfigurable.reset();
 222         }
 223
 224         public void disposeUIResources() {
 225             myConfigurable.disposeUIResources();
 226         }
 227     }
 228
 229     @Override
 230     public boolean isModified() {
 231         if (myResultItems.size() != myItems.size()) return true;
 232
 233         for (int i = 0; i < myItems.size(); i++) {
 234             if (!myComparer.equals(myItems.get(i), myResultItems.get(i))) return true;
 235         }
 236
 237         return super.isModified();
 238     }
 239
 240     public void apply() throws ConfigurationException {
 241         super.apply();
 242         myResultItems = myItems;
 243     }
 244
 245     protected List<T> getCurrentItems() {
 246       return Collections.unmodifiableList(myItems);
 247     }
 248
 249     public List<T> getItems() {
 250         return myResultItems;
 251     }
 252
 253     public T getSelectedItem() {
 254         return (T) getSelectedObject();
 255     }
 256
 257
 258     private class CopyAction extends DumbAwareAction {
 259         public CopyAction() {
 260             super("Copy", "Copy", MasterDetailsComponent.COPY_ICON);
 261             registerCustomShortcutSet(new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_D, KeyEvent.CTRL_MASK)), myTree);
 262         }
 263
 264         public void actionPerformed(AnActionEvent event) {
 265             final String profileName = askForProfileName("Copy {0}");
 266             if (profileName == null) return;
 267
 268             final T clone = myCloner.copyOf((T) getSelectedObject());
 269             myNamer.setName(clone, profileName);
 270             addNewNode(clone);
 271             selectNodeInTree(clone);
 272             onItemCloned(clone);
 273         }
 274
 275
 276         public void update(AnActionEvent event) {
 277             super.update(event);
 278             event.getPresentation().setEnabled(getSelectedObject() != null);
 279         }
 280     }
 281
 282     protected void onItemCloned(T clone) {
 283     }
 284
 285   private class AddAction extends DumbAwareAction {
 286         public AddAction() {
 287             super("Add", "Add", Icons.ADD_ICON);
 288             registerCustomShortcutSet(CommonShortcuts.INSERT, myTree);
 289         }
 290
 291         public void actionPerformed(AnActionEvent event) {
 292           final T newItem = createItem();
 293           if (newItem != null) {
 294             onItemCreated(newItem);
 295           }
 296         }
 297     }
 298
 299     public void selectItem(T item) {
 300         selectNodeInTree(findByName(myNamer.getName(item)));
 301     }
 302
 303     @Nullable
 304     protected T createItem() {
 305       final String name = askForProfileName("Create new {0}");
 306       if (name == null) return null;
 307       final T newItem = myFactory.create();
 308       myNamer.setName(newItem, name);
 309       return newItem;
 310     }
 311
 312     protected void onItemCreated(T newItem) {
 313       addNewNode(newItem);
 314       selectNodeInTree(newItem);
 315     }
 316
 317 }