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 <QMetaType>
#include <QItemDelegate>
#include <QFontMetrics>
#include <QModelIndex>
#include <QSize>
#include <QList>
#include <Q3PtrList>

#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 Q3PtrList<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;
};

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