001    package net.sourceforge.mp3dings.filter;
002    
003    /* Mp3dings - manage mp3 meta-information
004     * Copyright (C) 2003 Moritz Ringler
005     * $Id: StringReplacerCustomizer.java 68 2007-10-24 21:27:46Z ringler $
006     *
007     * This program is free software; you can redistribute it and/or
008     * modify it under the terms of the GNU General Public License
009     * as published by the Free Software Foundation; either version 2
010     * of the License, or (at your option) any later version.
011     *
012     * This program is distributed in the hope that it will be useful,
013     * but WITHOUT ANY WARRANTY; without even the implied warranty of
014     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
015     * GNU General Public License for more details.
016     *
017     * You should have received a copy of the GNU General Public License
018     * along with this program; if not, write to the Free Software
019     * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
020     */
021    
022    import java.awt.BorderLayout;
023    import java.awt.Component;
024    import java.awt.Container;
025    import java.awt.FlowLayout;
026    import java.awt.Font;
027    import java.awt.GridLayout;
028    import java.awt.Insets;
029    import java.awt.event.ActionEvent;
030    import java.awt.event.ActionListener;
031    import java.awt.event.FocusAdapter;
032    import java.awt.event.FocusEvent;
033    import java.awt.event.FocusListener;
034    import java.awt.event.WindowEvent;
035    import java.io.BufferedReader;
036    import java.io.File;
037    import java.io.FileInputStream;
038    import java.io.IOException;
039    import java.io.InputStreamReader;
040    import java.util.HashMap;
041    import java.util.Map;
042    import java.util.prefs.Preferences;
043    import java.util.regex.PatternSyntaxException;
044    import javax.swing.AbstractAction;
045    import javax.swing.Action;
046    import javax.swing.BorderFactory;
047    import javax.swing.Box;
048    import javax.swing.DefaultComboBoxModel;
049    import javax.swing.DefaultListCellRenderer;
050    import javax.swing.JButton;
051    import javax.swing.JFileChooser;
052    import javax.swing.JFrame;
053    import javax.swing.JLabel;
054    import javax.swing.JList;
055    import javax.swing.JOptionPane;
056    import javax.swing.JPanel;
057    import javax.swing.JScrollPane;
058    import javax.swing.JTextField;
059    import javax.swing.KeyStroke;
060    import javax.swing.ListSelectionModel;
061    import javax.swing.event.ListSelectionEvent;
062    import javax.swing.event.ListSelectionListener;
063    import de.mospace.swing.icon.ArrowIcon;
064    import de.mospace.swing.icon.DoubleArrowIcon;
065    import net.sourceforge.mp3dings.Globals;
066    import net.sourceforge.mp3dings.utils.AbstractBeanCustomizer;
067    import net.sourceforge.mp3dings.utils.Bean;
068    
069    /**
070     * The customizer class for string replacer filters.
071     * @author Moritz Ringler
072     * @version $Revision: 68 $ ($Date: 2007-10-24 23:27:46 +0200 (Mi, 24 Okt 2007) $)
073     * @see StringReplacer
074     */
075    public class StringReplacerCustomizer extends AbstractBeanCustomizer{
076        private JTextField replace, with;
077        private JList rules;
078        private JPanel ui;
079        private Map ruleActions;
080        //private Map moveActions = new HashMap();
081        private final static String DELETE = "DELETE";
082        private final static String CHANGE = "CHANGE";
083        private final static String NEW = "NEW";
084        private final static String UP = "UP";
085        private final static String DOWN = "DOWN";
086        private final static char ARROW = '\u2192';
087    
088        /* CONSTRUCTORS */
089    
090        public StringReplacerCustomizer(StringReplacer bean){
091            super(bean);
092            rules = new JList(new DefaultComboBoxModel(bean.getRuleList()));
093            getUI();
094        }
095    
096        public StringReplacerCustomizer(){
097            this(new StringReplacer());
098        }
099    
100        /* BEAN CUSTOMIZER METHODS */
101    
102        public void setModel(Bean b){
103            if(!(bean instanceof StringReplacer)){
104                throw new IllegalArgumentException("Model is not a StringReplacer.");
105            }
106            super.setModel(b);
107            rules.setModel(new DefaultComboBoxModel(((StringReplacer) b).getRuleList()));
108            rules.repaint();
109        }
110    
111        public Component getUI(){
112            if(ui == null){
113                JPanel jui = new JPanel();
114                jui.setLayout(new BorderLayout());
115                jui.setBorder(BorderFactory.createEmptyBorder(5,15,5,5));
116    
117                //Modifiers
118                jui.add(makeModifierControls(), BorderLayout.NORTH);
119    
120                //Rule List
121                jui.add(makeRuleList(), BorderLayout.CENTER);
122    
123                //Move Buttons
124                jui.add(makeMoveButtons(), BorderLayout.EAST);
125    
126                //Rule Editor
127                jui.add(makeRuleEditor(), BorderLayout.SOUTH);
128                ui = jui;
129            }
130            return ui;
131        }
132    
133        /* UI elements */
134    
135        private Action getRuleAction(String which){
136            if(ruleActions == null){
137                ruleActions = new HashMap();
138                ruleActions.put(NEW, new AbstractAction(Globals.getString(NEW)){
139                    public void actionPerformed(ActionEvent e){
140                        newRule();
141                    }
142                });
143                ruleActions.put(DELETE, new AbstractAction(Globals.getString(DELETE)){
144                    public void actionPerformed(ActionEvent e){
145                        deleteSelectedRule();
146                    }
147                });
148                ruleActions.put(CHANGE, new AbstractAction(Globals.getString(CHANGE)){
149                    public void actionPerformed(ActionEvent e){
150                        changeSelectedRule();
151                    }
152                });
153                ruleActions.put(UP, new AbstractAction(){
154                    public void actionPerformed(ActionEvent e){
155                        int i = rules.getSelectedIndex();
156                        if(i>0){
157                            rules.setSelectedIndex(i-1);
158                        }
159                    }
160                });
161                ruleActions.put(DOWN, new AbstractAction(){
162                    public void actionPerformed(ActionEvent e){
163                        int i = rules.getSelectedIndex()+1;
164                        if(i<rules.getModel().getSize()){
165                            rules.setSelectedIndex(i);
166                        }
167                    }
168                });
169            }
170            return (Action) ruleActions.get(which);
171        }
172    
173        private Component makeRuleList(){
174            rules.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
175            rules.addListSelectionListener(new ListSelectionListener(){
176                public void valueChanged(ListSelectionEvent e){
177                    if(!e.getValueIsAdjusting()){
178                        showSelectedRuleInEditor();
179                    }
180                }
181            });
182            rules.setCellRenderer(new DefaultListCellRenderer(){
183                String[] buff = new String[2];
184                private boolean changeFont = true;
185                private Font myFont;
186    
187                public Component getListCellRendererComponent(JList list,
188                        Object value, int index, boolean isSelected,
189                        boolean cellHasFocus){
190                    buff = ((StringReplacer) getModel()).ruleToStrings((Object[]) value, buff);
191                    Component c = super.getListCellRendererComponent(list,
192                            buff[0] + ARROW + buff[1],
193                            index,
194                            isSelected,
195                            cellHasFocus);
196    
197                    /* install a font that can display the ARROW */
198                    if(changeFont){
199    
200                        /* if we have not been here before look for a
201                           suitable font */
202                        if(myFont == null){
203    
204                            /* this is the default font installed by the LAF */
205                            Font f = c.getFont();
206    
207                            /* get a font that will deisplay the ARROW */
208                            myFont = de.mospace.swing.GLOBALS.getSuitableFont(f, new char[]{ARROW});
209    
210                            if(f == myFont){
211    
212                                /* the default font does the job
213                                or we don't have a suitable font */
214                                changeFont = false;
215                            }
216    
217                        }
218    
219                        c.setFont(myFont);
220                    }
221                    return c;
222                }
223    
224            });
225            rules.getInputMap().put(KeyStroke.getKeyStroke(DELETE), DELETE);
226            rules.getActionMap().put(DELETE, getRuleAction(DELETE));
227            return new JScrollPane(rules);
228        }
229    
230        private Component makeMoveButtons(){
231            JPanel moveButtons = new JPanel();
232            final JButton moveUp    = new JButton(
233                    new ArrowIcon(ArrowIcon.DIRECTION_UP));
234            final JButton moveDown  = new JButton(
235                    new ArrowIcon(ArrowIcon.DIRECTION_DOWN));
236            final JButton moveStart = new JButton(
237                    new DoubleArrowIcon(DoubleArrowIcon.DIRECTION_UP));
238            final JButton moveEnd   = new JButton(
239                    new DoubleArrowIcon(DoubleArrowIcon.DIRECTION_DOWN));
240            final JButton[] buttons = new JButton[]{
241                moveStart,
242                moveUp,
243                moveDown,
244                moveEnd
245            };
246            ActionListener moveAL = new ActionListener(){
247                public void actionPerformed(ActionEvent e){
248                    JButton src = (JButton) e.getSource();
249                    int i = rules.getMinSelectionIndex();
250                    if (src == moveUp){
251                        moveSelectedRule(i - 1);
252                    } else if (src == moveDown){
253                        moveSelectedRule(i + 1);
254                    } else if (src == moveStart){
255                        moveSelectedRule(0);
256                    } else if (src == moveEnd){
257                        moveSelectedRule(rules.getModel().getSize()-1);
258                    }
259                }
260            };
261    
262            Insets buttonInsets = new Insets(0,1,1,1);
263            moveButtons.setLayout(new GridLayout(4,1,2,2));
264            for (int i=0; i<buttons.length; i++){
265                buttons[i].setMargin(buttonInsets);
266                buttons[i].addActionListener(moveAL);
267                moveButtons.add(buttons[i]);
268            }
269            return moveButtons;
270        }
271    
272        private Component makeModifierControls(){
273            Box mod = Box.createHorizontalBox();
274            mod.add(getPropertyEditor("regExp",new Object[]{Globals.getString("REG_EXP")}));
275            mod.add(getPropertyEditor("caseSensitive",new Object[]{Globals.getString("CASE_SENSITIVE")}));
276            mod.add(getPropertyEditor("wordMatch",new Object[]{Globals.getString("MATCH_WORD")}));
277            return mod;
278        }
279    
280        private Component makeRuleEditor(){
281            String[] labels = Globals.getStringArray("RULESET_EDITOR_LABELS");
282            replace = new JTextField(5);
283            with = new JTextField(5);
284            FocusListener fl = new FocusAdapter(){
285                public void focusGained(FocusEvent e){
286                    ((JTextField) e.getSource()).selectAll();
287                }
288            };
289            replace.addFocusListener(fl);
290            with.addFocusListener(fl);
291    
292            JPanel ruleEditor = new JPanel();
293            ruleEditor.setLayout(new FlowLayout(FlowLayout.LEFT));
294            ruleEditor.add(new JLabel(labels[6]));
295            ruleEditor.add(replace);
296            ruleEditor.add(new JLabel(labels[7]));
297            ruleEditor.add(with);
298    
299            ruleEditor.setFocusCycleRoot(true);
300    
301            JTextField[] jtf = new JTextField[]{replace, with};
302            for (int i=0; i<jtf.length; i++){
303                jtf[i].getInputMap().put(KeyStroke.getKeyStroke("alt ENTER"), CHANGE);
304                jtf[i].getActionMap().put(CHANGE, getRuleAction(CHANGE));
305    
306                jtf[i].getInputMap().put(KeyStroke.getKeyStroke("ENTER"), NEW);
307                jtf[i].getActionMap().put(NEW, getRuleAction(NEW));
308    
309                jtf[i].getInputMap().put(KeyStroke.getKeyStroke(UP), UP);
310                jtf[i].getActionMap().put(UP, getRuleAction(UP));
311    
312                jtf[i].getInputMap().put(KeyStroke.getKeyStroke(DOWN), DOWN);
313                jtf[i].getActionMap().put(DOWN, getRuleAction(DOWN));
314            }
315    
316            JPanel editorButtons = new JPanel(new GridLayout(1,2,0,2));
317            JButton b = new JButton(getRuleAction(NEW));
318            b.setToolTipText("Enter");
319            editorButtons.add(b);
320            b = new JButton(getRuleAction(CHANGE));
321            b.setToolTipText("Alt Enter");
322            editorButtons.add(b);
323            b = new JButton(getRuleAction(DELETE));
324            b.setToolTipText("Del");
325            editorButtons.add(b);
326            editorButtons.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
327            b = new JButton(new AbstractAction(Globals.getString("PARSE_FILE")){
328                public void actionPerformed(ActionEvent e){
329                    JFileChooser jfc = new JFileChooser();
330                    jfc.setFileSelectionMode(JFileChooser.FILES_ONLY);
331                    int status = jfc.showOpenDialog(getUI());
332                    if(status == JFileChooser.APPROVE_OPTION){
333                        try{
334                            parseFile(jfc.getSelectedFile(), "\t");
335                        } catch (IOException ex){
336                            JOptionPane.showMessageDialog(
337                                ui, ex.getLocalizedMessage(),
338                                Globals.getString("PARSE_FILE"),
339                                JOptionPane.WARNING_MESSAGE);
340                        }
341                    }
342                }
343            });
344            b.setToolTipText(Globals.getString("STRING_REPLACER_PARSE_FILE_TT"));
345            editorButtons.add(b);
346    
347            JPanel ruleControls = new JPanel();
348            ruleControls.setLayout(new BorderLayout());
349            ruleControls.add(ruleEditor, BorderLayout.CENTER);
350            ruleControls.add(editorButtons, BorderLayout.SOUTH);
351    
352            return ruleControls;
353        }
354    
355        private void parseFile(File f, String sep) throws IOException{
356            BufferedReader in = null;
357            try{
358                in = new BufferedReader(
359                        new InputStreamReader(new FileInputStream(f), "UTF-8"));
360                String line = in.readLine();
361                String[] tokens = null;
362                while (line != null){
363                    tokens = line.split(sep);
364                    if(tokens.length >= 2){
365                        newRule(tokens[0], tokens[1]);
366                    }
367                    line = in.readLine();
368                }
369            } finally {
370                if(in != null){
371                    in.close();
372                }
373            }
374        }
375    
376        private void deleteSelectedRule(){
377            int i = rules.getSelectedIndex();
378            if (i == -1 || i >= rules.getModel().getSize()){
379                return;
380            }
381            DefaultComboBoxModel rm = (DefaultComboBoxModel) rules.getModel();
382            rm.removeElementAt(i);
383            if(i < rules.getModel().getSize()){
384                rules.setSelectedIndex(i);
385            } else if (i != 0){
386                rules.setSelectedIndex(i - 1);
387            }
388            rules.repaint();
389        }
390    
391        private void changeSelectedRule(){
392            int i = rules.getSelectedIndex();
393            if (i == -1 || i >= rules.getModel().getSize()){
394                return;
395            }
396            try{
397                StringReplacer sr = (StringReplacer) getModel();
398                sr.replaceRule(replace.getText(), with.getText(), i);
399            } catch (PatternSyntaxException ex){
400                JOptionPane.showMessageDialog(ui, ex.getLocalizedMessage(), 
401                        "PatternSyntaxException",
402                        JOptionPane.WARNING_MESSAGE);
403            }
404            rules.repaint();
405        }
406    
407        private void showSelectedRuleInEditor(){
408            clearRuleEditor();
409            int i = rules.getSelectedIndex();
410            if(i == -1 || i >= rules.getModel().getSize()){
411                return;
412            }
413            rules.ensureIndexIsVisible(i);
414            String[] rule = ((StringReplacer) getModel()).getRule(i);
415            replace.setText(rule[0]);
416            with.setText(rule[1]);
417        }
418    
419        private void clearRuleEditor(){
420            replace.setText("");
421            with.setText("");
422        }
423    
424        private void newRule(String a, String b){
425            String aa = (a.equals("") || (a.indexOf(ARROW) >= 0)) ? "a" : a;
426            String bb = (b.indexOf(ARROW) >= 0)? "a" : b;
427            DefaultComboBoxModel rm = (DefaultComboBoxModel) rules.getModel();
428            try{
429                rm.addElement(new Object[]{((StringReplacer) getModel()).compile(aa), bb});
430            } catch (PatternSyntaxException ex){
431                JOptionPane.showMessageDialog(getUI(),ex.getMessage());
432            }
433            rules.setSelectedIndex(rm.getSize()-1);
434            showSelectedRuleInEditor();
435            rules.repaint();
436        }
437    
438        private void newRule(){
439            newRule(replace.getText(), with.getText());
440        }
441    
442    
443        private void moveSelectedRule(int newindex){
444            int i = rules.getSelectedIndex();
445            if (i == -1 || i >= rules.getModel().getSize()){
446                return;
447            }
448            clearRuleEditor();
449            DefaultComboBoxModel rm = (DefaultComboBoxModel) rules.getModel();
450            Object o = rm.getElementAt(i);
451            rm.removeElementAt(i);
452            rm.insertElementAt(o, newindex);
453            rules.setSelectedIndex(newindex);
454        }
455    
456        public static void main (String[] argv){
457            final Preferences pref = Preferences.userNodeForPackage(StringReplacerCustomizer.class);
458            StringReplacer filter = (StringReplacer) StringReplacer.load(pref ,"test_srb");
459            final StringReplacer xfilter = (filter == null)
460                ? new StringReplacer()
461                : filter ;
462            JFrame frame = new JFrame(){
463                protected void processWindowEvent(WindowEvent e) {
464                    xfilter.save(pref, "test_srb");
465                    super.processWindowEvent(e);
466                    if (e.getID() == WindowEvent.WINDOW_CLOSING) {
467                        System.exit(0);
468                    }
469                }
470            };
471            frame.add((new StringReplacerCustomizer(xfilter)).getUI());
472            frame.pack();
473            frame.setVisible(true);
474        }
475    
476    }