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