trunk/src/qsamplerDevice.h

// qsamplerDevice.h
//
/****************************************************************************
   Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
   Copyright (C) 2007, Christian Schoenebeck

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   This program 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 this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*****************************************************************************/

#ifndef __qsamplerDevice_h
#define __qsamplerDevice_h

#include <QListWidget>
#include <QListWidgetItem>
#include <QTreeWidgetItem>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QAbstractTableModel>
#include <QItemDelegate>
#include <QFontMetrics>
#include <QModelIndex>
#include <QSize>
#include <QList>

#include <lscp/client.h>
#include <lscp/device.h>

#include "qsamplerOptions.h"


// Special QListViewItem::rtti() unique return value.
#define QSAMPLER_DEVICE_ITEM    1001

// Early forward declarations.
class qsamplerMainForm;
class qsamplerDevicePort;


//-------------------------------------------------------------------------
// qsamplerDeviceParam - MIDI/Audio Device parameter structure.
//
class qsamplerDeviceParam
{
public:

        // Constructor.
        qsamplerDeviceParam(lscp_param_info_t *pParamInfo = NULL,
                const char *pszValue = NULL);
        // Default destructor.
        ~qsamplerDeviceParam();

        // Initializer.
        void setParam(lscp_param_info_t *pParamInfo,
                const char *pszValue = NULL);

        // Info structure field members.
        lscp_type_t     type;
        QString         description;
        bool            mandatory;
        bool            fix;
        bool            multiplicity;
        QStringList depends;
        QString         defaultv;
        QString         range_min;
        QString         range_max;
        QStringList possibilities;
        // The current parameter value.
        QString         value;
};

// Typedef'd parameter QMap.
typedef QMap<QString, qsamplerDeviceParam> qsamplerDeviceParamMap;

// Typedef'd device port/channels QptrList.
typedef QList<qsamplerDevicePort *> qsamplerDevicePortList;


//-------------------------------------------------------------------------
// qsamplerDevice - MIDI/Audio Device structure.
//

class qsamplerDevice
{
public:

        // We use the same class for MIDI and audio device management
        enum qsamplerDeviceType { None, Midi, Audio };

        // Constructor.
        qsamplerDevice(qsamplerDeviceType deviceType, int iDeviceID = -1);
        // Copy constructor.
    qsamplerDevice(const qsamplerDevice& device);
        // Default destructor.
        ~qsamplerDevice();

        // Initializer.
        void setDevice(qsamplerDeviceType deviceType, int iDeviceID = -1);

        // Driver name initializer.
        void setDriver(const QString& sDriverName);

        // Device property accessors.
        int                 deviceID()   const;
        qsamplerDeviceType  deviceType() const;
        const QString&      deviceTypeName() const;
        const QString&      driverName() const;
        // Special device name formatter.
        QString deviceName() const;

        // Set the proper device parameter value.
        bool setParam (const QString& sParam, const QString& sValue);

        // Device parameters accessor.
        const qsamplerDeviceParamMap& params() const;

        // Device port/channel list accessor.
        qsamplerDevicePortList& ports();

        // Device parameter dependency list refreshner.
        int refreshParams();
        // Device port/channel list refreshner.
        int refreshPorts();
        // Refresh/set dependencies given that some parameter has changed.
        int refreshDepends(const QString& sParam);

        // Create/destroy device methods.
        bool createDevice();
        bool deleteDevice();

        // Message logging methods (brainlessly mapped to main form's).
        void appendMessages       (const QString& s) const;
        void appendMessagesColor  (const QString& s, const QString & c) const;
        void appendMessagesText   (const QString& s) const;
        void appendMessagesError  (const QString& s) const;
        void appendMessagesClient (const QString& s) const;

        // Device ids enumerator.
        static int *getDevices(lscp_client_t *pClient,
                qsamplerDeviceType deviceType);

        // Driver names enumerator.
        static QStringList getDrivers(lscp_client_t *pClient,
                qsamplerDeviceType deviceType);

private:

        // Refresh/set given parameter based on driver supplied dependencies.
        int refreshParam(const QString& sParam);

        // Main application form reference.
        qsamplerMainForm  *m_pMainForm;

        // Instance variables.
        int                m_iDeviceID;
        qsamplerDeviceType m_deviceType;
        QString            m_sDeviceType;
        QString            m_sDriverName;
        QString            m_sDeviceName;

        // Device parameter list.
        qsamplerDeviceParamMap m_params;

        // Device port/channel list.
        qsamplerDevicePortList m_ports;
};


//-------------------------------------------------------------------------
// qsamplerDevicePort - MIDI/Audio Device port/channel structure.
//

class qsamplerDevicePort
{
public:

        // Constructor.
        qsamplerDevicePort(qsamplerDevice& device, int iPortID);
        // Default destructor.
        ~qsamplerDevicePort();

        // Initializer.
        void setDevicePort(int iPortID);

        // Device port property accessors.
        int            portID()   const;
        const QString& portName() const;

        // Device port parameters accessor.
        const qsamplerDeviceParamMap& params() const;

        // Set the proper device port/channel parameter value.
        bool setParam (const QString& sParam, const QString& sValue);

private:

        // Device reference.
        qsamplerDevice& m_device;

        // Instance variables.
        int     m_iPortID;
        QString m_sPortName;

        // Device port parameter list.
        qsamplerDeviceParamMap m_params;
};


//-------------------------------------------------------------------------
// qsamplerDeviceItem - QListView device item.
//

class qsamplerDeviceItem : public QTreeWidgetItem
{
public:

        // Constructors.
        qsamplerDeviceItem(QTreeWidget* pTreeWidget,
                qsamplerDevice::qsamplerDeviceType deviceType);
        qsamplerDeviceItem(QTreeWidgetItem* pItem,
                qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID);
        // Default destructor.
        ~qsamplerDeviceItem();

        // Instance accessors.
        qsamplerDevice& device();

private:

        // Instance variables.
        qsamplerDevice m_device;
};

struct DeviceParameterRow {
    QString             name;
    qsamplerDeviceParam param;
    bool                alive; // whether these params refer to an existing device or for a device that is yet to be created
};

// so we can use it i.e. through QVariant
Q_DECLARE_METATYPE(DeviceParameterRow)

//-------------------------------------------------------------------------
// AbstractDeviceParamModel - data model base class for device parameters
//
class AbstractDeviceParamModel : public QAbstractTableModel {
        Q_OBJECT
    public:
        AbstractDeviceParamModel(QObject* parent = 0);

        // overridden methods from subclass(es)
        int rowCount(const QModelIndex& parent = QModelIndex()) const;
        int columnCount(const QModelIndex& parent = QModelIndex() ) const;
        QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
        Qt::ItemFlags flags(const QModelIndex& index) const;

        virtual void clear();

        void refresh(const qsamplerDeviceParamMap* params, bool bEditable);

    protected:
        const qsamplerDeviceParamMap* params;
        bool bEditable;
};

//-------------------------------------------------------------------------
// DeviceParamModel - data model for device parameters (used for QTableView)
//
class DeviceParamModel : public AbstractDeviceParamModel {
        Q_OBJECT
    public:
        DeviceParamModel(QObject* parent = 0);

        // overridden methods from subclass(es)
        QVariant data(const QModelIndex &index, int role) const;
        bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
        void clear();

    public slots:
        void refresh(qsamplerDevice* pDevice, bool bEditable);

    private:
        qsamplerDevice* device;
};

//-------------------------------------------------------------------------
// PortParamModel - data model for port parameters (used for QTableView)
//
class PortParamModel : public AbstractDeviceParamModel {
        Q_OBJECT
    public:
        PortParamModel(QObject* parent = 0);

        // overridden methods from subclass(es)
        QVariant data(const QModelIndex &index, int role) const;
        bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
        void clear();

    public slots:
        void refresh(qsamplerDevicePort* pPort, bool bEditable);

    private:
        qsamplerDevicePort* port;
};

//-------------------------------------------------------------------------
// DeviceParamDelegate - table cell renderer for device/port parameters
//
class DeviceParamDelegate : public QItemDelegate {
        Q_OBJECT
    public:
        DeviceParamDelegate(QObject* parent = 0);
        QWidget* createEditor(QWidget* parent,
                              const QStyleOptionViewItem& option,
                              const QModelIndex& index) const;
        void setEditorData(QWidget* editor, const QModelIndex& index) const;
        void setModelData(QWidget* editor, QAbstractItemModel* model,
                          const QModelIndex& index) const;
        void updateEditorGeometry(QWidget* editor,
                                  const QStyleOptionViewItem& option,
                                  const QModelIndex& index) const;
};

#endif  // __qsamplerDevice_h

// end of qsamplerDevice.h
1	capela	426	// qsamplerDevice.h
2			//
3			/****************************************************************************
4	schoenebeck	1461	Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5	capela	1464	Copyright (C) 2007, Christian Schoenebeck
6	capela	426
7			This program is free software; you can redistribute it and/or
8			modify it under the terms of the GNU General Public License
9			as published by the Free Software Foundation; either version 2
10			of the License, or (at your option) any later version.
11
12			This program 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	capela	920	You should have received a copy of the GNU General Public License along
18			with this program; if not, write to the Free Software Foundation, Inc.,
19			51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20	capela	426
21			*****************************************************************************/
22
23			#ifndef __qsamplerDevice_h
24			#define __qsamplerDevice_h
25
26	schoenebeck	1461	#include <QListWidget>
27			#include <QListWidgetItem>
28			#include <QTreeWidgetItem>
29			#include <QTableWidget>
30			#include <QTableWidgetItem>
31			#include <QAbstractTableModel>
32			#include <QItemDelegate>
33			#include <QFontMetrics>
34			#include <QModelIndex>
35			#include <QSize>
36			#include <QList>
37	capela	426
38			#include <lscp/client.h>
39			#include <lscp/device.h>
40
41			#include "qsamplerOptions.h"
42
43
44	capela	430	// Special QListViewItem::rtti() unique return value.
45	capela	429	#define QSAMPLER_DEVICE_ITEM 1001
46
47	capela	484	// Early forward declarations.
48			class qsamplerMainForm;
49	capela	463	class qsamplerDevicePort;
50	capela	429
51	capela	463
52	capela	426	//-------------------------------------------------------------------------
53	capela	429	// qsamplerDeviceParam - MIDI/Audio Device parameter structure.
54	capela	426	//
55	capela	429	class qsamplerDeviceParam
56			{
57			public:
58	capela	426
59	capela	431	// Constructor.
60			qsamplerDeviceParam(lscp_param_info_t *pParamInfo = NULL,
61	capela	429	const char *pszValue = NULL);
62	capela	431	// Default destructor.
63			~qsamplerDeviceParam();
64	capela	429
65			// Initializer.
66			void setParam(lscp_param_info_t *pParamInfo,
67			const char *pszValue = NULL);
68
69	capela	431	// Info structure field members.
70			lscp_type_t type;
71			QString description;
72			bool mandatory;
73			bool fix;
74			bool multiplicity;
75			QStringList depends;
76			QString defaultv;
77			QString range_min;
78			QString range_max;
79			QStringList possibilities;
80			// The current parameter value.
81			QString value;
82	capela	429	};
83
84	capela	463	// Typedef'd parameter QMap.
85	capela	429	typedef QMap<QString, qsamplerDeviceParam> qsamplerDeviceParamMap;
86
87	capela	463	// Typedef'd device port/channels QptrList.
88	capela	1499	typedef QList<qsamplerDevicePort *> qsamplerDevicePortList;
89	capela	429
90	capela	463
91	capela	429	//-------------------------------------------------------------------------
92			// qsamplerDevice - MIDI/Audio Device structure.
93			//
94
95			class qsamplerDevice
96	capela	426	{
97	capela	429	public:
98
99	capela	431	// We use the same class for MIDI and audio device management
100	capela	436	enum qsamplerDeviceType { None, Midi, Audio };
101	capela	429
102	capela	431	// Constructor.
103	capela	961	qsamplerDevice(qsamplerDeviceType deviceType, int iDeviceID = -1);
104	capela	484	// Copy constructor.
105			qsamplerDevice(const qsamplerDevice& device);
106	capela	431	// Default destructor.
107			~qsamplerDevice();
108	capela	429
109			// Initializer.
110	capela	484	void setDevice(qsamplerDeviceType deviceType, int iDeviceID = -1);
111	capela	431
112			// Driver name initializer.
113	capela	484	void setDriver(const QString& sDriverName);
114	capela	431
115	capela	429	// Device property accessors.
116	capela	431	int deviceID() const;
117			qsamplerDeviceType deviceType() const;
118	capela	433	const QString& deviceTypeName() const;
119	capela	431	const QString& driverName() const;
120	capela	484	// Special device name formatter.
121			QString deviceName() const;
122	capela	429
123	capela	463	// Set the proper device parameter value.
124	capela	484	bool setParam (const QString& sParam, const QString& sValue);
125	capela	463
126	capela	429	// Device parameters accessor.
127	capela	462	const qsamplerDeviceParamMap& params() const;
128	capela	429
129	capela	463	// Device port/channel list accessor.
130			qsamplerDevicePortList& ports();
131	capela	429
132	capela	467	// Device parameter dependency list refreshner.
133	capela	484	int refreshParams();
134	capela	463	// Device port/channel list refreshner.
135	capela	484	int refreshPorts();
136	capela	467	// Refresh/set dependencies given that some parameter has changed.
137	capela	484	int refreshDepends(const QString& sParam);
138	capela	467
139	capela	484	// Create/destroy device methods.
140			bool createDevice();
141			bool deleteDevice();
142
143			// Message logging methods (brainlessly mapped to main form's).
144			void appendMessages (const QString& s) const;
145			void appendMessagesColor (const QString& s, const QString & c) const;
146			void appendMessagesText (const QString& s) const;
147			void appendMessagesError (const QString& s) const;
148			void appendMessagesClient (const QString& s) const;
149
150	capela	430	// Device ids enumerator.
151	capela	431	static int getDevices(lscp_client_t pClient,
152	capela	429	qsamplerDeviceType deviceType);
153
154	capela	430	// Driver names enumerator.
155	capela	431	static QStringList getDrivers(lscp_client_t *pClient,
156	capela	430	qsamplerDeviceType deviceType);
157
158	capela	429	private:
159
160	capela	467	// Refresh/set given parameter based on driver supplied dependencies.
161	capela	484	int refreshParam(const QString& sParam);
162	capela	467
163	capela	484	// Main application form reference.
164			qsamplerMainForm *m_pMainForm;
165
166	capela	429	// Instance variables.
167	capela	431	int m_iDeviceID;
168			qsamplerDeviceType m_deviceType;
169	capela	433	QString m_sDeviceType;
170	capela	431	QString m_sDriverName;
171			QString m_sDeviceName;
172	capela	429
173			// Device parameter list.
174			qsamplerDeviceParamMap m_params;
175	capela	492
176	capela	463	// Device port/channel list.
177			qsamplerDevicePortList m_ports;
178	capela	429	};
179
180
181			//-------------------------------------------------------------------------
182	capela	462	// qsamplerDevicePort - MIDI/Audio Device port/channel structure.
183			//
184
185			class qsamplerDevicePort
186			{
187			public:
188
189			// Constructor.
190	capela	484	qsamplerDevicePort(qsamplerDevice& device, int iPortID);
191	capela	462	// Default destructor.
192			~qsamplerDevicePort();
193
194			// Initializer.
195	capela	484	void setDevicePort(int iPortID);
196	capela	462
197			// Device port property accessors.
198			int portID() const;
199			const QString& portName() const;
200
201			// Device port parameters accessor.
202			const qsamplerDeviceParamMap& params() const;
203
204			// Set the proper device port/channel parameter value.
205	capela	484	bool setParam (const QString& sParam, const QString& sValue);
206	capela	462
207			private:
208
209	capela	484	// Device reference.
210			qsamplerDevice& m_device;
211	capela	492
212	capela	462	// Instance variables.
213			int m_iPortID;
214			QString m_sPortName;
215
216			// Device port parameter list.
217			qsamplerDeviceParamMap m_params;
218			};
219
220
221			//-------------------------------------------------------------------------
222	capela	429	// qsamplerDeviceItem - QListView device item.
223			//
224
225	schoenebeck	1461	class qsamplerDeviceItem : public QTreeWidgetItem
226	capela	429	{
227			public:
228
229	capela	431	// Constructors.
230	schoenebeck	1461	qsamplerDeviceItem(QTreeWidget* pTreeWidget,
231	capela	429	qsamplerDevice::qsamplerDeviceType deviceType);
232	schoenebeck	1461	qsamplerDeviceItem(QTreeWidgetItem* pItem,
233	capela	429	qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID);
234	capela	431	// Default destructor.
235			~qsamplerDeviceItem();
236	capela	429
237	capela	431	// Instance accessors.
238			qsamplerDevice& device();
239	capela	429
240			private:
241
242	capela	431	// Instance variables.
243			qsamplerDevice m_device;
244	capela	429	};
245
246	schoenebeck	1461	struct DeviceParameterRow {
247			QString name;
248			qsamplerDeviceParam param;
249	schoenebeck	1508	bool alive; // whether these params refer to an existing device or for a device that is yet to be created
250	schoenebeck	1461	};
251	capela	426
252	schoenebeck	1461	// so we can use it i.e. through QVariant
253			Q_DECLARE_METATYPE(DeviceParameterRow)
254
255	schoenebeck	1486	//-------------------------------------------------------------------------
256			// AbstractDeviceParamModel - data model base class for device parameters
257			//
258			class AbstractDeviceParamModel : public QAbstractTableModel {
259	schoenebeck	1461	Q_OBJECT
260			public:
261	schoenebeck	1486	AbstractDeviceParamModel(QObject* parent = 0);
262	schoenebeck	1461
263			// overridden methods from subclass(es)
264	schoenebeck	1486	int rowCount(const QModelIndex& parent = QModelIndex()) const;
265			int columnCount(const QModelIndex& parent = QModelIndex() ) const;
266	schoenebeck	1461	QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
267	schoenebeck	1486	Qt::ItemFlags flags(const QModelIndex& index) const;
268	schoenebeck	1461
269	schoenebeck	1486	virtual void clear();
270	schoenebeck	1461
271	schoenebeck	1486	void refresh(const qsamplerDeviceParamMap* params, bool bEditable);
272	schoenebeck	1461
273	schoenebeck	1486	protected:
274			const qsamplerDeviceParamMap* params;
275	schoenebeck	1461	bool bEditable;
276			};
277
278	schoenebeck	1486	//-------------------------------------------------------------------------
279			// DeviceParamModel - data model for device parameters (used for QTableView)
280			//
281			class DeviceParamModel : public AbstractDeviceParamModel {
282	schoenebeck	1461	Q_OBJECT
283			public:
284	schoenebeck	1486	DeviceParamModel(QObject* parent = 0);
285	schoenebeck	1461
286	schoenebeck	1486	// overridden methods from subclass(es)
287	schoenebeck	1508	QVariant data(const QModelIndex &index, int role) const;
288	schoenebeck	1486	bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
289			void clear();
290	schoenebeck	1461
291	schoenebeck	1486	public slots:
292			void refresh(qsamplerDevice* pDevice, bool bEditable);
293	schoenebeck	1461
294	schoenebeck	1486	private:
295			qsamplerDevice* device;
296	schoenebeck	1461	};
297
298	capela	442	//-------------------------------------------------------------------------
299	schoenebeck	1486	// PortParamModel - data model for port parameters (used for QTableView)
300	capela	442	//
301	schoenebeck	1486	class PortParamModel : public AbstractDeviceParamModel {
302			Q_OBJECT
303			public:
304			PortParamModel(QObject* parent = 0);
305	capela	442
306	schoenebeck	1486	// overridden methods from subclass(es)
307	schoenebeck	1508	QVariant data(const QModelIndex &index, int role) const;
308	schoenebeck	1486	bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
309			void clear();
310	capela	442
311	schoenebeck	1486	public slots:
312			void refresh(qsamplerDevicePort* pPort, bool bEditable);
313	capela	442
314	schoenebeck	1486	private:
315			qsamplerDevicePort* port;
316	capela	442	};
317
318			//-------------------------------------------------------------------------
319	schoenebeck	1486	// DeviceParamDelegate - table cell renderer for device/port parameters
320	capela	442	//
321	schoenebeck	1486	class DeviceParamDelegate : public QItemDelegate {
322			Q_OBJECT
323			public:
324			DeviceParamDelegate(QObject* parent = 0);
325			QWidget* createEditor(QWidget* parent,
326			const QStyleOptionViewItem& option,
327			const QModelIndex& index) const;
328			void setEditorData(QWidget* editor, const QModelIndex& index) const;
329			void setModelData(QWidget* editor, QAbstractItemModel* model,
330			const QModelIndex& index) const;
331			void updateEditorGeometry(QWidget* editor,
332			const QStyleOptionViewItem& option,
333			const QModelIndex& index) const;
334	capela	442	};
335
336	capela	426	#endif // __qsamplerDevice_h
337
338			// end of qsamplerDevice.h