trunk/src/qsamplerDevice.h

// qsamplerDevice.h
//
/****************************************************************************
   Copyright (C) 2005, rncbc aka Rui Nuno Capela. All rights reserved.

   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

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

#ifndef __qsamplerDevice_h
#define __qsamplerDevice_h

#include <qlistview.h>
#include <qtable.h>

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

#include "qsamplerOptions.h"


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


//-------------------------------------------------------------------------
// 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;
};

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


//-------------------------------------------------------------------------
// 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(lscp_client_t *pClient,
                qsamplerDeviceType deviceType, int iDeviceID = -1);
        // Default destructor.
        ~qsamplerDevice();

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

        // Driver name initializer.
        void setDriver(lscp_client_t *pClient,
                const QString& sDriverName);

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

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

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

        // 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:

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

        // Device parameter list.
        qsamplerDeviceParamMap m_params;
};


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

class qsamplerDevicePort
{
public:

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

        // Initializer.
        void setDevicePort(lscp_client_t *pClient,
                const qsamplerDevice& device, 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.
        void setParam (const QString& sParam, const QString& sValue);

private:

        // Instance variables.
        int     m_iPortID;
        QString m_sPortName;

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


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

class qsamplerDeviceItem : public QListViewItem
{
public:

        // Constructors.
        qsamplerDeviceItem(QListView *pListView, lscp_client_t *pClient,
                qsamplerDevice::qsamplerDeviceType deviceType);
        qsamplerDeviceItem(QListViewItem *pItem, lscp_client_t *pClient,
                qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID);
        // Default destructor.
        ~qsamplerDeviceItem();

        // Instance accessors.
        qsamplerDevice& device();

        // To virtually distinguish between list view items.
        virtual int rtti() const;

private:

        // Instance variables.
        qsamplerDevice m_device;
};


//-------------------------------------------------------------------------
// qsamplerDeviceParamTable - Device parameter view table.
//

class qsamplerDeviceParamTable : public QTable
{
        Q_OBJECT

public:

        // Constructor.
        qsamplerDeviceParamTable(QWidget *pParent = 0, const char *pszName = 0);
        // Default destructor.
        ~qsamplerDeviceParamTable();

        // Common parameter table renderer.
        void refresh(const qsamplerDeviceParamMap& params, bool bEditable);
};


//-------------------------------------------------------------------------
// qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
//

class qsamplerDeviceParamTableSpinBox : public QTableItem
{
public:

        // Constructor.
        qsamplerDeviceParamTableSpinBox (QTable *pTable, EditType editType,
                const QString& sText);

        // Public accessors.
        void setMinValue(int iMinValue);
        void setMaxValue(int iMaxValue);
        void setValue(int iValue);

protected:

        // Virtual implemetations.
        QWidget *createEditor() const;
        void setContentFromEditor(QWidget *pWidget);

private:

        // Initial value holders.
        int m_iValue;
        int m_iMinValue;
        int m_iMaxValue;
};


//-------------------------------------------------------------------------
// qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
//

class qsamplerDeviceParamTableEditBox : public QTableItem
{
public:

        // Constructor.
        qsamplerDeviceParamTableEditBox (QTable *pTable, EditType editType,
                const QString& sText);

protected:

        // Virtual implemetations.
        QWidget *createEditor() const;
        void setContentFromEditor(QWidget *pWidget);
};


#endif  // __qsamplerDevice_h


// end of qsamplerDevice.h
1	// qsamplerDevice.h
2	//
3	/****************************************************************************
4	Copyright (C) 2005, rncbc aka Rui Nuno Capela. All rights reserved.
5
6	This program is free software; you can redistribute it and/or
7	modify it under the terms of the GNU General Public License
8	as published by the Free Software Foundation; either version 2
9	of the License, or (at your option) any later version.
10
11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with this program; if not, write to the Free Software
18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20	*****************************************************************************/
21
22	#ifndef __qsamplerDevice_h
23	#define __qsamplerDevice_h
24
25	#include <qlistview.h>
26	#include <qtable.h>
27
28	#include <lscp/client.h>
29	#include <lscp/device.h>
30
31	#include "qsamplerOptions.h"
32
33
34	// Special QListViewItem::rtti() unique return value.
35	#define QSAMPLER_DEVICE_ITEM 1001
36
37
38	//-------------------------------------------------------------------------
39	// qsamplerDeviceParam - MIDI/Audio Device parameter structure.
40	//
41	class qsamplerDeviceParam
42	{
43	public:
44
45	// Constructor.
46	qsamplerDeviceParam(lscp_param_info_t *pParamInfo = NULL,
47	const char *pszValue = NULL);
48	// Default destructor.
49	~qsamplerDeviceParam();
50
51	// Initializer.
52	void setParam(lscp_param_info_t *pParamInfo,
53	const char *pszValue = NULL);
54
55	// Info structure field members.
56	lscp_type_t type;
57	QString description;
58	bool mandatory;
59	bool fix;
60	bool multiplicity;
61	QStringList depends;
62	QString defaultv;
63	QString range_min;
64	QString range_max;
65	QStringList possibilities;
66	// The current parameter value.
67	QString value;
68	};
69
70	// A typedef'd parameter QMap.
71	typedef QMap<QString, qsamplerDeviceParam> qsamplerDeviceParamMap;
72
73
74	//-------------------------------------------------------------------------
75	// qsamplerDevice - MIDI/Audio Device structure.
76	//
77
78	class qsamplerDevice
79	{
80	public:
81
82	// We use the same class for MIDI and audio device management
83	enum qsamplerDeviceType { None, Midi, Audio };
84
85	// Constructor.
86	qsamplerDevice(lscp_client_t *pClient,
87	qsamplerDeviceType deviceType, int iDeviceID = -1);
88	// Default destructor.
89	~qsamplerDevice();
90
91	// Initializer.
92	void setDevice(lscp_client_t *pClient,
93	qsamplerDeviceType deviceType, int iDeviceID = -1);
94
95	// Driver name initializer.
96	void setDriver(lscp_client_t *pClient,
97	const QString& sDriverName);
98
99	// Device property accessors.
100	int deviceID() const;
101	qsamplerDeviceType deviceType() const;
102	const QString& deviceTypeName() const;
103	const QString& driverName() const;
104	const QString& deviceName() const;
105
106	// Device parameters accessor.
107	const qsamplerDeviceParamMap& params() const;
108
109	// Set the proper device parameter value.
110	void setParam (const QString& sParam, const QString& sValue);
111
112	// Device ids enumerator.
113	static int getDevices(lscp_client_t pClient,
114	qsamplerDeviceType deviceType);
115
116	// Driver names enumerator.
117	static QStringList getDrivers(lscp_client_t *pClient,
118	qsamplerDeviceType deviceType);
119
120	private:
121
122	// Instance variables.
123	int m_iDeviceID;
124	qsamplerDeviceType m_deviceType;
125	QString m_sDeviceType;
126	QString m_sDriverName;
127	QString m_sDeviceName;
128
129	// Device parameter list.
130	qsamplerDeviceParamMap m_params;
131	};
132
133
134	//-------------------------------------------------------------------------
135	// qsamplerDevicePort - MIDI/Audio Device port/channel structure.
136	//
137
138	class qsamplerDevicePort
139	{
140	public:
141
142	// Constructor.
143	qsamplerDevicePort(lscp_client_t *pClient,
144	const qsamplerDevice& device, int iPortID);
145	// Default destructor.
146	~qsamplerDevicePort();
147
148	// Initializer.
149	void setDevicePort(lscp_client_t *pClient,
150	const qsamplerDevice& device, int iPortID);
151
152	// Device port property accessors.
153	int portID() const;
154	const QString& portName() const;
155
156	// Device port parameters accessor.
157	const qsamplerDeviceParamMap& params() const;
158
159	// Set the proper device port/channel parameter value.
160	void setParam (const QString& sParam, const QString& sValue);
161
162	private:
163
164	// Instance variables.
165	int m_iPortID;
166	QString m_sPortName;
167
168	// Device port parameter list.
169	qsamplerDeviceParamMap m_params;
170	};
171
172
173	//-------------------------------------------------------------------------
174	// qsamplerDeviceItem - QListView device item.
175	//
176
177	class qsamplerDeviceItem : public QListViewItem
178	{
179	public:
180
181	// Constructors.
182	qsamplerDeviceItem(QListView pListView, lscp_client_t pClient,
183	qsamplerDevice::qsamplerDeviceType deviceType);
184	qsamplerDeviceItem(QListViewItem pItem, lscp_client_t pClient,
185	qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID);
186	// Default destructor.
187	~qsamplerDeviceItem();
188
189	// Instance accessors.
190	qsamplerDevice& device();
191
192	// To virtually distinguish between list view items.
193	virtual int rtti() const;
194
195	private:
196
197	// Instance variables.
198	qsamplerDevice m_device;
199	};
200
201
202	//-------------------------------------------------------------------------
203	// qsamplerDeviceParamTable - Device parameter view table.
204	//
205
206	class qsamplerDeviceParamTable : public QTable
207	{
208	Q_OBJECT
209
210	public:
211
212	// Constructor.
213	qsamplerDeviceParamTable(QWidget pParent = 0, const char pszName = 0);
214	// Default destructor.
215	~qsamplerDeviceParamTable();
216
217	// Common parameter table renderer.
218	void refresh(const qsamplerDeviceParamMap& params, bool bEditable);
219	};
220
221
222	//-------------------------------------------------------------------------
223	// qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
224	//
225
226	class qsamplerDeviceParamTableSpinBox : public QTableItem
227	{
228	public:
229
230	// Constructor.
231	qsamplerDeviceParamTableSpinBox (QTable *pTable, EditType editType,
232	const QString& sText);
233
234	// Public accessors.
235	void setMinValue(int iMinValue);
236	void setMaxValue(int iMaxValue);
237	void setValue(int iValue);
238
239	protected:
240
241	// Virtual implemetations.
242	QWidget *createEditor() const;
243	void setContentFromEditor(QWidget *pWidget);
244
245	private:
246
247	// Initial value holders.
248	int m_iValue;
249	int m_iMinValue;
250	int m_iMaxValue;
251	};
252
253
254	//-------------------------------------------------------------------------
255	// qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
256	//
257
258	class qsamplerDeviceParamTableEditBox : public QTableItem
259	{
260	public:
261
262	// Constructor.
263	qsamplerDeviceParamTableEditBox (QTable *pTable, EditType editType,
264	const QString& sText);
265
266	protected:
267
268	// Virtual implemetations.
269	QWidget *createEditor() const;
270	void setContentFromEditor(QWidget *pWidget);
271	};
272
273
274	#endif // __qsamplerDevice_h
275
276
277	// end of qsamplerDevice.h