src/main/java/jp/sourceforge/stigmata/ui/swing/WellknownClassesSettingsPane.java

   1 package jp.sourceforge.stigmata.ui.swing;
   2
   3 /*
   4  * $Id$
   5  */
   6
   7 import java.awt.BorderLayout;
   8 import java.awt.FlowLayout;
   9 import java.awt.event.ActionEvent;
  10 import java.awt.event.ActionListener;
  11 import java.awt.event.MouseAdapter;
  12 import java.awt.event.MouseEvent;
  13 import java.util.HashMap;
  14 import java.util.Map;
  15
  16 import javax.swing.AbstractAction;
  17 import javax.swing.Action;
  18 import javax.swing.Box;
  19 import javax.swing.DefaultListModel;
  20 import javax.swing.JButton;
  21 import javax.swing.JCheckBox;
  22 import javax.swing.JComboBox;
  23 import javax.swing.JComponent;
  24 import javax.swing.JLabel;
  25 import javax.swing.JList;
  26 import javax.swing.JOptionPane;
  27 import javax.swing.JPanel;
  28 import javax.swing.JPopupMenu;
  29 import javax.swing.JScrollPane;
  30 import javax.swing.JTextField;
  31 import javax.swing.border.TitledBorder;
  32 import javax.swing.event.DocumentEvent;
  33 import javax.swing.event.DocumentListener;
  34 import javax.swing.event.ListSelectionEvent;
  35 import javax.swing.event.ListSelectionListener;
  36
  37 import jp.sourceforge.stigmata.ui.swing.actions.PopupShowAction;
  38 import jp.sourceforge.stigmata.utils.WellknownClassJudgeRule;
  39 import jp.sourceforge.stigmata.utils.WellknownClassManager;
  40 import jp.sourceforge.talisman.i18n.Messages;
  41
  42 /**
  43  * Well-known classes judge rules management pane.
  44  *
  45  * @author Haruaki TAMADA
  46  * @version $Revision$
  47  */
  48 public class WellknownClassesSettingsPane extends JPanel{
  49     private static final long serialVersionUID = 329734546345634532L;
  50
  51     private StigmataFrame stigmata;
  52     private WellknownClassManager manager;
  53     private JList list;
  54     private DefaultListModel listmodel;
  55
  56     private Map<String, String> matchTypeMap = new HashMap<String, String>();
  57     private Map<String, String> partTypeMap = new HashMap<String, String>();
  58
  59     public WellknownClassesSettingsPane(StigmataFrame stigmata){
  60         this.stigmata = stigmata;
  61         this.manager = stigmata.getEnvironment().getWellknownClassManager();
  62
  63         initLayouts();
  64         initializeData();
  65     }
  66
  67     public synchronized void setWellknownClasses(WellknownClassManager manager){
  68         manager.clear();
  69         for(int i = 0; i < listmodel.getSize(); i++){
  70             WellknownClassJudgeRule rule = (WellknownClassJudgeRule)listmodel.getElementAt(i);
  71             manager.add(rule);
  72         }
  73     }
  74
  75     public synchronized WellknownClassManager createWellknownClassManager(){
  76         WellknownClassManager manager = new WellknownClassManager();
  77         setWellknownClasses(manager);
  78         return manager;
  79     }
  80
  81     public void reset(){
  82         listmodel.clear();
  83         initializeData();
  84     }
  85
  86     private synchronized boolean isWellknownClass(String className){
  87         WellknownClassManager manager = createWellknownClassManager();
  88
  89         return manager.isWellKnownClass(className);
  90     }
  91
  92     private String findType(JComboBox combo, Map<String, String> map){
  93         String item = (String)combo.getSelectedItem();
  94         for(Map.Entry<String, String> entry: map.entrySet()){
  95             if(item.equals(entry.getValue())){
  96                 return entry.getKey();
  97             }
  98         }
  99         return null;
 100     }
 101
 102     public void addRule(WellknownClassJudgeRule rule){
 103         if(rule != null){
 104             listmodel.addElement(rule);
 105             stigmata.setNeedToSaveSettings(true);
 106         }
 107     }
 108
 109     public void editRule(int index){
 110         WellknownClassJudgeRule rule = (WellknownClassJudgeRule)listmodel.getElementAt(index);
 111         WellknownClassJudgeRule newrule = createOrUpdateRule(stigmata.getMessages(), rule);
 112         if(newrule != null){
 113             listmodel.setElementAt(newrule, index);
 114             stigmata.setNeedToSaveSettings(true);
 115         }
 116     }
 117
 118
 119     private void initializeData(){
 120         for(WellknownClassJudgeRule rule : manager){
 121             listmodel.addElement(rule);
 122         }
 123
 124         for(WellknownClassJudgeRule.MatchType type: WellknownClassJudgeRule.MatchType.values()){
 125             matchTypeMap.put(type.name(), stigmata.getMessages().get("matchtype." + type.name()));
 126         }
 127         for(WellknownClassJudgeRule.MatchPartType type: WellknownClassJudgeRule.MatchPartType.values()){
 128             partTypeMap.put(type.name(), stigmata.getMessages().get("matchparttype." + type.name()));
 129         }
 130     }
 131
 132     private void initLayouts(){
 133         setLayout(new BorderLayout());
 134         JPanel center = new JPanel(new BorderLayout());
 135         listmodel = new DefaultListModel();
 136
 137         list = new JList(listmodel);
 138         JScrollPane scroll = new JScrollPane(list);
 139
 140         center.add(scroll, BorderLayout.CENTER);
 141         center.add(createSouthPane(stigmata.getMessages()), BorderLayout.SOUTH);
 142
 143         add(center, BorderLayout.CENTER);
 144         add(createCheckPane(stigmata.getMessages()), BorderLayout.SOUTH);
 145     }
 146
 147     private JComponent createCheckPane(final Messages messages){
 148         final JTextField text = new JTextField();
 149         final JButton checkButton = GUIUtility.createButton(messages, "checkwellknown");
 150         final JLabel label = new JLabel(GUIUtility.getIcon(messages, "wellknownclasschecker.default.icon"));
 151         checkButton.setEnabled(false);
 152
 153         ActionListener listener = new ActionListener(){
 154             @Override
 155             public void actionPerformed(ActionEvent e){
 156                 String t = text.getText().trim();
 157                 if(t.length() > 0){
 158                     String message = messages.get("wellknownclasschecker.wellknown.tooltip");
 159                     if(isWellknownClass(t)){
 160                         label.setIcon(GUIUtility.getIcon(messages, "wellknownclasschecker.wellknown.icon"));
 161                     }
 162                     else{
 163                         label.setIcon(GUIUtility.getIcon(messages, "wellknownclasschecker.notwellknown.icon"));
 164                         message = messages.get("wellknownclasschecker.notwellknown.tooltip");
 165                     }
 166                     label.setToolTipText(message);
 167                     String dm = String.format(
 168                         "<html><body><dl><dt>%s</dt><dd>%s</dd></body></html>", t, message
 169                     );
 170                     JOptionPane.showMessageDialog(
 171                         stigmata, dm, stigmata.getMessages().get("wellknownclasschecker.dialog.title"),
 172                         JOptionPane.INFORMATION_MESSAGE
 173                     );
 174                 }
 175             }
 176         };
 177         checkButton.addActionListener(listener);
 178         text.addActionListener(listener);
 179         text.getDocument().addDocumentListener(new DocumentListener(){
 180             @Override
 181             public void changedUpdate(DocumentEvent arg0){
 182                 checkButton.setEnabled(text.getText().trim().length() > 0);
 183             }
 184
 185             @Override
 186             public void insertUpdate(DocumentEvent arg0){
 187                 checkButton.setEnabled(text.getText().trim().length() > 0);
 188             }
 189
 190             @Override
 191             public void removeUpdate(DocumentEvent arg0){
 192                 checkButton.setEnabled(text.getText().trim().length() > 0);
 193             }
 194         });
 195
 196         JComponent south = Box.createHorizontalBox();
 197         south.add(Box.createHorizontalGlue());
 198         south.add(text);
 199         south.add(Box.createHorizontalGlue());
 200         south.add(checkButton);
 201         south.add(Box.createHorizontalGlue());
 202         south.add(label);
 203         south.add(Box.createHorizontalGlue());
 204
 205         south.setBorder(new TitledBorder(stigmata.getMessages().get("wellknownclasschecker.border")));
 206
 207         return south;
 208     }
 209
 210     private JComponent createSouthPane(final Messages messages){
 211         JComponent southPanel = Box.createHorizontalBox();
 212         Action addAction = new AbstractAction(){
 213             private static final long serialVersionUID = -8749957850400877529L;
 214
 215             @Override
 216             public void actionPerformed(ActionEvent e){
 217                 addRule(createOrUpdateRule(messages, null));
 218             }
 219         };
 220         final Action removeAction = new AbstractAction(){
 221             private static final long serialVersionUID = 8776209200186477040L;
 222
 223             @Override
 224             public void actionPerformed(ActionEvent e){
 225                 int[] indeces = list.getSelectedIndices();
 226                 for(int i = indeces.length - 1; i >= 0; i--){
 227                     listmodel.removeElementAt(indeces[i]);
 228                 }
 229                 list.getSelectionModel().clearSelection();
 230                 stigmata.setNeedToSaveSettings(true);
 231             }
 232         };
 233         final Action updateAction = new AbstractAction(){
 234             private static final long serialVersionUID = 852965501722574084L;
 235
 236             @Override
 237             public void actionPerformed(ActionEvent e){
 238                 editRule(list.getSelectedIndex());
 239             }
 240         };
 241         JButton addButton = GUIUtility.createButton(messages, "addwellknown", addAction);
 242         JButton removeButton = GUIUtility.createButton(messages, "removewellknown", removeAction);
 243         JButton updateButton = GUIUtility.createButton(messages, "updatewellknown", updateAction);
 244         removeAction.setEnabled(false);
 245         updateAction.setEnabled(false);
 246
 247         southPanel.add(Box.createHorizontalGlue());
 248         southPanel.add(addButton);
 249         southPanel.add(Box.createHorizontalGlue());
 250         southPanel.add(updateButton);
 251         southPanel.add(Box.createHorizontalGlue());
 252         southPanel.add(removeButton);
 253         southPanel.add(Box.createHorizontalGlue());
 254
 255         list.addMouseListener(new MouseAdapter(){
 256             @Override
 257             public void mouseClicked(MouseEvent e){
 258                 if(e.getClickCount() == 2){
 259                     editRule(list.getSelectedIndex());
 260                 }
 261             }
 262         });
 263         JPopupMenu popup = new JPopupMenu();
 264         popup.add(GUIUtility.createJMenuItem(messages, "addwellknown", addAction));
 265         popup.add(GUIUtility.createJMenuItem(messages, "updatewellknown", updateAction));
 266         popup.add(GUIUtility.createJMenuItem(messages, "removewellknown", removeAction));
 267
 268         list.addMouseListener(new PopupShowAction(popup));
 269         list.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
 270             @Override
 271             public void valueChanged(ListSelectionEvent arg0){
 272                 int[] indeces = list.getSelectedIndices();
 273                 removeAction.setEnabled(indeces != null && indeces.length > 0);
 274                 updateAction.setEnabled(indeces != null && indeces.length == 1);
 275             }
 276         });
 277
 278         return southPanel;
 279     }
 280
 281     private WellknownClassJudgeRule createOrUpdateRule(Messages messages, WellknownClassJudgeRule rule){
 282         JTextField text = new JTextField();
 283         text.setOpaque(true);
 284         GUIUtility.decorateJComponent(messages, text, "addwellknown.newrule.pattern");
 285         JCheckBox excludeCheck = new JCheckBox(messages.get("addwellknown.newrule.exclude.label"), false);
 286         GUIUtility.decorateJComponent(messages, excludeCheck, "addwellknown.newrule.exclude");
 287         JComboBox matchTypeComboBox = new JComboBox();
 288         for(Map.Entry<String, String> entry: matchTypeMap.entrySet()){
 289             matchTypeComboBox.addItem(entry.getValue());
 290         }
 291         JComboBox partTypeComboBox = new JComboBox();
 292         for(Map.Entry<String, String> entry: partTypeMap.entrySet()){
 293             partTypeComboBox.addItem(entry.getValue());
 294         }
 295         if(rule != null){
 296             text.setText(rule.getPattern());
 297             excludeCheck.setSelected(rule.isExclude());
 298             matchTypeComboBox.setSelectedItem(matchTypeMap.get(rule.getMatchType().name()));
 299             partTypeComboBox.setSelectedItem(partTypeMap.get(rule.getMatchPartType().name()));
 300         }
 301
 302         JPanel panel = new JPanel(new BorderLayout());
 303         panel.setOpaque(true);
 304         JPanel centerPanel = new JPanel(new FlowLayout());
 305
 306         centerPanel.add(partTypeComboBox);
 307         centerPanel.add(matchTypeComboBox);
 308
 309         panel.add(excludeCheck, BorderLayout.NORTH);
 310         panel.add(centerPanel, BorderLayout.CENTER);
 311         panel.add(text, BorderLayout.SOUTH);
 312
 313         int value = JOptionPane.showConfirmDialog(
 314             stigmata, panel, stigmata.getMessages().get("addwellknown.dialog.title"),
 315             JOptionPane.OK_CANCEL_OPTION
 316         );
 317         if(value == JOptionPane.OK_OPTION){
 318             String matchType = findType(matchTypeComboBox, matchTypeMap);
 319             String partType = findType(partTypeComboBox, partTypeMap);
 320             WellknownClassJudgeRule.MatchType match = null;
 321             WellknownClassJudgeRule.MatchPartType part = null;
 322             String pattern = text.getText();
 323             boolean excludeFlag = excludeCheck.isSelected();
 324
 325             if(matchType != null && partType != null){
 326                 match = WellknownClassJudgeRule.MatchType.valueOf(matchType);
 327                 part = WellknownClassJudgeRule.MatchPartType.valueOf(partType);
 328             }
 329
 330             if(match != null && partType != null && pattern != null && !pattern.equals("")){
 331                 return new WellknownClassJudgeRule(pattern, match, part, excludeFlag);
 332             }
 333         }
 334         return null;
 335     }
 336 }