001    package net.sourceforge.mp3dings.preferences;
002    
003    /* Mp3dings - manage mp3 meta-information
004     * Copyright (C) 2003-2006 Moritz Ringler
005     * $Id: FieldSelectorPanel.java,v 1.13 2006/09/25 17:34:42 ringler Exp $
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.Dimension;
025    import java.awt.GraphicsEnvironment;
026    import java.awt.Insets;
027    import java.awt.Point;
028    import java.awt.Toolkit;
029    import java.awt.event.ActionEvent;
030    import java.awt.event.ActionListener;
031    import java.awt.event.MouseEvent;
032    import java.awt.event.MouseListener;
033    import java.util.ArrayList;
034    import java.util.Arrays;
035    import java.util.HashMap;
036    import java.util.Iterator;
037    import java.util.Collections;
038    import java.util.Comparator;
039    import java.util.List;
040    import java.util.Map;
041    import java.util.logging.Logger;
042    import java.util.prefs.Preferences;
043    import javax.swing.BorderFactory;
044    import javax.swing.DefaultListCellRenderer;
045    import javax.swing.DefaultListModel;
046    import javax.swing.JLabel;
047    import javax.swing.JList;
048    import javax.swing.JMenuItem;
049    import javax.swing.JPopupMenu;
050    import javax.swing.SwingUtilities;
051    import de.mospace.lang.Array;
052    import de.mospace.swing.JDoubleList;
053    import net.sourceforge.mp3dings.Field;
054    import net.sourceforge.mp3dings.Globals;
055    import net.sourceforge.mp3dings.MainFrame;
056    import net.sourceforge.mp3dings.utils.BeanSet;
057    
058    /** The PrefPanel that configures which fields are available in
059     * which table.
060     * @author Moritz Ringler
061     * @version $Revision: 1.13 $ ($Date: 2006/09/25 17:34:42 $)
062     **/
063    public class FieldSelectorPanel extends PrefPanel{
064        private static final Logger logger = Logger.getLogger(FieldSelectorPanel.class.getPackage().getName());
065        private int tabm;
066        private DefaultListModel left, right;
067        private JDoubleList jdl;
068        public final static int LEFT  = JDoubleList.LEFT;
069        public final static int RIGHT = JDoubleList.RIGHT;
070        Map filteredFields = new HashMap();
071        SimpleFieldFilterDialog sffdialog;
072        FieldFilterEditor ffeditor;
073        private Point mousePoint = null;
074    
075        /** Creates a new instance of this class.
076        * @param pref the preferences node associated with the new pref field
077        * @param name the display name of the new pref field
078        * @param tab the tab configured by this FieldSelector
079        **/
080        public FieldSelectorPanel(MainFrame owner, Preferences pref, String name, int tab, BeanSet filterset){
081            super(owner, pref, name);
082            tabm = tab;
083            //get available, allowed and active fields
084            Field[]   allowedFields   = getTabModel(tab).getAllowedFields();
085            Field[]   active          = loadActiveFields(getTabModel(tab).getPrefs());
086            Preferences prefFilters = getTabModel(tabm).getPrefs().node("filters");
087    
088            Field field;
089            FilteredField ff;
090            List nonActiveList = new ArrayList();
091            for(int i=0; i<allowedFields.length; i++){
092                field = allowedFields[i];
093                ff = FilteredField.load(prefFilters, field, filterset);
094                filterset.addChangeListener(ff);
095                filteredFields.put(field, ff);
096                nonActiveList.add(field);
097            }
098    
099    
100            //construct JDoubleList
101            jdl = new JDoubleList();
102            left = (DefaultListModel) jdl.getLeftList().getModel();
103            right = (DefaultListModel) jdl.getRightList().getModel();
104            //add active fields to right hand side.
105            for (int i=0; i<active.length; i++){
106                field = active[i];
107                Object ffo = filteredFields.get(field);
108                if(ffo != null){
109                    right.addElement(ffo);
110                    nonActiveList.remove(field);
111                } else {
112                    logger.severe("Field not found " + field + " in tab model " + getTabModel(tabm));
113                }
114            }
115    
116            //add non-active fields to left hand side.
117            Collections.sort(nonActiveList, new Comparator(){
118                    public int compare(Object o1, Object o2){
119                        return ((Field) o1).longname().compareTo(
120                               ((Field) o2).longname());
121                    }
122            });
123            Iterator it = nonActiveList.iterator();
124            while(it.hasNext()){
125                left.addElement(filteredFields.get(it.next()));
126            }
127    
128            jdl.setSymmetric(true);
129            jdl.getRightList().addMouseListener(new ContextMenu());
130    
131            /* Install a cell renderer that paints filtered fields in the
132               filtered column color */
133            jdl.getRightList().setCellRenderer(new DefaultListCellRenderer(){
134                public Component getListCellRendererComponent(JList list,
135                Object value, int index, boolean isSelected,
136                boolean cellHasFocus){
137                    Component c = super.getListCellRendererComponent(
138                    list, value, index, isSelected, cellHasFocus);
139                    if(value != null && ((FilteredField) value).isFiltered()){
140                        c.setForeground(Globals.getColor(Globals.COLOR_FILTERED));
141                    }
142                    return c;
143                }
144            });
145    
146            //add title
147            JLabel text = new JLabel(
148                    Globals.getString("PREFS_FIELDS_TEXT"));
149            text.setBorder(BorderFactory.createEmptyBorder(7,2,10,2));
150            add(text, BorderLayout.NORTH);
151            /* add JDoubleList */
152            add(jdl, BorderLayout.CENTER);
153            //immobilize persistent fields
154            Field[] persistent = getTabModel(tab).getPersistentFields();
155            for (int i=0; i<persistent.length; i++){
156                setPersistent(persistent[i], true);
157            }
158    
159            sffdialog = new SimpleFieldFilterDialog(this, filterset);
160            ffeditor = new FieldFilterEditor(this, filterset);
161        }
162    
163        /** Load active fields from a Preferences node.
164         * @param p the preferences node to evaluate
165         * @return an integer array containing the active fields from p in arbitrary order
166         **/
167        public static Field[] loadActiveFields(Preferences p){
168            String pString   = p.get("activeFields", "");
169            if (pString.equals("")){
170                return new Field[]{};
171            }
172            String[] pActive = pString.split(";");
173            final int m = pActive.length;
174            List afields = new ArrayList(m);
175            Field field = null;
176            for (int i=0; i<m; i++){
177                field = Field.forName(pActive[i]);
178                if(field != null){
179                    afields.add(field);
180                } else {
181                    logger.severe("Unknown active field: " + pActive[i]);
182                }
183            }
184            return (Field[]) afields.toArray(new Field[afields.size()]);
185        }
186    
187        /** Saves this panel to the associated preferences node. **/
188        public void save(){
189            int n = right.size();
190            Field[] p = new Field[n];
191            for (int i=0; i<n; i++){
192                if(right.get(i) != null){
193                    p[i] = ((FilteredField) right.get(i)).getField();
194                } else {
195                                    logger.severe("null found in active field list at index " + i);
196                        }
197            }
198            Preferences ppref = getTabModel(tabm).getPrefs();
199            ppref.put("activeFields",Array.join(p,';'));
200            ppref = ppref.node("filters");
201    
202            Iterator it = filteredFields.keySet().iterator();
203            while(it.hasNext()){
204                ((FilteredField) filteredFields.get(it.next())).save(ppref);
205            }
206        }
207    
208        /** Sets whether a given field must always be present in the associated tab.
209        * @param field the field to make (non-)persistent
210        **/
211        public void setPersistent(Field field, boolean persist){
212            Object[] elements = right.toArray();
213            FilteredField li;
214            for (int j=0; j<elements.length; j++){
215                li = (FilteredField) elements[j];
216                if (li.getField() == field){
217                    li.setMovable(!persist);
218                    break;
219                }
220            }
221        }
222    
223        private class ContextMenu extends JPopupMenu implements MouseListener, ActionListener{
224            Dimension mySize;
225            Point screen;
226            int[] selection;
227            JMenuItem addFilters;
228            JMenuItem removeFilters;
229            JMenuItem editFilters;
230    
231            public ContextMenu(){
232                Toolkit tk = Toolkit.getDefaultToolkit();
233                Dimension scr = tk.getScreenSize();
234                Insets ins = tk.getScreenInsets(
235                GraphicsEnvironment.getLocalGraphicsEnvironment()
236                .getDefaultScreenDevice().getDefaultConfiguration());
237                screen = new Point(scr.width-ins.right,scr.height-ins.bottom);
238    
239                init();
240    
241                pack();
242                mySize = this.getPreferredSize();
243            }
244    
245            public void init(){
246                addFilters = new JMenuItem(Globals.getString("ADD_FILTERS"));
247                removeFilters = new JMenuItem(Globals.getString("REMOVE_FILTERS"));
248                editFilters = new JMenuItem(Globals.getString("EDIT_FILTERS"));
249    
250                addFilters.addActionListener(this);
251                removeFilters.addActionListener(this);
252                editFilters.addActionListener(this);
253    
254                add(editFilters);
255                add(addFilters);
256                add(removeFilters);
257            }
258    
259            private FilteredField[] getSelectedFields(){
260                FilteredField[] result;
261                if(selection == null){
262                    result = null;
263                } else {
264                    JList rlist = jdl.getRightList();
265                    result = new FilteredField[selection.length];
266                    for(int i=0; i<selection.length; i++){
267                        result[i] = ((FilteredField) right.getElementAt(selection[i]));
268                    }
269                }
270                return result;
271            }
272    
273            public void actionPerformed(ActionEvent e){
274                FilteredField[] fields = getSelectedFields();
275                Object source = e.getSource();
276                if(source == addFilters){
277                    addFilters(fields, mousePoint);
278                } else if( source == removeFilters){
279                    removeFilters(fields, mousePoint);
280                } else if( source == editFilters){
281                    editFilters(fields, mousePoint);
282                }
283            }
284    
285            private void addFilters(FilteredField[] fields, Point origin){
286                Object[] add = sffdialog.showAddFilterDialog(fields, origin);
287                List rm = Arrays.asList(add);
288                for(int i=0; i<fields.length; i++){
289                    fields[i].getFilters().addAll(rm);
290                }
291                /* repaint the list so that the foreground color
292                 * of the fields we have edited is updated */
293                jdl.getRightList().repaint();
294            }
295    
296            private void removeFilters(FilteredField[] fields, Point origin){
297                Object[] remove = sffdialog.showRemoveFilterDialog(fields, origin);
298                List rm = Arrays.asList(remove);
299                for(int i=0; i<fields.length; i++){
300                    fields[i].getFilters().removeAll(rm);
301                }
302                /* repaint the list so that the foreground color
303                 * of the fields we have edited is updated */
304                jdl.getRightList().repaint();
305            }
306    
307            private void editFilters(FilteredField[] fields, Point origin){
308                Object[] newFilters = ffeditor.showDialog(fields[0], origin);
309                if(newFilters != null){
310                    fields[0].setFilters(Arrays.asList(newFilters));
311                }
312                /* repaint the list so that the foreground color
313                 * of the fields we have edited is updated */
314                jdl.getRightList().repaint();
315                //System.out.println("edit filters not implemented");
316            }
317    
318            /** The PopupListener that triggers this ContextMenu. **/
319            public void mousePressed(MouseEvent e) {
320                maybeShowPopup(e);
321            }
322    
323            public void mouseReleased(MouseEvent e) {
324                maybeShowPopup(e);
325            }
326    
327            private void maybeShowPopup(MouseEvent e) {
328                if (!e.isPopupTrigger()) {
329                    return;
330                }
331    
332                JList rlist = jdl.getRightList();
333    
334                selection = rlist.getSelectedIndices();
335    
336                //assure that we have a selection or return
337                int mouseIndex = rlist.locationToIndex(e.getPoint());
338                if(mouseIndex != -1){
339                    rlist.addSelectionInterval(mouseIndex, mouseIndex);
340                }
341                selection = rlist.getSelectedIndices();
342                if(selection.length == 0){
343                    return;
344                }
345                editFilters.setVisible(selection.length == 1);
346    
347                Point scr = (Point) screen.clone();
348                SwingUtilities.convertPointFromScreen(scr,jdl.getRightList());
349                show(e.getComponent(),
350                (int) Math.min(e.getX(),scr.getX()-mySize.width),
351                (int) Math.min(e.getY(),scr.getY()-mySize.height));
352                mousePoint = e.getPoint();
353                mousePoint.x = (int) (jdl.getRightList().getSize().width * 0.75);
354                SwingUtilities.convertPointToScreen(mousePoint, jdl.getRightList());
355            }
356    
357            public void mouseEntered(MouseEvent e){}
358    
359            public void mouseExited(MouseEvent e){}
360    
361            public void mouseClicked(MouseEvent e){}
362    
363        }
364    }