001    /**
002     * Created by IntelliJ IDEA.
003     * User: Wei Wang
004     * Date: Apr 27, 2003
005     * Time: 5:48:17 PM
006     */
007    
008    package EVolve.util.phasedetectors.phasedetectorUI;
009    
010    import java.awt.Component;
011    import java.awt.FlowLayout;
012    import java.awt.event.ActionEvent;
013    import java.awt.event.ActionListener;
014    import java.util.ArrayList;
015    import java.util.HashMap;
016    import java.util.Iterator;
017    import java.util.StringTokenizer;
018    
019    import javax.swing.ImageIcon;
020    import javax.swing.JButton;
021    import javax.swing.JComboBox;
022    import javax.swing.JLabel;
023    import javax.swing.JScrollPane;
024    import javax.swing.JTextField;
025    import javax.swing.JToolBar;
026    
027    import EVolve.Scene;
028    import EVolve.util.phasedetectors.PhaseDetector;
029    import EVolve.visualization.AxesPanel;
030    import EVolve.visualization.Visualization;
031    import EVolve.visualization.XYViz.XYVisualization;
032    
033    public class PhaseDetectorToolBar extends JToolBar{
034        public static int NumberOfSharedOptions = 3;
035        private JButton buttonRefreshAppend, buttonRefreshNew, buttonClose, buttonUndo, buttonRedo;
036        private JButton buttonAddPhase, buttonRemovePhase;
037        private JButton buttonCopyPhase, buttonPastePhase;
038        private JComboBox comboOptions;
039    
040        private JButton buttonTriggerAppend, buttonTriggerNew;
041        private JButton buttonSetAppend, buttonSetNew;
042        private JLabel labelTriggerNoise, labelSetNoise;
043        private JTextField noiseTriggerTolerance, noiseSetTolerance;
044        private JLabel labelTriggerThreshold, labelSetThreshold;
045        private JTextField textTriggerThreshold, textSetThreshold;
046        private int noiseTriggerToler = 0, noiseSetToler = 2;
047        private float triggerThreshold = 0.8F, setThreshold = 0.05F;
048    
049        private HashMap controlsMap;
050        private PhaseDetector detector;
051        private String detectorName, entityTrigger, entitySet;
052        private Component commonControls[];
053        private Component appendCommandButtons[];
054    
055    
056        public PhaseDetectorToolBar() {
057            super("Phase detector setting");
058            controlsMap = new HashMap();
059            entityTrigger = "Phase Entity Trigger";
060            entitySet = "Phase Entity Set";
061            detector = null;
062            setPreferredSize(new java.awt.Dimension(850,28));
063            FlowLayout layout = new FlowLayout(FlowLayout.LEFT,2,-2);
064            layout.preferredLayoutSize(this);
065            setLayout(layout);
066            commonControls = createCommandButtons();
067            appendCommandButtons = createRefreshButtons();
068            createPhaseDetectorToolBar();
069            layout.layoutContainer(this);
070        }
071    
072        private void createPhaseDetectorToolBar() {
073            setRollover(true);
074    
075            comboOptions = new JComboBox();
076    
077            controlsMap.put(entityTrigger, createEntityTriggerButtons());
078            controlsMap.put(entitySet, createEntitySetButtons());
079            comboOptions.addItem(entityTrigger);
080            comboOptions.addItem(entitySet);
081    
082            comboOptions.addActionListener(new ActionListener() {
083                public void actionPerformed(ActionEvent e) {
084                    String item = (String)comboOptions.getSelectedItem();
085                    int number = getComponents().length;
086                    for (int i=number-1; i>=2; i--) {
087                        remove(i);
088                    }
089                    Component[] controls = (Component[])controlsMap.get(item);
090                    for (int i=0; i<controls.length; i++) {
091                        add(controls[i]);
092                    }
093                    for (int i=0; i<commonControls.length; i++) {
094                        add(commonControls[i]);
095                    }
096                }
097            });
098            comboOptions.setPreferredSize(new java.awt.Dimension(180,26));
099            add(comboOptions);
100            addSeparator();
101            comboOptions.setSelectedIndex(0);
102        }
103    
104        public void refresh() {
105            ArrayList vizList = Scene.getVisualizationManager().getVisualizationList();
106            for (int i=0; i<vizList.size(); i++) {
107                Visualization visual = (Visualization)vizList.get(i);
108                if (visual.isFreezed()) return;
109            }
110    
111            if (detector != null)
112                updateToolBarState(detector.getToolBarState());
113    
114            Visualization visual = Scene.getVisualizationManager().getActiveVisualization();
115            if ((visual == null) || (!(visual instanceof XYVisualization))) {
116                detector = null;
117            } else
118                detector = ((XYVisualization)visual).getPhaseDetector();
119    
120            controlsMap.remove(detectorName);
121    
122            comboOptions.removeAllItems();
123            if (detector != null) {
124                detectorName = detector.getName();
125                Component[] detectorControls = detector.createDetectorParamsControls();
126                Component[] all = new Component[detectorControls.length+appendCommandButtons.length];
127                for ( int i = 0; i<detectorControls.length; i++) {
128                    all[i] = detectorControls[i];
129                }
130                for ( int i = 0; i<appendCommandButtons.length; i++) {
131                    all[i+detectorControls.length] = appendCommandButtons[i];
132                }
133                controlsMap.put(detectorName,all);
134                comboOptions.addItem(detectorName);
135            } else {
136                detectorName = "";
137            }
138    
139            comboOptions.addItem(entityTrigger);
140            comboOptions.addItem(entitySet);
141    
142            if (detector != null) { //restore button/controls state
143                PhaseDetectorToolBarState state = detector.getToolBarState();
144                comboOptions.setSelectedIndex(state.selectedOption);
145                HashMap optionControlsMap = state.optionsControlState;
146                Iterator it = controlsMap.keySet().iterator();
147                while (it.hasNext()) {
148                    String key = (String)it.next();
149                    if ((key.equals(detectorName)) || (!optionControlsMap.containsKey(key))) continue;
150    
151                    Component[] controls = (Component[])controlsMap.get(key);
152                    boolean[] enableStates = (boolean[])optionControlsMap.get(key);
153                    for (int i=0; i<controls.length; i++) {
154                        controls[i].setEnabled(enableStates[i]);
155                    }
156                }
157            }
158    
159            enableButton(detector != null);
160            buttonClose.setEnabled(true);
161        }
162    
163        public void enableButton(boolean flag) {
164            comboOptions.setEnabled(flag);
165            for (int i=0; i<commonControls.length-1; i++) {
166                commonControls[i].setEnabled(flag);
167            }
168            Iterator it = controlsMap.keySet().iterator();
169            while (it.hasNext()) {
170                Component items[] = (Component[])controlsMap.get(it.next());
171                for (int i=0; i<items.length; i++) {
172                    items[i].setEnabled(flag);
173                }
174            }
175            boolean empty = Scene.getVisualizationManager().getPhaseOperation().clipboardIsEmpty();
176            if (buttonPastePhase.isEnabled()) {
177                buttonPastePhase.setEnabled(!empty);
178            }
179            if (flag == true) {
180                boolean undoable = Scene.getVisualizationManager().getPhaseOperation().undoable();
181                buttonUndo.setEnabled(undoable);
182                boolean redoable = Scene.getVisualizationManager().getPhaseOperation().redoable();
183                buttonRedo.setEnabled(redoable);
184            }
185        }
186    
187        public void updateVisualization(boolean cleanup, boolean append) {
188            Visualization visual = Scene.getVisualizationManager().getActiveVisualization();
189            if ((visual == null) || (!(visual instanceof XYVisualization)))
190                return ;
191    
192            AxesPanel canvas = (AxesPanel)((JScrollPane)visual.getPanel()).getViewport().getView();
193            PhaseDetector phaseDetector = ((XYVisualization)visual).getPhaseDetector();
194    
195            if (phaseDetector == null) return;
196    
197            phaseDetector.saveSetting();
198            if (cleanup) {
199                canvas.setPhases(null);
200            } else
201                phaseDetector.drawPhase(append);
202            canvas.repaint();
203        }
204    
205        public void updateToolBarState(PhaseDetectorToolBarState state) {
206            state.selectedOption = comboOptions.getSelectedIndex();
207            HashMap optionControlsMap = state.optionsControlState;
208            Iterator it = controlsMap.keySet().iterator();
209            while (it.hasNext()) {
210                String key = (String)it.next();
211                if (key.equals(detectorName)) continue;
212    
213                Component[] controls = (Component[])controlsMap.get(key);
214                boolean[] enableStates = null;
215                if (optionControlsMap.containsKey(key)) {
216                    enableStates = (boolean[])optionControlsMap.get(key);
217                } else {
218                    enableStates = new boolean[controls.length];
219                    optionControlsMap.put(key,enableStates);
220                }
221                for (int i=0; i<controls.length; i++) {
222                    enableStates[i] = controls[i].isEnabled();
223                }
224            }
225        }
226    
227        private Component[] createEntityTriggerButtons() {
228            buttonTriggerAppend = new JButton(new ImageIcon(Scene.getGifURL("trigger_append.gif")));
229            buttonTriggerAppend.setToolTipText("Append triggered phases to the current phase set");
230            buttonTriggerAppend.addActionListener(new ActionListener() {
231                public void actionPerformed(ActionEvent e) {
232                    try {
233                        noiseTriggerToler = Integer.parseInt(noiseTriggerTolerance.getText());
234                        triggerThreshold = Float.parseFloat(textTriggerThreshold.getText());
235                        Scene.getVisualizationManager().getPhaseOperation().triggerPhases(noiseTriggerToler, triggerThreshold, true);
236                    } catch (NumberFormatException exp) {
237                        Scene.showErrorMessage("Noise Tolerance must be an integer!");
238                    }
239                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
240                }
241            });
242            buttonTriggerAppend.setPreferredSize(new java.awt.Dimension(28,28));
243    
244            buttonTriggerNew = new JButton(new ImageIcon(Scene.getGifURL("trigger_new.gif")));
245            buttonTriggerNew.setToolTipText("Trigger phases and use them as a new phase set");
246            buttonTriggerNew.addActionListener(new ActionListener() {
247                public void actionPerformed(ActionEvent e) {
248                    try {
249                        noiseTriggerToler = Integer.parseInt(noiseTriggerTolerance.getText());
250                        triggerThreshold = Float.parseFloat(textTriggerThreshold.getText());
251                        Scene.getVisualizationManager().getPhaseOperation().triggerPhases(noiseTriggerToler, triggerThreshold, false);
252                    } catch (NumberFormatException exp) {
253                        Scene.showErrorMessage("Noise Tolerance must be an integer!");
254                    }
255                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
256                }
257            });
258            buttonTriggerNew.setPreferredSize(new java.awt.Dimension(28,28));
259    
260            labelTriggerNoise = new JLabel("Noise tolerance (intervals):");
261            noiseTriggerTolerance = new JTextField(String.valueOf(noiseTriggerToler));
262            labelTriggerThreshold = new JLabel("Threshold");
263            textTriggerThreshold = new JTextField(String.valueOf(triggerThreshold));
264            noiseTriggerTolerance.setColumns(2);
265            textTriggerThreshold.setColumns(3);
266    
267            Component[] returnVal = new Component[4];
268    
269            //returnVal[0] = labelTriggerNoise;
270            //returnVal[1] = noiseTriggerTolerance;
271            returnVal[0] = labelTriggerThreshold;
272            returnVal[1] = textTriggerThreshold;
273            returnVal[2] = buttonTriggerAppend;
274            returnVal[3] = buttonTriggerNew;
275            return returnVal;
276        }
277    
278        private Component[] createEntitySetButtons() {
279            Component[] returnVal = new Component[6];
280    
281            buttonSetAppend = new JButton(new ImageIcon(Scene.getGifURL("trigger_append.gif")));
282            buttonSetAppend.setToolTipText("Append phases to the current phase set");
283            buttonSetAppend.addActionListener(new ActionListener() {
284                public void actionPerformed(ActionEvent e) {
285                    try {
286                        noiseSetToler = Integer.parseInt(noiseSetTolerance.getText());
287                        setThreshold = Float.parseFloat(textSetThreshold.getText());
288                        Scene.getVisualizationManager().getPhaseOperation().entitySetPhases(noiseSetToler, setThreshold, true);
289                    } catch (NumberFormatException exp) {
290                        Scene.showErrorMessage("Noise Tolerance must be an integer!");
291                    }
292                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
293                }
294            });
295            buttonSetAppend.setPreferredSize(new java.awt.Dimension(28,28));
296    
297            buttonSetNew = new JButton(new ImageIcon(Scene.getGifURL("trigger_new.gif")));
298            buttonSetNew.setToolTipText("Set phases and use them as a new phase set");
299            buttonSetNew.addActionListener(new ActionListener() {
300                public void actionPerformed(ActionEvent e) {
301                    try {
302                        noiseSetToler = Integer.parseInt(noiseSetTolerance.getText());
303                        setThreshold = Float.parseFloat(textSetThreshold.getText());
304                        Scene.getVisualizationManager().getPhaseOperation().entitySetPhases(noiseSetToler, setThreshold, false);
305                    } catch (NumberFormatException exp) {
306                        Scene.showErrorMessage("Noise Tolerance must be an integer!");
307                    }
308                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
309                }
310            });
311            buttonSetNew.setPreferredSize(new java.awt.Dimension(28,28));
312    
313            labelSetNoise = new JLabel("Noise tolerance (intervals):");
314            noiseSetTolerance = new JTextField(String.valueOf(noiseSetToler));
315            labelSetThreshold = new JLabel("Threshold");
316            textSetThreshold = new JTextField(String.valueOf(setThreshold));
317            noiseSetTolerance.setColumns(2);
318            textSetThreshold.setColumns(3);
319    
320    
321            returnVal[0] = labelSetNoise;
322            returnVal[1] = noiseSetTolerance;
323            returnVal[2] = labelSetThreshold;
324            returnVal[3] = textSetThreshold;
325            returnVal[4] = buttonSetAppend;
326            returnVal[5] = buttonSetNew;
327            return returnVal;
328        }
329    
330        private Component[] createCommandButtons() {
331            Component returnVal[] = new Component[7];
332    
333            buttonClose = new JButton(new ImageIcon(Scene.getGifURL("close.gif")));
334            buttonClose.setToolTipText("Disable Phase Detector");
335            buttonClose.addActionListener(new ActionListener() {
336                public void actionPerformed(ActionEvent e) {
337                    Scene.getVisualizationManager().enablePhaseDetector(false);
338                    setVisible(false);
339                    updateVisualization(true, false);
340                    Scene.getUIManager().refreshToolBar();
341                }
342            });
343            buttonClose.setPreferredSize(new java.awt.Dimension(28,28));
344    
345            buttonCopyPhase = new JButton(new ImageIcon(Scene.getGifURL("copy.gif")));
346            buttonCopyPhase.setToolTipText("Copy phase in the current visualization");
347            buttonCopyPhase.addActionListener(new ActionListener() {
348                public void actionPerformed(ActionEvent e) {
349                    Scene.getVisualizationManager().getPhaseOperation().copyPhase();
350                    boolean empty = Scene.getVisualizationManager().getPhaseOperation().clipboardIsEmpty();
351                    buttonPastePhase.setEnabled(!empty);
352                }
353            });
354            buttonCopyPhase.setPreferredSize(new java.awt.Dimension(28,28));
355    
356            buttonPastePhase = new JButton(new ImageIcon(Scene.getGifURL("paste.gif")));
357            buttonPastePhase.setToolTipText("Paste phase to the current visualization");
358            buttonPastePhase.addActionListener(new ActionListener() {
359                public void actionPerformed(ActionEvent e) {
360                    Scene.getVisualizationManager().getPhaseOperation().pastePhase();
361                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
362                }
363            });
364            buttonPastePhase.setPreferredSize(new java.awt.Dimension(28,28));
365            buttonPastePhase.setEnabled(false);
366    
367            buttonUndo = new JButton(new ImageIcon(Scene.getGifURL("undo.gif")));
368            buttonUndo.setToolTipText("Undo");
369            buttonUndo.addActionListener(new ActionListener() {
370                public void actionPerformed(ActionEvent e) {
371                    Scene.getVisualizationManager().getPhaseOperation().undo();
372                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
373                    buttonRedo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().redoable());
374                }
375            });
376            buttonUndo.setPreferredSize(new java.awt.Dimension(28,28));
377            buttonUndo.setEnabled(false);
378    
379            buttonRedo = new JButton(new ImageIcon(Scene.getGifURL("redo.gif")));
380            buttonRedo.setToolTipText("Redo");
381            buttonRedo.addActionListener(new ActionListener() {
382                public void actionPerformed(ActionEvent e) {
383                    Scene.getVisualizationManager().getPhaseOperation().redo();
384                    buttonRedo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().redoable());
385                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
386                }
387            });
388            buttonRedo.setPreferredSize(new java.awt.Dimension(28,28));
389            buttonRedo.setEnabled(false);
390    
391            buttonAddPhase = new JButton(new ImageIcon(Scene.getGifURL("add.gif")));
392            buttonAddPhase.setToolTipText("Add phase manually");
393            buttonAddPhase.addActionListener(new ActionListener() {
394                public void actionPerformed(ActionEvent e) {
395                    Scene.getVisualizationManager().getPhaseOperation().add();
396                }
397            });
398            buttonAddPhase.setPreferredSize(new java.awt.Dimension(28,28));
399    
400            buttonRemovePhase = new JButton(new ImageIcon(Scene.getGifURL("remove.gif")));
401            buttonRemovePhase.setToolTipText("Remove phase manually");
402            buttonRemovePhase.addActionListener(new ActionListener() {
403                public void actionPerformed(ActionEvent e) {
404                    Scene.getVisualizationManager().getPhaseOperation().remove();
405                }
406            });
407            buttonRemovePhase.setPreferredSize(new java.awt.Dimension(28,28));
408    
409            returnVal[0] = buttonCopyPhase;
410            returnVal[1] = buttonPastePhase;
411            returnVal[2] = buttonAddPhase;
412            returnVal[3] = buttonRemovePhase;
413            returnVal[4] = buttonUndo;
414            returnVal[5] = buttonRedo;
415            returnVal[6] = buttonClose;
416    
417            return returnVal;
418        }
419    
420        private Component[] createRefreshButtons() {
421            Component[] returnVal = new Component[2];
422    
423            buttonRefreshAppend = new JButton(new ImageIcon(Scene.getGifURL("refresh_append.gif")));
424            buttonRefreshAppend.setToolTipText("Append detected phases to the current phase set");
425            buttonRefreshAppend.addActionListener(new ActionListener() {
426                public void actionPerformed(ActionEvent e) {
427                    updateVisualization(false, true);
428                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
429                }
430            });
431            buttonRefreshAppend.setPreferredSize(new java.awt.Dimension(28,28));
432    
433            buttonRefreshNew = new JButton(new ImageIcon(Scene.getGifURL("refresh_new.gif")));
434            buttonRefreshNew.setToolTipText("Use detected phases as a new phase set");
435            buttonRefreshNew.addActionListener(new ActionListener() {
436                public void actionPerformed(ActionEvent e) {
437                    updateVisualization(false, false);
438                    buttonUndo.setEnabled(Scene.getVisualizationManager().getPhaseOperation().undoable());
439                }
440            });
441            buttonRefreshNew.setPreferredSize(new java.awt.Dimension(28,28));
442    
443            returnVal[0] = buttonRefreshAppend;
444            returnVal[1] = buttonRefreshNew;
445    
446            return returnVal;
447        }
448    
449        public HashMap getToolbarParams() {
450            HashMap paramsState = new HashMap();
451            Iterator it = controlsMap.keySet().iterator();
452            while (it.hasNext()) {
453                String params = "";
454                Object key = it.next();
455                Component[] value = (Component[])controlsMap.get(key);
456                for (int i=0; i<value.length; i++) {
457                    if (value[i] instanceof JTextField) {
458                        params = params + ((JTextField)value[i]).getText() + ";";
459                    }
460                }
461                paramsState.put(key,params);
462            }
463            return paramsState;
464        }
465    
466        public void setToolbarParams(HashMap paramsState) {
467    
468            Iterator it = paramsState.keySet().iterator();
469    
470            while (it.hasNext()) {
471                Object key = it.next();
472                Component[] value = (Component[])controlsMap.get(key);
473                StringTokenizer params = new StringTokenizer((String)paramsState.get(key),";");
474                for (int i=0; i<value.length; i++) {
475                    if (value[i] instanceof JTextField) {
476                        ((JTextField)value[i]).setText(params.nextToken());
477                    }
478                }
479            }
480            revalidate();
481    
482        }
483    }