org/jsampler/DefaultOrchestraListModel.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005-2011 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;

import java.util.Vector;

import org.jsampler.event.ListEvent;
import org.jsampler.event.ListListener;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


/**
 * This class provides default implementation of the <code>OrchestraListModel</code> interface.
 * @author Grigor Iliev
 */
public class DefaultOrchestraListModel implements OrchestraListModel {
        private final Vector<OrchestraModel> orchestras = new Vector<OrchestraModel>();
        private final Vector<ListListener<OrchestraModel>> listeners =
                new Vector<ListListener<OrchestraModel>>();
        
        
        /** Creates a new instance of <code>DefaultOrchestraListModel</code>. */
        public
        DefaultOrchestraListModel() {
                
        }
        
        /**
         * Registers the specified listener for receiving event messages.
         * @param l The <code>OrchestraListListener</code> to register.
         */
        @Override
        public void
        addOrchestraListListener(ListListener<OrchestraModel> l) { listeners.add(l); }
        
        /**
         * Removes the specified listener.
         * @param l The <code>OrchestraListListener</code> to remove.
         */
        @Override
        public void
        removeOrchestraListListener(ListListener<OrchestraModel> l) { listeners.remove(l); }
        
        /**
         * Gets the current number of orchestras in the list.
         * @return The current number of orchestras in the list.
         */
        @Override
        public int
        getOrchestraCount() { return orchestras.size(); }
        
        /**
         * Gets the orchestra at the specified position.
         * @param idx The index of the orchestra to be returned.
         * @return The orchestra at the specified position.
         */
        @Override
        public OrchestraModel
        getOrchestra(int idx) { return orchestras.get(idx); }
        
        /**
         * Adds the specified orchestra to the list.
         * @param orchestra The model of the orchestra to be added.
         * @throws IllegalArgumentException If <code>orchestra</code> is <code>null</code>.
         */
        @Override
        public void
        addOrchestra(OrchestraModel orchestra) {
                insertOrchestra(orchestra, getOrchestraCount());
        }
        
        /**
         * Inserts the specified orchestra at the specified position.
         * @param orchestra The orchestra to be inserted.
         * @param idx The position of the orchestra.
         * @throws IllegalArgumentException If <code>orchestra</code> is <code>null</code>.
         * @throws ArrayIndexOutOfBoundsException If the specified index is invalid.
         */
        @Override
        public void
        insertOrchestra(OrchestraModel orchestra, int idx) {
                if(orchestra == null)
                        throw new IllegalArgumentException("orchestra should be non-null!");
                
                orchestras.insertElementAt(orchestra, idx);
                fireOrchestraAdded(orchestra);
        }
        
        /**
         * Removes the specified orchestra from the list.
         * @param idx The index of the orchestra to remove.
         */
        @Override
        public void
        removeOrchestra(int idx) {
                OrchestraModel orchestraModel = orchestras.get(idx);
                orchestras.removeElementAt(idx);
                fireOrchestraRemoved(orchestraModel);
        }
        
        /**
         * Removes the specified orchestra from the list.
         * @param orchestraModel The model of the orchestra to remove.
         * @return <code>true</code> if the specified orchestra was in the list,
         * <code>false</code> otherwise.
         */
        @Override
        public boolean
        removeOrchestra(OrchestraModel orchestraModel) {
                boolean b = orchestras.removeElement(orchestraModel);
                if(b) fireOrchestraRemoved(orchestraModel);
                return b;
        }
        
        /** Removes all orchestras from the list. */
        @Override
        public void
        removeAllOrchestras() {
                for(int i = 0; i < getOrchestraCount(); i++) removeOrchestra(i);
        }
        
        /**
         * Gets the position of the specified orchestra in this orchestra list.
         * @param orchestra The orchestra whose index should be returned.
         * @return The position of the specified orchestra in this orchestra list,
         * and -1 if <code>orchestra</code> is <code>null</code> or
         * the orchestra list does not contain the specified orchestra.
         */
        @Override
        public int
        getOrchestraIndex(OrchestraModel orchestra) {
                if(orchestra == null) return -1;
                
                for(int i = 0; i < getOrchestraCount(); i++) {
                        if(getOrchestra(i) == orchestra) return i;
                }
                
                return -1;
        }
        
        /**
         * Moves the specified orchestra one the top of the orchestra list.
         * This method does nothing if <code>orchestra</code> is <code>null</code>,
         * the orchestra list does not contain the specified orchestra,
         * or if the orchestra is already on the top.
         * @param orchestra The orchestra to move on top.
         */
        @Override
        public void
        moveOrchestraOnTop(OrchestraModel orchestra) {
                if(orchestra == null) return;
                
                int idx = getOrchestraIndex(orchestra);
                if(idx <= 0) return;
                
                removeOrchestra(idx);
                insertOrchestra(orchestra, 0);
        }
        
        /**
         * Moves the specified orchestra one position up in the orchestra list.
         * This method does nothing if <code>orchestra</code> is <code>null</code>,
         * the orchestra list does not contain the specified orchestra,
         * or if the orchestra is already on the top.
         * @param orchestra The orchestra to move up.
         */
        @Override
        public void
        moveOrchestraUp(OrchestraModel orchestra) {
                if(orchestra == null) return;
                
                int idx = getOrchestraIndex(orchestra);
                if(idx <= 0) return;
                
                removeOrchestra(idx);
                insertOrchestra(orchestra, idx - 1);
        }
        
        /**
         * Moves the specified orchestra one position down in the orchestra list.
         * This method does nothing if <code>orchestra</code> is <code>null</code>,
         * the orchestra list does not contain the specified orchestra,
         * or if the orchestra is already at the bottom.
         * @param orchestra The orchestra to move down.
         */
        @Override
        public void
        moveOrchestraDown(OrchestraModel orchestra) {
                if(orchestra == null) return;
                
                int idx = getOrchestraIndex(orchestra);
                if(idx < 0 || idx == getOrchestraCount() - 1) return;
                removeOrchestra(idx);
                insertOrchestra(orchestra, idx + 1);
        }
        
        /**
         * Moves the specified orchestra at the bottom of the orchestra list.
         * This method does nothing if <code>orchestra</code> is <code>null</code>,
         * the orchestra list does not contain the specified orchestra,
         * or if the orchestra is already at the bottom.
         * @param orchestra The orchestra to move at bottom.
         */
        @Override
        public void
        moveOrchestraAtBottom(OrchestraModel orchestra) {
                if(orchestra == null) return;
                
                int idx = getOrchestraIndex(orchestra);
                if(idx < 0 || idx == getOrchestraCount() - 1) return;
                
                removeOrchestra(idx);
                insertOrchestra(orchestra, getOrchestraCount());
        }
        
        /**
         * Reads and loads the content provided by <code>node</code> to this orchestra list.
         * @param node The node providing the content of this orchestra list.
         * @throws IllegalArgumentException If an error occurs while
         * reading the content of this orchestra list.
         */
        @Override
        public void
        readObject(Node node) {
                if(
                        node.getNodeType() != Node.ELEMENT_NODE ||
                        !(node.getNodeName().equals("orchestras"))
                ) {
                        throw new IllegalArgumentException("Not an orchestra list node!");
                }
                
                NodeList nl = node.getChildNodes();
                
                for(int i = 0; i < nl.getLength(); i++) {
                        node = nl.item(i);
                        if(node.getNodeType() != Node.ELEMENT_NODE) continue;
                        
                        OrchestraModel om = new DefaultOrchestraModel();
                        om.readObject(node);
                        addOrchestra(om);
                }
        }
        
        /**
         * Writes the content of this orchestra list to the
         * specified node of document <code>doc</code>.
         * @param doc The document containing <code>node</code>.
         * @param node Specifies the node where the content of this orchestra
         * list should be written.
         */
        @Override
        public void
        writeObject(Document doc, Node node) {
                Element el = doc.createElement("orchestras");
                node.appendChild(el);
                                
                node = el;
                
                for(int i = 0; i < getOrchestraCount(); i++) {
                        getOrchestra(i).writeObject(doc, node);
                }
        }
        
        /** Notifies listeners that an orchestra has been added to the list. */
        private void
        fireOrchestraAdded(OrchestraModel orchestraModel) {
                ListEvent<OrchestraModel> e = new ListEvent<OrchestraModel>(this, orchestraModel);
                for(ListListener<OrchestraModel> l : listeners) l.entryAdded(e);
        }
        
        /** Notifies listeners that an orchestra has been removed from the list. */
        private void
        fireOrchestraRemoved(OrchestraModel orchestraModel) {
                ListEvent<OrchestraModel> e = new ListEvent<OrchestraModel>(this, orchestraModel);
                for(ListListener<OrchestraModel> l : listeners) l.entryRemoved(e);
        }
}
1	iliev	912	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4	iliev	2288	* Copyright (C) 2005-2011 Grigor Iliev <grigor@grigoriliev.com>
5	iliev	912	*
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;
24
25			import java.util.Vector;
26
27	iliev	1143	import org.jsampler.event.ListEvent;
28			import org.jsampler.event.ListListener;
29	iliev	912
30			import org.w3c.dom.Document;
31			import org.w3c.dom.Element;
32			import org.w3c.dom.Node;
33			import org.w3c.dom.NodeList;
34
35
36			/**
37			* This class provides default implementation of the <code>OrchestraListModel</code> interface.
38			* @author Grigor Iliev
39			*/
40			public class DefaultOrchestraListModel implements OrchestraListModel {
41			private final Vector<OrchestraModel> orchestras = new Vector<OrchestraModel>();
42	iliev	1143	private final Vector<ListListener<OrchestraModel>> listeners =
43			new Vector<ListListener<OrchestraModel>>();
44	iliev	912
45
46			/** Creates a new instance of <code>DefaultOrchestraListModel</code>. */
47			public
48			DefaultOrchestraListModel() {
49
50			}
51
52			/**
53			* Registers the specified listener for receiving event messages.
54			* @param l The <code>OrchestraListListener</code> to register.
55			*/
56	iliev	2288	@Override
57	iliev	912	public void
58	iliev	1143	addOrchestraListListener(ListListener<OrchestraModel> l) { listeners.add(l); }
59	iliev	912
60			/**
61			* Removes the specified listener.
62			* @param l The <code>OrchestraListListener</code> to remove.
63			*/
64	iliev	2288	@Override
65	iliev	912	public void
66	iliev	1143	removeOrchestraListListener(ListListener<OrchestraModel> l) { listeners.remove(l); }
67	iliev	912
68			/**
69			* Gets the current number of orchestras in the list.
70			* @return The current number of orchestras in the list.
71			*/
72	iliev	2288	@Override
73	iliev	912	public int
74			getOrchestraCount() { return orchestras.size(); }
75
76			/**
77			* Gets the orchestra at the specified position.
78			* @param idx The index of the orchestra to be returned.
79			* @return The orchestra at the specified position.
80			*/
81	iliev	2288	@Override
82	iliev	912	public OrchestraModel
83			getOrchestra(int idx) { return orchestras.get(idx); }
84
85			/**
86			* Adds the specified orchestra to the list.
87			* @param orchestra The model of the orchestra to be added.
88			* @throws IllegalArgumentException If <code>orchestra</code> is <code>null</code>.
89			*/
90	iliev	2288	@Override
91	iliev	912	public void
92			addOrchestra(OrchestraModel orchestra) {
93			insertOrchestra(orchestra, getOrchestraCount());
94			}
95
96			/**
97			* Inserts the specified orchestra at the specified position.
98			* @param orchestra The orchestra to be inserted.
99			* @param idx The position of the orchestra.
100			* @throws IllegalArgumentException If <code>orchestra</code> is <code>null</code>.
101			* @throws ArrayIndexOutOfBoundsException If the specified index is invalid.
102			*/
103	iliev	2288	@Override
104	iliev	912	public void
105			insertOrchestra(OrchestraModel orchestra, int idx) {
106			if(orchestra == null)
107			throw new IllegalArgumentException("orchestra should be non-null!");
108
109			orchestras.insertElementAt(orchestra, idx);
110			fireOrchestraAdded(orchestra);
111			}
112
113			/**
114			* Removes the specified orchestra from the list.
115			* @param idx The index of the orchestra to remove.
116			*/
117	iliev	2288	@Override
118	iliev	912	public void
119			removeOrchestra(int idx) {
120			OrchestraModel orchestraModel = orchestras.get(idx);
121			orchestras.removeElementAt(idx);
122			fireOrchestraRemoved(orchestraModel);
123			}
124
125			/**
126			* Removes the specified orchestra from the list.
127			* @param orchestraModel The model of the orchestra to remove.
128			* @return <code>true</code> if the specified orchestra was in the list,
129			* <code>false</code> otherwise.
130			*/
131	iliev	2288	@Override
132	iliev	912	public boolean
133			removeOrchestra(OrchestraModel orchestraModel) {
134			boolean b = orchestras.removeElement(orchestraModel);
135			if(b) fireOrchestraRemoved(orchestraModel);
136			return b;
137			}
138
139	iliev	1143	/** Removes all orchestras from the list. */
140	iliev	2288	@Override
141	iliev	1143	public void
142			removeAllOrchestras() {
143			for(int i = 0; i < getOrchestraCount(); i++) removeOrchestra(i);
144			}
145
146	iliev	912	/**
147			* Gets the position of the specified orchestra in this orchestra list.
148			* @param orchestra The orchestra whose index should be returned.
149			* @return The position of the specified orchestra in this orchestra list,
150			* and -1 if <code>orchestra</code> is <code>null</code> or
151			* the orchestra list does not contain the specified orchestra.
152			*/
153	iliev	2288	@Override
154	iliev	912	public int
155			getOrchestraIndex(OrchestraModel orchestra) {
156			if(orchestra == null) return -1;
157
158			for(int i = 0; i < getOrchestraCount(); i++) {
159			if(getOrchestra(i) == orchestra) return i;
160			}
161
162			return -1;
163			}
164
165			/**
166			* Moves the specified orchestra one the top of the orchestra list.
167			* This method does nothing if <code>orchestra</code> is <code>null</code>,
168			* the orchestra list does not contain the specified orchestra,
169			* or if the orchestra is already on the top.
170			* @param orchestra The orchestra to move on top.
171			*/
172	iliev	2288	@Override
173	iliev	912	public void
174			moveOrchestraOnTop(OrchestraModel orchestra) {
175			if(orchestra == null) return;
176
177			int idx = getOrchestraIndex(orchestra);
178			if(idx <= 0) return;
179
180			removeOrchestra(idx);
181			insertOrchestra(orchestra, 0);
182			}
183
184			/**
185			* Moves the specified orchestra one position up in the orchestra list.
186			* This method does nothing if <code>orchestra</code> is <code>null</code>,
187			* the orchestra list does not contain the specified orchestra,
188			* or if the orchestra is already on the top.
189			* @param orchestra The orchestra to move up.
190			*/
191	iliev	2288	@Override
192	iliev	912	public void
193			moveOrchestraUp(OrchestraModel orchestra) {
194			if(orchestra == null) return;
195
196			int idx = getOrchestraIndex(orchestra);
197			if(idx <= 0) return;
198
199			removeOrchestra(idx);
200			insertOrchestra(orchestra, idx - 1);
201			}
202
203			/**
204			* Moves the specified orchestra one position down in the orchestra list.
205			* This method does nothing if <code>orchestra</code> is <code>null</code>,
206			* the orchestra list does not contain the specified orchestra,
207			* or if the orchestra is already at the bottom.
208			* @param orchestra The orchestra to move down.
209			*/
210	iliev	2288	@Override
211	iliev	912	public void
212			moveOrchestraDown(OrchestraModel orchestra) {
213			if(orchestra == null) return;
214
215			int idx = getOrchestraIndex(orchestra);
216			if(idx < 0 \|\| idx == getOrchestraCount() - 1) return;
217			removeOrchestra(idx);
218			insertOrchestra(orchestra, idx + 1);
219			}
220
221			/**
222			* Moves the specified orchestra at the bottom of the orchestra list.
223			* This method does nothing if <code>orchestra</code> is <code>null</code>,
224			* the orchestra list does not contain the specified orchestra,
225			* or if the orchestra is already at the bottom.
226			* @param orchestra The orchestra to move at bottom.
227			*/
228	iliev	2288	@Override
229	iliev	912	public void
230			moveOrchestraAtBottom(OrchestraModel orchestra) {
231			if(orchestra == null) return;
232
233			int idx = getOrchestraIndex(orchestra);
234			if(idx < 0 \|\| idx == getOrchestraCount() - 1) return;
235
236			removeOrchestra(idx);
237			insertOrchestra(orchestra, getOrchestraCount());
238			}
239
240			/**
241			* Reads and loads the content provided by <code>node</code> to this orchestra list.
242			* @param node The node providing the content of this orchestra list.
243			* @throws IllegalArgumentException If an error occurs while
244			* reading the content of this orchestra list.
245			*/
246	iliev	2288	@Override
247	iliev	912	public void
248			readObject(Node node) {
249			if(
250			node.getNodeType() != Node.ELEMENT_NODE \|\|
251			!(node.getNodeName().equals("orchestras"))
252			) {
253			throw new IllegalArgumentException("Not an orchestra list node!");
254			}
255
256			NodeList nl = node.getChildNodes();
257
258			for(int i = 0; i < nl.getLength(); i++) {
259			node = nl.item(i);
260			if(node.getNodeType() != Node.ELEMENT_NODE) continue;
261
262			OrchestraModel om = new DefaultOrchestraModel();
263			om.readObject(node);
264			addOrchestra(om);
265			}
266			}
267
268			/**
269			* Writes the content of this orchestra list to the
270			* specified node of document <code>doc</code>.
271			* @param doc The document containing <code>node</code>.
272			* @param node Specifies the node where the content of this orchestra
273			* list should be written.
274			*/
275	iliev	2288	@Override
276	iliev	912	public void
277			writeObject(Document doc, Node node) {
278			Element el = doc.createElement("orchestras");
279			node.appendChild(el);
280
281			node = el;
282
283			for(int i = 0; i < getOrchestraCount(); i++) {
284			getOrchestra(i).writeObject(doc, node);
285			}
286			}
287
288			/** Notifies listeners that an orchestra has been added to the list. */
289			private void
290			fireOrchestraAdded(OrchestraModel orchestraModel) {
291	iliev	1143	ListEvent<OrchestraModel> e = new ListEvent<OrchestraModel>(this, orchestraModel);
292			for(ListListener<OrchestraModel> l : listeners) l.entryAdded(e);
293	iliev	912	}
294
295			/** Notifies listeners that an orchestra has been removed from the list. */
296			private void
297			fireOrchestraRemoved(OrchestraModel orchestraModel) {
298	iliev	1143	ListEvent<OrchestraModel> e = new ListEvent<OrchestraModel>(this, orchestraModel);
299			for(ListListener<OrchestraModel> l : listeners) l.entryRemoved(e);
300	iliev	912	}
301			}