jsampler/view/AbstractInstrumentsDbTree.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
 *
 *   This file is part of JSampler.
 *
 *   JSampler is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   JSampler is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with JSampler; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 */

package org.jsampler.view;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JTree;

import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.event.TreeWillExpandListener;

import javax.swing.tree.TreePath;

import org.jsampler.CC;

/**
 *
 * @author Grigor Iliev
 */
public abstract class AbstractInstrumentsDbTree extends JTree {
        private InstrumentsDbTreeView view = null;
        
        /**
         * Creates a new instance of <code>AbstractInstrumentsDbTree</code>.
         */
        public
        AbstractInstrumentsDbTree() { this((ActionListener)null); }
        
        /**
         * Creates a new instance of <code>AbstractInstrumentsDbTree</code>.
         * 
         * @param l A listener that will be notified when the root
         * directory content is loaded.
         */
        public
        AbstractInstrumentsDbTree(ActionListener l) { this(new InstrumentsDbTreeModel(l)); }
        
        /**
         * Creates a new instance of <code>AbstractInstrumentsDbTree</code>
         * using the specified tree model.
         * 
         * @param model The model to be used by this tree.
         */
        public
        AbstractInstrumentsDbTree(InstrumentsDbTreeModel model) {
                setView(CC.getViewConfig().getInstrumentsDbTreeView());
                setModel(model);
                addTreeWillExpandListener(getHandler());
                addTreeSelectionListener(getHandler());
        }
        
        public InstrumentsDbTreeModel
        getModel() { return (InstrumentsDbTreeModel) super.getModel(); }
        
        /**
         * Removes the selected directory.
         */
        public void
        removeSelectedDirectory() {
                DbDirectoryTreeNode node = getSelectedDirectoryNode();
                if(node == null) return;
                
                String path = getModel().getPathName(getModel().getPathToRoot(node));
                
        }
        
        /**
         * Returns the currently selected directory, or <code>null</code>
         * if nothing is selected.
         */
        public DbDirectoryTreeNode
        getSelectedDirectoryNode() {
                if(getSelectionCount() == 0) return null;
                return (DbDirectoryTreeNode)getSelectionPath().getLastPathComponent();
        }
        
        public void
        setSelectedDirectoryNode(DbDirectoryTreeNode node) {
                Object[] objs = getModel().getPathToRoot(node);
                setSelectionPath(new TreePath(objs));
        }
        
        public String
        getSelectedDirectoryPath() {
                return getModel().getPathByNode(getSelectedDirectoryNode());
        }
        
        /**
         * Selects the specified directory.
         * Note that if there is at least one directory in the path,
         * which is not connected the selection will be changed
         * after the execution of this method.
         */
        public void
        setSelectedDirectory(final String dir) {
                getModel().loadPath(dir, new ActionListener() {
                        public void
                        actionPerformed(ActionEvent e) {
                                DbDirectoryTreeNode node = getModel().getNodeByPath(dir);
                                if(node != null) setSelectedDirectoryNode(node);
                        }
                });
        }
        
        /**
         * Schedules a task for refreshing the content of the specified directory.
         * Note that the specified directory is expected to be connected.
         * @param dir The absolute path name of the directory to refresh.
         */
        public void
        refreshDirectoryContent(String dir) {
                getModel().refreshDirectoryContent(dir);
        }
        
        public boolean
        hasBeenExpanded(TreePath p) {
                return super.hasBeenExpanded(p) || !getModel().isLeaf(p.getLastPathComponent());
        }
        
        /** Sets the view to be used for retrieving UI information. */
        public void
        setView(InstrumentsDbTreeView view) {
                this.view = view;
        }
        
        /** Gets the view used to retrieve UI information. */
        public InstrumentsDbTreeView
        getView() { return view; }
        
        private final EventHandler eventHandler = new EventHandler();
        
        private EventHandler
        getHandler() { return eventHandler; }
        
        private class EventHandler implements TreeWillExpandListener, TreeSelectionListener {
                public void
                treeWillCollapse(TreeExpansionEvent e) { }
                
                public void
                treeWillExpand(TreeExpansionEvent e) {
                        getModel().treeWillExpand(e.getPath());
                }
                
                public void
                valueChanged(TreeSelectionEvent e) {
                        TreePath p = e.getPath();
                        if(p == null) {
                                System.err.println("p is null");
                                return;
                        }
                        getModel().treeWillExpand(p);
                }
        }
}
1	iliev	1204	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4			* Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
5			*
6			* This file is part of JSampler.
7			*
8			* JSampler is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License version 2
10			* as published by the Free Software Foundation.
11			*
12			* JSampler is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with JSampler; if not, write to the Free Software
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20			* MA 02111-1307 USA
21			*/
22
23			package org.jsampler.view;
24
25			import java.awt.event.ActionEvent;
26			import java.awt.event.ActionListener;
27
28			import javax.swing.JTree;
29
30			import javax.swing.event.TreeExpansionEvent;
31			import javax.swing.event.TreeSelectionEvent;
32			import javax.swing.event.TreeSelectionListener;
33			import javax.swing.event.TreeWillExpandListener;
34
35			import javax.swing.tree.TreePath;
36
37	iliev	1285	import org.jsampler.CC;
38	iliev	1204
39			/**
40			*
41			* @author Grigor Iliev
42			*/
43			public abstract class AbstractInstrumentsDbTree extends JTree {
44	iliev	1285	private InstrumentsDbTreeView view = null;
45
46	iliev	1204	/**
47			* Creates a new instance of <code>AbstractInstrumentsDbTree</code>.
48			*/
49			public
50			AbstractInstrumentsDbTree() { this((ActionListener)null); }
51
52			/**
53			* Creates a new instance of <code>AbstractInstrumentsDbTree</code>.
54			*
55			* @param l A listener that will be notified when the root
56			* directory content is loaded.
57			*/
58			public
59			AbstractInstrumentsDbTree(ActionListener l) { this(new InstrumentsDbTreeModel(l)); }
60
61			/**
62			* Creates a new instance of <code>AbstractInstrumentsDbTree</code>
63			* using the specified tree model.
64			*
65			* @param model The model to be used by this tree.
66			*/
67			public
68			AbstractInstrumentsDbTree(InstrumentsDbTreeModel model) {
69	iliev	1285	setView(CC.getViewConfig().getInstrumentsDbTreeView());
70	iliev	1204	setModel(model);
71			addTreeWillExpandListener(getHandler());
72			addTreeSelectionListener(getHandler());
73			}
74
75			public InstrumentsDbTreeModel
76			getModel() { return (InstrumentsDbTreeModel) super.getModel(); }
77
78			/**
79			* Removes the selected directory.
80			*/
81			public void
82			removeSelectedDirectory() {
83			DbDirectoryTreeNode node = getSelectedDirectoryNode();
84			if(node == null) return;
85
86			String path = getModel().getPathName(getModel().getPathToRoot(node));
87
88			}
89
90			/**
91			* Returns the currently selected directory, or <code>null</code>
92			* if nothing is selected.
93			*/
94			public DbDirectoryTreeNode
95			getSelectedDirectoryNode() {
96			if(getSelectionCount() == 0) return null;
97			return (DbDirectoryTreeNode)getSelectionPath().getLastPathComponent();
98			}
99
100			public void
101			setSelectedDirectoryNode(DbDirectoryTreeNode node) {
102			Object[] objs = getModel().getPathToRoot(node);
103			setSelectionPath(new TreePath(objs));
104			}
105
106			public String
107			getSelectedDirectoryPath() {
108			return getModel().getPathByNode(getSelectedDirectoryNode());
109			}
110
111			/**
112			* Selects the specified directory.
113			* Note that if there is at least one directory in the path,
114			* which is not connected the selection will be changed
115			* after the execution of this method.
116			*/
117			public void
118			setSelectedDirectory(final String dir) {
119			getModel().loadPath(dir, new ActionListener() {
120			public void
121			actionPerformed(ActionEvent e) {
122			DbDirectoryTreeNode node = getModel().getNodeByPath(dir);
123			if(node != null) setSelectedDirectoryNode(node);
124			}
125			});
126			}
127
128			/**
129			* Schedules a task for refreshing the content of the specified directory.
130			* Note that the specified directory is expected to be connected.
131			* @param dir The absolute path name of the directory to refresh.
132			*/
133			public void
134			refreshDirectoryContent(String dir) {
135			getModel().refreshDirectoryContent(dir);
136			}
137
138			public boolean
139			hasBeenExpanded(TreePath p) {
140			return super.hasBeenExpanded(p) \|\| !getModel().isLeaf(p.getLastPathComponent());
141			}
142
143	iliev	1285	/** Sets the view to be used for retrieving UI information. */
144			public void
145			setView(InstrumentsDbTreeView view) {
146			this.view = view;
147			}
148
149			/** Gets the view used to retrieve UI information. */
150			public InstrumentsDbTreeView
151			getView() { return view; }
152
153	iliev	1204	private final EventHandler eventHandler = new EventHandler();
154
155			private EventHandler
156			getHandler() { return eventHandler; }
157
158			private class EventHandler implements TreeWillExpandListener, TreeSelectionListener {
159			public void
160			treeWillCollapse(TreeExpansionEvent e) { }
161
162			public void
163			treeWillExpand(TreeExpansionEvent e) {
164			getModel().treeWillExpand(e.getPath());
165			}
166
167			public void
168			valueChanged(TreeSelectionEvent e) {
169			TreePath p = e.getPath();
170			if(p == null) {
171			System.err.println("p is null");
172			return;
173			}
174			getModel().treeWillExpand(p);
175			}
176			}
177			}