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

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