← Back to branch summary

~ubuntu-branches/debian/sid/geogebra/sid

« back to all changes in this revision

Viewing changes to geogebra/gui/toolbar/ToolbarConfigPanel.java

  • Committer: Package Import Robot
  • Author(s): Giovanni Mascellani
  • Date: 2012-01-10 11:37:41 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120110113741-satwohsd4de4ite1
Tags: 4.0.19.0+dfsg1-1
http://bugs.debian.org/649893
https://launchpad.net/bugs/893007
* New upstream version (closes: #649893).
* Update dependency: icedtea-plugin -> icedtea-netx-common (LP: #893007).
* New thumbnailer configuration compatible with Gnome 3.
* Package building is now managed by javahelper instead of upstream
  build.xml.

Show diffs side-by-side

added added

removed removed

Lines of Context:
geogebra/gui/toolbar/ToolbarConfigPanel.java
1
 
/* 
2
 
GeoGebra - Dynamic Mathematics for Everyone
3
 
http://www.geogebra.org
4
 
 
5
 
This file is part of GeoGebra.
6
 
 
7
 
This program is free software; you can redistribute it and/or modify it 
8
 
under the terms of the GNU General Public License as published by 
9
 
the Free Software Foundation.
10
 
 
11
 
*/
12
 
 
13
 
package geogebra.gui.toolbar;
14
 
import geogebra.main.Application;
15
 
 
16
 
import java.awt.BorderLayout;
17
 
import java.awt.Dimension;
18
 
import java.awt.event.ActionEvent;
19
 
import java.util.Enumeration;
20
 
import java.util.Vector;
21
 
 
22
 
import javax.swing.Box;
23
 
import javax.swing.BoxLayout;
24
 
import javax.swing.JButton;
25
 
import javax.swing.JList;
26
 
import javax.swing.JPanel;
27
 
import javax.swing.JScrollPane;
28
 
import javax.swing.JTree;
29
 
import javax.swing.ListSelectionModel;
30
 
import javax.swing.border.EmptyBorder;
31
 
import javax.swing.border.TitledBorder;
32
 
import javax.swing.tree.DefaultMutableTreeNode;
33
 
import javax.swing.tree.DefaultTreeModel;
34
 
import javax.swing.tree.TreePath;
35
 
import javax.swing.tree.TreeSelectionModel;
36
 
 
37
 
/**
38
 
 * Toolbar configuration panel.
39
 
 *  
40
 
 * @author Markus Hohenwarter, based on a dialog from geonext.de
41
 
 *
42
 
 */
43
 
public class ToolbarConfigPanel extends javax.swing.JPanel implements java.awt.event.ActionListener, javax.swing.event.TreeExpansionListener {  
44
 
        
45
 
        private static final int SCROLL_PANEL_WIDTH = 300;
46
 
        private static final int SCROLL_PANEL_HEIGHT = 400;
47
 
        
48
 
        public JButton insertButton;
49
 
        public JButton moveUpButton;
50
 
        public JButton moveDownButton;
51
 
        public JButton deleteButton;
52
 
        public JTree tree;
53
 
        JScrollPane configScrollPane;
54
 
        JScrollPane modeScrollPane;
55
 
        JScrollPane iconScrollPane;
56
 
        JPanel selectionPanel;
57
 
        JList toolList; 
58
 
        int selectedRow;        
59
 
        Application app;        
60
 
        
61
 
        public ToolbarConfigPanel(Application app) {
62
 
                super();        
63
 
                this.app = app;                 
64
 
                
65
 
                selectionPanel = new JPanel();
66
 
                selectionPanel.setLayout(new BorderLayout(5, 5));
67
 
                selectionPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
68
 
                setLayout(new BorderLayout(5, 5));
69
 
                                
70
 
                tree = generateTree();
71
 
                setToolBarString(app.getGuiManager().getToolBarDefinition());   
72
 
                
73
 
                configScrollPane = new JScrollPane(tree);
74
 
                configScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
75
 
                configScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
76
 
                //configScrollPane.setSize(150, 150);           
77
 
                JPanel scrollSpacePanel = new JPanel();
78
 
                scrollSpacePanel.setLayout(new BorderLayout(0, 0));
79
 
                scrollSpacePanel.setBorder(new EmptyBorder(3, 5, 3, 5));
80
 
                scrollSpacePanel.add(configScrollPane, BorderLayout.CENTER); //
81
 
                JPanel scrollPanel = new JPanel();
82
 
                scrollPanel.setLayout(new BorderLayout(0, 0));
83
 
                scrollPanel.setBorder(new TitledBorder(app.getMenu("Toolbar")));
84
 
                scrollPanel.add(scrollSpacePanel, BorderLayout.CENTER);
85
 
                                
86
 
                scrollPanel.setPreferredSize(new Dimension(SCROLL_PANEL_WIDTH, SCROLL_PANEL_HEIGHT));
87
 
                //
88
 
                selectionPanel.add(scrollPanel, BorderLayout.WEST);
89
 
                //
90
 
                
91
 
                JPanel buttonPanel = new JPanel();
92
 
                buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.Y_AXIS));
93
 
                buttonPanel.add(Box.createVerticalGlue());
94
 
                
95
 
                insertButton = new JButton("< " + app.getPlain("Insert"));              
96
 
                insertButton.addActionListener(this);
97
 
                insertButton.setAlignmentX(CENTER_ALIGNMENT);
98
 
                buttonPanel.add(insertButton);
99
 
                buttonPanel.add(Box.createVerticalStrut(10));
100
 
                
101
 
                deleteButton = new javax.swing.JButton(app.getPlain("Remove") + " >");          
102
 
                deleteButton.addActionListener(this);
103
 
                deleteButton.setAlignmentX(CENTER_ALIGNMENT);
104
 
                buttonPanel.add(deleteButton);          
105
 
                
106
 
                buttonPanel.add(Box.createVerticalGlue());
107
 
                selectionPanel.add(buttonPanel, BorderLayout.CENTER);
108
 
                
109
 
                
110
 
                
111
 
                //              
112
 
                JPanel upDownPanel = new JPanel();
113
 
                moveUpButton = new javax.swing.JButton("\u25b2 " + app.getPlain("Up")); 
114
 
                moveUpButton.addActionListener(this);
115
 
                upDownPanel.add(moveUpButton);
116
 
                //
117
 
                moveDownButton = new javax.swing.JButton("\u25bc " + app.getPlain("Down"));             
118
 
                moveDownButton.addActionListener(this);
119
 
                upDownPanel.add(moveDownButton);
120
 
                
121
 
                scrollPanel.add(upDownPanel, BorderLayout.SOUTH);
122
 
 
123
 
                //
124
 
 
125
 
                //
126
 
                JPanel modePanel = new JPanel();
127
 
                modePanel.setLayout(new BorderLayout(0, 0));
128
 
                modePanel.setBorder(new TitledBorder(app.getMenu("Tools")));
129
 
                //modePanel.setBorder(new TitledBorder(new EmptyBorder(0, 0, 0, 0), " " + "W�hlbare Eintr�ge" + " "));
130
 
                //
131
 
                Vector modeVector = generateToolsVector();
132
 
                toolList = new JList(modeVector);               
133
 
                //modeList.setPreferredSize(new Dimension(150, 150));
134
 
                //
135
 
                //modeList.setSize(new Dimension(150, 150));
136
 
                //modeList.addListSelectionListener(this);
137
 
                //
138
 
                ListSelectionModel lsm = toolList.getSelectionModel();
139
 
                lsm.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
140
 
                toolList.setBackground(configScrollPane.getBackground());
141
 
                modeScrollPane = new JScrollPane(toolList);             
142
 
                modeScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
143
 
                modeScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
144
 
                toolList.setCellRenderer(new ModeCellRenderer(app));
145
 
                toolList.setSelectedIndex(0);
146
 
                //
147
 
                //
148
 
                JPanel modeSpacePanel = new JPanel();
149
 
                modeSpacePanel.setLayout(new BorderLayout(0, 0));
150
 
                modeSpacePanel.setBorder(new EmptyBorder(3, 5, 3, 5));
151
 
                modeSpacePanel.add("Center", modeScrollPane);
152
 
                //
153
 
                //modeSpacePanel.setPreferredSize(new Dimension(175, 175));
154
 
                //
155
 
                //modeSpacePanel.setSize(new Dimension(175, 175));
156
 
                //
157
 
                modePanel.add("Center", modeSpacePanel);
158
 
                modePanel.setPreferredSize(new Dimension(SCROLL_PANEL_WIDTH, SCROLL_PANEL_HEIGHT));
159
 
                selectionPanel.add("East", modePanel);          
160
 
                add("Center", selectionPanel);
161
 
                //
162
 
                /*JPanel controlPanel = new JPanel();
163
 
                controlPanel.setLayout(new FlowLayout());
164
 
                okButton = new javax.swing.JButton("OK");
165
 
                okButton.setName("ok");
166
 
                okButton.addActionListener(this);
167
 
                controlPanel.add(okButton);
168
 
                cancelButton = new javax.swing.JButton("Abbrechen");
169
 
                cancelButton.setName("cancel");
170
 
                cancelButton.addActionListener(this);
171
 
                controlPanel.add(cancelButton);
172
 
                controlPanel.doLayout();*/
173
 
                //add(controlPanel, BorderLayout.SOUTH);
174
 
                //
175
 
                //doLayout();
176
 
                //this.validateTree();
177
 
                //modeScrollPane.setPreferredSize(new Dimension(Math.max(modeScrollPane.getWidth(), configScrollPane.getWidth()), (int) configScrollPane.getSize().getHeight()));
178
 
                //modeScrollPane.setSize(modeList.getPreferredSize());
179
 
                //modeScrollPane.setSize(modeScrollPane.getPreferredSize());
180
 
                //configScrollPane.setPreferredSize(new Dimension(Math.max(modeScrollPane.getWidth(), configScrollPane.getWidth()), (int) configScrollPane.getSize().getHeight()));
181
 
                
182
 
                
183
 
                try {
184
 
                        tree.setSelectionRow(1);
185
 
                } catch (Exception exc) {
186
 
                        tree.setSelectionRow(0);
187
 
                }                               
188
 
        }
189
 
                
190
 
        
191
 
        
192
 
        
193
 
        /**
194
 
         * Handles remove, add and up, down buttons.
195
 
         */
196
 
        public void actionPerformed(ActionEvent e) {                                    
197
 
                // get selected node in tree
198
 
                DefaultTreeModel model = (DefaultTreeModel) tree.getModel();                                                    
199
 
                TreePath selPath = tree.getSelectionPath();
200
 
                if (selPath == null) {                  
201
 
                    tree.setSelectionRow(0); // take root if nothing is selected
202
 
                    selPath = tree.getSelectionPath();
203
 
                } 
204
 
                DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
205
 
                DefaultMutableTreeNode selNode = (DefaultMutableTreeNode) selPath.getLastPathComponent();
206
 
                // remember row number
207
 
                int selRow = tree.getRowForPath(selPath);       
208
 
                
209
 
                DefaultMutableTreeNode parentNode;              
210
 
                if (selNode == root) { // root is selected
211
 
                        parentNode = selNode;
212
 
                } else {
213
 
                        parentNode = (DefaultMutableTreeNode) selNode.getParent();                                                      
214
 
                }       
215
 
                int childIndex = parentNode.getIndex(selNode);
216
 
                
217
 
                Object src = e.getSource();     
218
 
                
219
 
                // DELETE
220
 
                if (src == deleteButton) {                                                                      
221
 
                        if (selRow > 0) { // not root                                   
222
 
                                // delete node unless move node                         
223
 
                                Object userOb = selNode.getUserObject();
224
 
                                if (userOb == null)
225
 
                                        userOb = ((DefaultMutableTreeNode) selNode.getFirstChild()).getUserObject();                            
226
 
                                if (userOb instanceof Integer && ((Integer) userOb).intValue() == 0) 
227
 
                                        return;
228
 
                                
229
 
                                // not move mode: delete node
230
 
                                model.removeNodeFromParent(selNode);                            
231
 
                                // remove empty menu too        
232
 
                                if (parentNode.getChildCount() == 0) {
233
 
                                        if (!parentNode.isRoot()) {                                     
234
 
                                                model.removeNodeFromParent(parentNode);
235
 
                                                selRow--;
236
 
                                        }
237
 
                                }
238
 
                                
239
 
                                // select node at same row or above
240
 
                                if (selRow >= tree.getRowCount())
241
 
                                        selRow--;
242
 
                                tree.setSelectionRow(selRow);
243
 
                        }                                               
244
 
                } 
245
 
                // INSERT
246
 
                else if (src == insertButton) {         
247
 
                        childIndex++;
248
 
                        
249
 
                        boolean didInsert = false;
250
 
                        Object [] tools = toolList.getSelectedValues();                                         
251
 
                        for (int i=0; i < tools.length; i++) {
252
 
                                // check if too is already there
253
 
                                Integer modeInt = (Integer)tools[i];
254
 
                                if (modeInt.intValue() > -1 && containsTool(root, (Integer)tools[i]))
255
 
                                        continue;
256
 
                                
257
 
                                DefaultMutableTreeNode newNode;
258
 
                                if (parentNode == root && modeInt.intValue() > -1) {
259
 
                                        // parent is root: create new submenu
260
 
                                        newNode = new DefaultMutableTreeNode();                 
261
 
                                        newNode.add(new DefaultMutableTreeNode(modeInt));
262
 
                                }
263
 
                                else {
264
 
                                        // parent is submenu
265
 
                                        newNode = new DefaultMutableTreeNode(modeInt);                                          
266
 
                                }                                                                                       
267
 
                                model.insertNodeInto(newNode, parentNode, childIndex++);                                
268
 
                                didInsert = true;                               
269
 
                        }
270
 
                        
271
 
                        if (didInsert) {
272
 
                                // make sure that root is expanded
273
 
                                tree.expandPath(new TreePath(model.getRoot()));
274
 
                                
275
 
                                // select first inserted node
276
 
                                tree.setSelectionRow(++selRow);
277
 
                                tree.scrollRowToVisible(selRow);
278
 
                                configScrollPane.getHorizontalScrollBar().setValue(0); // scroll to left
279
 
                        }
280
 
                }
281
 
                
282
 
                // UP
283
 
                else if (src == moveUpButton) {
284
 
                        if (selNode == root)
285
 
                                return;
286
 
                                                
287
 
                        if (parentNode.getChildBefore(selNode) != null) {                                                       
288
 
                                model.removeNodeFromParent(selNode);
289
 
                                model.insertNodeInto(selNode, parentNode, --childIndex);
290
 
                                tree.setSelectionRow(--selRow);
291
 
                        }                       
292
 
                }
293
 
                
294
 
                // DOWN
295
 
                else if (src == moveDownButton) {
296
 
                        if (selNode == root)
297
 
                                return;
298
 
                                                
299
 
                        if (parentNode.getChildAfter(selNode) != null) {                                                        
300
 
                                model.removeNodeFromParent(selNode);
301
 
                                model.insertNodeInto(selNode, parentNode, ++childIndex);
302
 
                                tree.setSelectionRow(++selRow);
303
 
                        }                       
304
 
                }
305
 
        }       
306
 
        
307
 
        private boolean containsTool(DefaultMutableTreeNode node, Integer mode) {
308
 
        // compare modes
309
 
                Object ob = node.getUserObject();
310
 
        if (ob != null && mode.compareTo((Integer)ob) == 0) {                   
311
 
                return true;
312
 
        }
313
 
    
314
 
        if (node.getChildCount() >= 0) {
315
 
            for (Enumeration e=node.children(); e.hasMoreElements(); ) {
316
 
                DefaultMutableTreeNode n = (DefaultMutableTreeNode)e.nextElement();
317
 
                if (containsTool(n, mode))
318
 
                        return true;
319
 
            }
320
 
        }
321
 
        return false;
322
 
    }
323
 
        
324
 
        /**
325
 
         * Inits the toolbar tree in this panel to show the given toolbar definition string.
326
 
         */
327
 
        public void setToolBarString(String toolbarDefinition) {                                
328
 
                // create new tree model
329
 
                Vector toolVec = MyToolbar.createToolBarVec(toolbarDefinition);
330
 
                DefaultTreeModel model = new DefaultTreeModel(generateRootNode(toolVec));
331
 
                tree.setModel(model);           
332
 
                collapseAllRows();      
333
 
                tree.setRowHeight(-1);                          
334
 
        }
335
 
        
336
 
        /**
337
 
         * Returns the custom toolbar created with this panel as a String.
338
 
         * Separator ("||" between menus, "," in menu), New menu starts with "|"
339
 
         */
340
 
        public String getToolBarString() {                                                              
341
 
                StringBuffer sb = new StringBuffer();
342
 
                
343
 
                DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel().getRoot();                           
344
 
        for (int i=0; i < root.getChildCount(); i++) {
345
 
                DefaultMutableTreeNode menu = (DefaultMutableTreeNode) root.getChildAt(i);
346
 
                
347
 
                if (menu.getChildCount() == 0) { // new menu with separator
348
 
                        sb.append("|| ");
349
 
                } 
350
 
                else if (i > 0 && !sb.toString().endsWith("|| ")) // new menu
351
 
                        sb.append("| ");
352
 
                
353
 
                for (int j=0; j < menu.getChildCount(); j++) {
354
 
                DefaultMutableTreeNode node = (DefaultMutableTreeNode) menu.getChildAt(j);
355
 
                int mode = ((Integer) node.getUserObject()).intValue();
356
 
                                
357
 
                if (mode < 0) // separator
358
 
                        sb.append(", ");
359
 
                else { // mode number                           
360
 
                        sb.append(mode);
361
 
                        sb.append(" ");
362
 
                }               
363
 
            }                           
364
 
        }
365
 
                
366
 
        return sb.toString().trim();    
367
 
        }               
368
 
        
369
 
        public void collapseAllRows() {
370
 
                int z = tree.getRowCount();
371
 
                for (int i = z; i > 0; i--) {
372
 
                        tree.collapseRow(i);
373
 
                }
374
 
        }
375
 
        
376
 
                
377
 
        /**
378
 
         * 
379
 
         */
380
 
        public Vector generateToolsVector() {                           
381
 
                Vector vector = new Vector();           
382
 
                // separator
383
 
                vector.add(MyToolbar.TOOLBAR_SEPARATOR);
384
 
                                
385
 
                // get default toolbar as nested vectors
386
 
                Vector defTools = MyToolbar.createToolBarVec(app.getGuiManager().getDefaultToolbarString());                            
387
 
                for (int i=0; i < defTools.size(); i++) {
388
 
                        Object element = defTools.get(i);
389
 
                        
390
 
                        if (element instanceof Vector) {
391
 
                                Vector menu = (Vector) element;
392
 
                                for (int j=0; j < menu.size(); j++) {
393
 
                                        Integer modeInt = (Integer) menu.get(j);
394
 
                                        int mode = modeInt.intValue();
395
 
                                        if (mode != -1)
396
 
                                                vector.add(modeInt);
397
 
                                }
398
 
                        } else {
399
 
                                Integer modeInt = (Integer) element;
400
 
                                int mode = modeInt.intValue();
401
 
                                if (mode != -1)
402
 
                                        vector.add(modeInt);
403
 
                        }                       
404
 
                }                               
405
 
                return vector;
406
 
        }
407
 
        /**
408
 
         *
409
 
         */
410
 
        private JTree generateTree() {                  
411
 
                final JTree jTree = new JTree() {
412
 
                protected void setExpandedState(TreePath path, boolean state) {
413
 
                    // Ignore all collapse requests of root             
414
 
                    if (path != getPathForRow(0)) {
415
 
                        super.setExpandedState(path, state);
416
 
                    }
417
 
                }
418
 
            };                     
419
 
                
420
 
                jTree.setCellRenderer(new ModeCellRenderer(app));
421
 
                jTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
422
 
                jTree.putClientProperty("JTree.lineStyle", "Angled");
423
 
                jTree.addTreeExpansionListener(this);                                           
424
 
                
425
 
                return jTree;
426
 
        }
427
 
        /**
428
 
         * 
429
 
         */
430
 
        public DefaultMutableTreeNode generateRootNode(Vector toolbarModes) {
431
 
                DefaultMutableTreeNode node = new DefaultMutableTreeNode();
432
 
                
433
 
                for (int i = 0; i < toolbarModes.size(); i++) {
434
 
                        Object ob = toolbarModes.get(i);
435
 
                        if (ob instanceof Vector) {
436
 
                                Vector menu = (Vector) ob;  
437
 
                                DefaultMutableTreeNode sub = new DefaultMutableTreeNode();
438
 
                                for (int j = 0; j < menu.size(); j++) {
439
 
                                        sub.add(new DefaultMutableTreeNode(menu.get(j)));
440
 
                                }
441
 
                                node.add(sub);
442
 
                        }
443
 
                        else
444
 
                                node.add(new DefaultMutableTreeNode(ob));
445
 
                }
446
 
                return node;
447
 
        }
448
 
                
449
 
        /**
450
 
         * 
451
 
         */
452
 
        public void treeCollapsed(javax.swing.event.TreeExpansionEvent event) {}
453
 
        /**
454
 
         * 
455
 
         */
456
 
        public void treeExpanded(javax.swing.event.TreeExpansionEvent event) {
457
 
                /*tabbed.invalidate();
458
 
                tabbed.validateTree();*/
459
 
        }
460
 
        
461
 
        /**
462
 
         * 
463
 
         */
464
 
        public void valueChanged(javax.swing.event.ListSelectionEvent e) {}
465
 
        
466
 
        
 
1
/* 
 
2
GeoGebra - Dynamic Mathematics for Everyone
 
3
http://www.geogebra.org
 
4
 
 
5
This file is part of GeoGebra.
 
6
 
 
7
This program is free software; you can redistribute it and/or modify it 
 
8
under the terms of the GNU General Public License as published by 
 
9
the Free Software Foundation.
 
10
 
 
11
*/
 
12
 
 
13
package geogebra.gui.toolbar;
 
14
import geogebra.gui.layout.DockPanel;
 
15
import geogebra.main.Application;
 
16
 
 
17
import java.awt.BorderLayout;
 
18
import java.awt.Dimension;
 
19
import java.awt.SystemColor;
 
20
import java.awt.event.ActionEvent;
 
21
import java.util.Enumeration;
 
22
import java.util.Iterator;
 
23
import java.util.Vector;
 
24
 
 
25
import javax.swing.Box;
 
26
import javax.swing.BoxLayout;
 
27
import javax.swing.DefaultListModel;
 
28
import javax.swing.JButton;
 
29
import javax.swing.JList;
 
30
import javax.swing.JPanel;
 
31
import javax.swing.JScrollPane;
 
32
import javax.swing.JTree;
 
33
import javax.swing.ListSelectionModel;
 
34
import javax.swing.border.EmptyBorder;
 
35
import javax.swing.border.TitledBorder;
 
36
import javax.swing.tree.DefaultMutableTreeNode;
 
37
import javax.swing.tree.DefaultTreeModel;
 
38
import javax.swing.tree.TreePath;
 
39
import javax.swing.tree.TreeSelectionModel;
 
40
 
 
41
/**
 
42
 * Toolbar configuration panel.
 
43
 *  
 
44
 * @author Markus Hohenwarter, based on a dialog from geonext.de
 
45
 *
 
46
 */
 
47
public class ToolbarConfigPanel extends javax.swing.JPanel implements java.awt.event.ActionListener, javax.swing.event.TreeExpansionListener {  
 
48
        
 
49
        private static final int SCROLL_PANEL_WIDTH = 300;
 
50
        private static final int SCROLL_PANEL_HEIGHT = 400;
 
51
        
 
52
        private DockPanel dockPanel;
 
53
        
 
54
        public JButton insertButton;
 
55
        public JButton moveUpButton;
 
56
        public JButton moveDownButton;
 
57
        public JButton deleteButton;
 
58
        public JTree tree;
 
59
        JScrollPane configScrollPane;
 
60
        JScrollPane modeScrollPane;
 
61
        JScrollPane iconScrollPane;
 
62
        JPanel selectionPanel;
 
63
        JList toolList; 
 
64
        DefaultListModel toolListModel;
 
65
        int selectedRow;        
 
66
        Application app;        
 
67
        
 
68
        public ToolbarConfigPanel(Application app) {
 
69
                super();        
 
70
                this.app = app;                 
 
71
                
 
72
                selectionPanel = new JPanel();
 
73
                selectionPanel.setLayout(new BorderLayout(5, 5));
 
74
                selectionPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
 
75
                setLayout(new BorderLayout(5, 5));
 
76
                                
 
77
                tree = generateTree();
 
78
                
 
79
                toolListModel = new DefaultListModel();
 
80
                toolList = new JList(toolListModel);
 
81
                
 
82
                setToolbar(null, app.getGuiManager().getToolbarDefinition());   
 
83
                
 
84
                configScrollPane = new JScrollPane(tree);
 
85
                configScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
 
86
                configScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
 
87
                //configScrollPane.setSize(150, 150);   
 
88
                JPanel scrollSpacePanel = new JPanel();
 
89
                scrollSpacePanel.setLayout(new BorderLayout(0, 0));
 
90
                scrollSpacePanel.setBorder(new EmptyBorder(3, 5, 3, 5));
 
91
                scrollSpacePanel.add(configScrollPane, BorderLayout.CENTER); //
 
92
                JPanel scrollPanel = new JPanel();
 
93
                scrollPanel.setLayout(new BorderLayout(0, 0));
 
94
                scrollPanel.setBorder(new TitledBorder(app.getMenu("Toolbar")));
 
95
                scrollPanel.add(scrollSpacePanel, BorderLayout.CENTER);
 
96
                                
 
97
                scrollPanel.setPreferredSize(new Dimension(SCROLL_PANEL_WIDTH, SCROLL_PANEL_HEIGHT));
 
98
                //
 
99
                selectionPanel.add(scrollPanel, BorderLayout.WEST);
 
100
                //
 
101
                
 
102
                JPanel buttonPanel = new JPanel();
 
103
                buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.Y_AXIS));
 
104
                buttonPanel.add(Box.createVerticalGlue());
 
105
                
 
106
                insertButton = new JButton("< " + app.getPlain("Insert"));              
 
107
                insertButton.addActionListener(this);
 
108
                insertButton.setAlignmentX(CENTER_ALIGNMENT);
 
109
                buttonPanel.add(insertButton);
 
110
                buttonPanel.add(Box.createVerticalStrut(10));
 
111
                
 
112
                deleteButton = new javax.swing.JButton(app.getPlain("Remove") + " >");          
 
113
                deleteButton.addActionListener(this);
 
114
                deleteButton.setAlignmentX(CENTER_ALIGNMENT);
 
115
                buttonPanel.add(deleteButton);          
 
116
                
 
117
                buttonPanel.add(Box.createVerticalGlue());
 
118
                selectionPanel.add(buttonPanel, BorderLayout.CENTER);
 
119
                
 
120
                
 
121
                
 
122
                //              
 
123
                JPanel upDownPanel = new JPanel();
 
124
                moveUpButton = new javax.swing.JButton("\u25b2 " + app.getPlain("Up")); 
 
125
                moveUpButton.addActionListener(this);
 
126
                upDownPanel.add(moveUpButton);
 
127
                //
 
128
                moveDownButton = new javax.swing.JButton("\u25bc " + app.getPlain("Down"));             
 
129
                moveDownButton.addActionListener(this);
 
130
                upDownPanel.add(moveDownButton);
 
131
                
 
132
                scrollPanel.add(upDownPanel, BorderLayout.SOUTH);
 
133
 
 
134
                //
 
135
                
 
136
                JPanel buttonAllPanel = new JPanel(new BorderLayout());                 
 
137
                buttonAllPanel.add(buttonPanel, BorderLayout.NORTH);
 
138
                JPanel tempPanel = new JPanel();
 
139
                tempPanel.setLayout(new BoxLayout(tempPanel, BoxLayout.Y_AXIS));
 
140
                tempPanel.add(Box.createRigidArea(new Dimension(10,150)));
 
141
                tempPanel.add(buttonAllPanel);
 
142
                tempPanel.add(Box.createVerticalGlue());
 
143
                
 
144
                selectionPanel.add(tempPanel, BorderLayout.CENTER);
 
145
                JPanel modePanel = new JPanel();
 
146
                modePanel.setLayout(new BorderLayout(0, 0));
 
147
                modePanel.setBorder(new TitledBorder(app.getMenu("Tools")));
 
148
                
 
149
                ListSelectionModel lsm = toolList.getSelectionModel();
 
150
                lsm.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
 
151
                toolList.setBackground(SystemColor.text);
 
152
                modeScrollPane = new JScrollPane(toolList);             
 
153
                modeScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
 
154
                modeScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
 
155
                toolList.setCellRenderer(new ModeCellRenderer(app));
 
156
                toolList.setSelectedIndex(0);
 
157
                //
 
158
                //
 
159
                JPanel modeSpacePanel = new JPanel();
 
160
                modeSpacePanel.setLayout(new BorderLayout(0, 0));
 
161
                modeSpacePanel.setBorder(new EmptyBorder(3, 5, 3, 5));
 
162
                modeSpacePanel.add("Center", modeScrollPane);
 
163
                
 
164
                modePanel.add("Center", modeSpacePanel);
 
165
                modePanel.setPreferredSize(new Dimension(SCROLL_PANEL_WIDTH, SCROLL_PANEL_HEIGHT));
 
166
                selectionPanel.add("East", modePanel);          
 
167
                add("Center", selectionPanel);
 
168
                
 
169
                try {
 
170
                        tree.setSelectionRow(1);
 
171
                } catch (Exception exc) {
 
172
                        tree.setSelectionRow(0);
 
173
                }                               
 
174
        }
 
175
                
 
176
        
 
177
        
 
178
        
 
179
        /**
 
180
         * Handles remove, add and up, down buttons.
 
181
         */
 
182
        public void actionPerformed(ActionEvent e) {                                    
 
183
                // get selected node in tree
 
184
                DefaultTreeModel model = (DefaultTreeModel) tree.getModel();                                                    
 
185
                TreePath selPath = tree.getSelectionPath();
 
186
                if (selPath == null) {                  
 
187
                    tree.setSelectionRow(0); // take root if nothing is selected
 
188
                    selPath = tree.getSelectionPath();
 
189
                } 
 
190
                DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
 
191
                DefaultMutableTreeNode selNode = (DefaultMutableTreeNode) selPath.getLastPathComponent();
 
192
                // remember row number
 
193
                int selRow = tree.getRowForPath(selPath);       
 
194
                
 
195
                DefaultMutableTreeNode parentNode;              
 
196
                if (selNode == root) { // root is selected
 
197
                        parentNode = selNode;
 
198
                } else {
 
199
                        parentNode = (DefaultMutableTreeNode) selNode.getParent();                                                      
 
200
                }       
 
201
                int childIndex = parentNode.getIndex(selNode);
 
202
                
 
203
                Object src = e.getSource();     
 
204
                
 
205
                // DELETE
 
206
                if (src == deleteButton) {                                                                      
 
207
                        if (selRow > 0) { // not root                           
 
208
                                Object userOb = selNode.getUserObject();
 
209
                                if (userOb == null)
 
210
                                        userOb = ((DefaultMutableTreeNode) selNode.getFirstChild()).getUserObject();
 
211
                                
 
212
                                // not move mode: delete node
 
213
                                model.removeNodeFromParent(selNode);                            
 
214
                                // remove empty menu too        
 
215
                                if (parentNode.getChildCount() == 0) {
 
216
                                        if (!parentNode.isRoot()) {                                     
 
217
                                                model.removeNodeFromParent(parentNode);
 
218
                                                selRow--;
 
219
                                        }
 
220
                                }
 
221
                                
 
222
                                toolListModel.addElement(userOb);
 
223
                                sortToolList();
 
224
                                
 
225
                                // select node at same row or above
 
226
                                if (selRow >= tree.getRowCount())
 
227
                                        selRow--;
 
228
                                tree.setSelectionRow(selRow);
 
229
                        }                                               
 
230
                } 
 
231
                // INSERT
 
232
                else if (src == insertButton) {         
 
233
                        childIndex++;
 
234
                        
 
235
                        boolean didInsert = false;
 
236
                        Object [] tools = toolList.getSelectedValues();                                         
 
237
                        for (int i=0; i < tools.length; i++) {
 
238
                                // check if too is already there
 
239
                                Integer modeInt = (Integer)tools[i];
 
240
                                if (modeInt.intValue() > -1 && containsTool(root, (Integer)tools[i]))
 
241
                                        continue;
 
242
                                
 
243
                                DefaultMutableTreeNode newNode;
 
244
                                if (parentNode == root && modeInt.intValue() > -1) {
 
245
                                        // parent is root: create new submenu
 
246
                                        newNode = new DefaultMutableTreeNode();                 
 
247
                                        newNode.add(new DefaultMutableTreeNode(modeInt));
 
248
                                }
 
249
                                else {
 
250
                                        // parent is submenu
 
251
                                        newNode = new DefaultMutableTreeNode(modeInt);                                          
 
252
                                }                                                                                       
 
253
                                model.insertNodeInto(newNode, parentNode, childIndex++);                                
 
254
                                didInsert = true;       
 
255
                                
 
256
                                // remove node from list of unused tools if the node is not a separator
 
257
                                if(modeInt.intValue() > -1)
 
258
                                        toolListModel.removeElement(modeInt);
 
259
                        }
 
260
                        
 
261
                        if (didInsert) {
 
262
                                // make sure that root is expanded
 
263
                                tree.expandPath(new TreePath(model.getRoot()));
 
264
                                
 
265
                                // select first inserted node
 
266
                                tree.setSelectionRow(++selRow);
 
267
                                tree.scrollRowToVisible(selRow);
 
268
                                configScrollPane.getHorizontalScrollBar().setValue(0); // scroll to left
 
269
                                
 
270
                                // sort tool list
 
271
                                sortToolList();
 
272
                        }
 
273
                }
 
274
                
 
275
                // UP
 
276
                else if (src == moveUpButton) {
 
277
                        if (selNode == root)
 
278
                                return;
 
279
                                                
 
280
                        if (parentNode.getChildBefore(selNode) != null) {                                                       
 
281
                                model.removeNodeFromParent(selNode);
 
282
                                model.insertNodeInto(selNode, parentNode, --childIndex);
 
283
                                tree.setSelectionRow(--selRow);
 
284
                        }                       
 
285
                }
 
286
                
 
287
                // DOWN
 
288
                else if (src == moveDownButton) {
 
289
                        if (selNode == root)
 
290
                                return;
 
291
                                                
 
292
                        if (parentNode.getChildAfter(selNode) != null) {                                                        
 
293
                                model.removeNodeFromParent(selNode);
 
294
                                model.insertNodeInto(selNode, parentNode, ++childIndex);
 
295
                                tree.setSelectionRow(++selRow);
 
296
                        }                       
 
297
                }
 
298
        }       
 
299
        
 
300
        @SuppressWarnings("unchecked")
 
301
        private boolean containsTool(DefaultMutableTreeNode node, Integer mode) {
 
302
        // compare modes
 
303
                Object ob = node.getUserObject();
 
304
        if (ob != null && mode.compareTo((Integer)ob) == 0) {                   
 
305
                return true;
 
306
        }
 
307
    
 
308
        if (node.getChildCount() >= 0) {
 
309
            for (Enumeration e=node.children(); e.hasMoreElements(); ) {
 
310
                DefaultMutableTreeNode n = (DefaultMutableTreeNode)e.nextElement();
 
311
                if (containsTool(n, mode))
 
312
                        return true;
 
313
            }
 
314
        }
 
315
        return false;
 
316
    }
 
317
        
 
318
        /**
 
319
         * Inits the toolbar tree in this panel to show the given toolbar definition string.
 
320
         * @param dockPanel 
 
321
         * @param toolbarDefinition toolbar as string (sequence of numbers and delimiters)
 
322
         */
 
323
        public void setToolbar(DockPanel dockPanel, String toolbarDefinition) {
 
324
                this.dockPanel = dockPanel;
 
325
                
 
326
                // create new tree model
 
327
                Vector<Object> toolVec = Toolbar.parseToolbarString(toolbarDefinition);         
 
328
                DefaultTreeModel model = new DefaultTreeModel(generateRootNode(toolVec));
 
329
                tree.setModel(model);           
 
330
                collapseAllRows();      
 
331
                tree.setRowHeight(-1);
 
332
                
 
333
                Vector<Object> allTools = generateToolsVector(Toolbar.getAllTools(app));
 
334
                Vector<Object> usedTools = generateToolsVector(toolbarDefinition);
 
335
                
 
336
                toolListModel.clear();
 
337
                toolListModel.addElement(Toolbar.SEPARATOR); // always display the separator in the tools list
 
338
                
 
339
                for(Iterator<Object> iter = allTools.iterator(); iter.hasNext();) {
 
340
                        Object next = iter.next();
 
341
                        
 
342
                        if(!usedTools.contains(next)) {
 
343
                                toolListModel.addElement(next);
 
344
                        }
 
345
                }
 
346
        }
 
347
        
 
348
        public void apply() {
 
349
                if(dockPanel != null) {
 
350
                        dockPanel.setToolbarString(getToolBarString());
 
351
                } else {
 
352
                        app.getGuiManager().setToolBarDefinition(getToolBarString());
 
353
                }
 
354
        }
 
355
        
 
356
        /**
 
357
         * Reset the current toolbar to its default state.
 
358
         */
 
359
        public void resetDefaultToolbar() {
 
360
                if(dockPanel != null) {
 
361
                        setToolbar(dockPanel, dockPanel.getDefaultToolbarString());
 
362
                } else {
 
363
                        setToolbar(null, app.getGuiManager().getDefaultToolbarString());
 
364
                }
 
365
        }
 
366
        
 
367
        /**
 
368
         * Returns the custom toolbar created with this panel as a String.
 
369
         * Separator ("||" between menus, "," in menu), New menu starts with "|"
 
370
         * @return toolbar as string
 
371
         */
 
372
        public String getToolBarString() {                                                              
 
373
                StringBuilder sb = new StringBuilder();
 
374
                
 
375
                DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel().getRoot();                           
 
376
        for (int i=0; i < root.getChildCount(); i++) {
 
377
                DefaultMutableTreeNode menu = (DefaultMutableTreeNode) root.getChildAt(i);
 
378
                
 
379
                if (menu.getChildCount() == 0) { // new menu with separator
 
380
                        sb.append("|| ");
 
381
                } 
 
382
                else if (i > 0 && !sb.toString().endsWith("|| ")) // new menu
 
383
                        sb.append("| ");
 
384
                
 
385
                for (int j=0; j < menu.getChildCount(); j++) {
 
386
                DefaultMutableTreeNode node = (DefaultMutableTreeNode) menu.getChildAt(j);
 
387
                int mode = ((Integer) node.getUserObject()).intValue();
 
388
                                
 
389
                if (mode < 0) // separator
 
390
                        sb.append(", ");
 
391
                else { // mode number                           
 
392
                        sb.append(mode);
 
393
                        sb.append(" ");
 
394
                }               
 
395
            }                           
 
396
        }
 
397
        
 
398
        return sb.toString().trim();    
 
399
        }               
 
400
        
 
401
        public void collapseAllRows() {
 
402
                int z = tree.getRowCount();
 
403
                for (int i = z; i > 0; i--) {
 
404
                        tree.collapseRow(i);
 
405
                }
 
406
        }
 
407
        
 
408
        /**
 
409
         * @param toolbarDefinition 
 
410
         * @return vector of menus (vectors of ints) and separators (ints)
 
411
         * 
 
412
         */
 
413
        @SuppressWarnings("unchecked")
 
414
        public Vector<Object> generateToolsVector(String toolbarDefinition) {                           
 
415
                Vector<Object> vector = new Vector<Object>();           
 
416
                // separator
 
417
                vector.add(Toolbar.SEPARATOR);
 
418
                                
 
419
                // get default toolbar as nested vectors
 
420
                Vector<Object> defTools = Toolbar.parseToolbarString(toolbarDefinition);                                
 
421
                for (int i=0; i < defTools.size(); i++) {
 
422
                        Object element = defTools.get(i);
 
423
                        
 
424
                        if (element instanceof Vector) {
 
425
                                Vector<Integer> menu = (Vector<Integer>) element;
 
426
                                for (int j=0; j < menu.size(); j++) {
 
427
                                        Integer modeInt = menu.get(j);
 
428
                                        int mode = modeInt.intValue();
 
429
                                        if (mode != -1)
 
430
                                                vector.add(modeInt);
 
431
                                }
 
432
                        } else {
 
433
                                Integer modeInt = (Integer) element;
 
434
                                int mode = modeInt.intValue();
 
435
                                if (mode != -1)
 
436
                                        vector.add(modeInt);
 
437
                        }                       
 
438
                }                               
 
439
                return vector;
 
440
        }
 
441
        /**
 
442
         *
 
443
         */
 
444
        private JTree generateTree() {                  
 
445
                final JTree jTree = new JTree() {
 
446
                protected void setExpandedState(TreePath path, boolean state) {
 
447
                    // Ignore all collapse requests of root             
 
448
                    if (path != getPathForRow(0)) {
 
449
                        super.setExpandedState(path, state);
 
450
                    }
 
451
                }
 
452
            };                     
 
453
                
 
454
                jTree.setCellRenderer(new ModeCellRenderer(app));
 
455
                jTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
 
456
                jTree.putClientProperty("JTree.lineStyle", "Angled");
 
457
                jTree.addTreeExpansionListener(this);                                           
 
458
                
 
459
                return jTree;
 
460
        }
 
461
        /**
 
462
         * @param toolbarModes 
 
463
         * @return toolbar as DefaultMutableTreeNode 
 
464
         * 
 
465
         */
 
466
        @SuppressWarnings("unchecked")
 
467
        public DefaultMutableTreeNode generateRootNode(Vector toolbarModes) {
 
468
                DefaultMutableTreeNode node = new DefaultMutableTreeNode();
 
469
                
 
470
                for (int i = 0; i < toolbarModes.size(); i++) {
 
471
                        Object ob = toolbarModes.get(i);
 
472
                        if (ob instanceof Vector) {
 
473
                                Vector menu = (Vector) ob;  
 
474
                                DefaultMutableTreeNode sub = new DefaultMutableTreeNode();
 
475
                                for (int j = 0; j < menu.size(); j++) {
 
476
                                        sub.add(new DefaultMutableTreeNode(menu.get(j)));
 
477
                                }
 
478
                                node.add(sub);
 
479
                        }
 
480
                        else
 
481
                                node.add(new DefaultMutableTreeNode(ob));
 
482
                }
 
483
                return node;
 
484
        }
 
485
 
 
486
        /**
 
487
         * Add an item to the tool list
 
488
         * 
 
489
         * TODO Rename method
 
490
         * TODO Use this method to insert new items into the model
 
491
         * TODO Use the default toolbar vector to keep the standard sorting
 
492
         * 
 
493
         * @author Florian Sonner
 
494
         * @version 2008-10-22
 
495
         */
 
496
        private void sortToolList() {
 
497
                /*int numItems = toolListModel.getSize();
 
498
 
 
499
                if (numItems < 2)
 
500
                        return;
 
501
 
 
502
                // copy list data into an array
 
503
                Integer[] a = new Integer[numItems];
 
504
                for (int i = 0; i < numItems; ++i) {
 
505
                        a[i] = (Integer) toolListModel.getElementAt(i);
 
506
                }
 
507
 
 
508
                // sort array..
 
509
                Arrays.sort(a);
 
510
 
 
511
                // copy the sorted array back into the model
 
512
                for (int i = 0; i < numItems; ++i) {
 
513
                        toolListModel.setElementAt(a[i], i);
 
514
                }*/
 
515
        }
 
516
                
 
517
        /**
 
518
         * 
 
519
         */
 
520
        public void treeCollapsed(javax.swing.event.TreeExpansionEvent event) {}
 
521
        /**
 
522
         * 
 
523
         */
 
524
        public void treeExpanded(javax.swing.event.TreeExpansionEvent event) {
 
525
                /*tabbed.invalidate();
 
526
                tabbed.validateTree();*/
 
527
        }
 
528
        
 
529
        /**
 
530
         * @param e 
 
531
         * 
 
532
         */
 
533
        public void valueChanged(javax.swing.event.ListSelectionEvent e) {}
 
534
        
 
535
        
467
536
}
 
 
b'\\ No newline at end of file'