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

// 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 <QItemDelegate>
33	#include <QFontMetrics>
34	#include <QModelIndex>
35	#include <QSize>
36	#include <QList>
37
38	#include <lscp/client.h>
39	#include <lscp/device.h>
40
41	#include "qsamplerOptions.h"
42
43
44	// Special QListViewItem::rtti() unique return value.
45	#define QSAMPLER_DEVICE_ITEM 1001
46
47	// Early forward declarations.
48	class qsamplerMainForm;
49	class qsamplerDevicePort;
50
51
52	//-------------------------------------------------------------------------
53	// qsamplerDeviceParam - MIDI/Audio Device parameter structure.
54	//
55	class qsamplerDeviceParam
56	{
57	public:
58
59	// Constructor.
60	qsamplerDeviceParam(lscp_param_info_t *pParamInfo = NULL,
61	const char *pszValue = NULL);
62	// Default destructor.
63	~qsamplerDeviceParam();
64
65	// Initializer.
66	void setParam(lscp_param_info_t *pParamInfo,
67	const char *pszValue = NULL);
68
69	// 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	};
83
84	// Typedef'd parameter QMap.
85	typedef QMap<QString, qsamplerDeviceParam> qsamplerDeviceParamMap;
86
87	// Typedef'd device port/channels QptrList.
88	typedef QList<qsamplerDevicePort *> qsamplerDevicePortList;
89
90
91	//-------------------------------------------------------------------------
92	// qsamplerDevice - MIDI/Audio Device structure.
93	//
94
95	class qsamplerDevice
96	{
97	public:
98
99	// We use the same class for MIDI and audio device management
100	enum qsamplerDeviceType { None, Midi, Audio };
101
102	// Constructor.
103	qsamplerDevice(qsamplerDeviceType deviceType, int iDeviceID = -1);
104	// Copy constructor.
105	qsamplerDevice(const qsamplerDevice& device);
106	// Default destructor.
107	~qsamplerDevice();
108
109	// Initializer.
110	void setDevice(qsamplerDeviceType deviceType, int iDeviceID = -1);
111
112	// Driver name initializer.
113	void setDriver(const QString& sDriverName);
114
115	// Device property accessors.
116	int deviceID() const;
117	qsamplerDeviceType deviceType() const;
118	const QString& deviceTypeName() const;
119	const QString& driverName() const;
120	// Special device name formatter.
121	QString deviceName() const;
122
123	// Set the proper device parameter value.
124	bool setParam (const QString& sParam, const QString& sValue);
125
126	// Device parameters accessor.
127	const qsamplerDeviceParamMap& params() const;
128
129	// Device port/channel list accessor.
130	qsamplerDevicePortList& ports();
131
132	// Device parameter dependency list refreshner.
133	int refreshParams();
134	// Device port/channel list refreshner.
135	int refreshPorts();
136	// Refresh/set dependencies given that some parameter has changed.
137	int refreshDepends(const QString& sParam);
138
139	// 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	// Device ids enumerator.
151	static int getDevices(lscp_client_t pClient,
152	qsamplerDeviceType deviceType);
153
154	// Driver names enumerator.
155	static QStringList getDrivers(lscp_client_t *pClient,
156	qsamplerDeviceType deviceType);
157
158	private:
159
160	// Refresh/set given parameter based on driver supplied dependencies.
161	int refreshParam(const QString& sParam);
162
163	// Main application form reference.
164	qsamplerMainForm *m_pMainForm;
165
166	// Instance variables.
167	int m_iDeviceID;
168	qsamplerDeviceType m_deviceType;
169	QString m_sDeviceType;
170	QString m_sDriverName;
171	QString m_sDeviceName;
172
173	// Device parameter list.
174	qsamplerDeviceParamMap m_params;
175
176	// Device port/channel list.
177	qsamplerDevicePortList m_ports;
178	};
179
180
181	//-------------------------------------------------------------------------
182	// qsamplerDevicePort - MIDI/Audio Device port/channel structure.
183	//
184
185	class qsamplerDevicePort
186	{
187	public:
188
189	// Constructor.
190	qsamplerDevicePort(qsamplerDevice& device, int iPortID);
191	// Default destructor.
192	~qsamplerDevicePort();
193
194	// Initializer.
195	void setDevicePort(int iPortID);
196
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	bool setParam (const QString& sParam, const QString& sValue);
206
207	private:
208
209	// Device reference.
210	qsamplerDevice& m_device;
211
212	// 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	// qsamplerDeviceItem - QListView device item.
223	//
224
225	class qsamplerDeviceItem : public QTreeWidgetItem
226	{
227	public:
228
229	// Constructors.
230	qsamplerDeviceItem(QTreeWidget* pTreeWidget,
231	qsamplerDevice::qsamplerDeviceType deviceType);
232	qsamplerDeviceItem(QTreeWidgetItem* pItem,
233	qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID);
234	// Default destructor.
235	~qsamplerDeviceItem();
236
237	// Instance accessors.
238	qsamplerDevice& device();
239
240	private:
241
242	// Instance variables.
243	qsamplerDevice m_device;
244	};
245
246	struct DeviceParameterRow {
247	QString name;
248	qsamplerDeviceParam param;
249	};
250
251	// so we can use it i.e. through QVariant
252	Q_DECLARE_METATYPE(DeviceParameterRow)
253
254	//-------------------------------------------------------------------------
255	// AbstractDeviceParamModel - data model base class for device parameters
256	//
257	class AbstractDeviceParamModel : public QAbstractTableModel {
258	Q_OBJECT
259	public:
260	AbstractDeviceParamModel(QObject* parent = 0);
261
262	// overridden methods from subclass(es)
263	int rowCount(const QModelIndex& parent = QModelIndex()) const;
264	int columnCount(const QModelIndex& parent = QModelIndex() ) const;
265	QVariant data(const QModelIndex &index, int role) const;
266	QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
267	Qt::ItemFlags flags(const QModelIndex& index) const;
268
269	virtual void clear();
270
271	void refresh(const qsamplerDeviceParamMap* params, bool bEditable);
272
273	protected:
274	const qsamplerDeviceParamMap* params;
275	bool bEditable;
276	};
277
278	//-------------------------------------------------------------------------
279	// DeviceParamModel - data model for device parameters (used for QTableView)
280	//
281	class DeviceParamModel : public AbstractDeviceParamModel {
282	Q_OBJECT
283	public:
284	DeviceParamModel(QObject* parent = 0);
285
286	// overridden methods from subclass(es)
287	bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
288	void clear();
289
290	public slots:
291	void refresh(qsamplerDevice* pDevice, bool bEditable);
292
293	private:
294	qsamplerDevice* device;
295	};
296
297	//-------------------------------------------------------------------------
298	// PortParamModel - data model for port parameters (used for QTableView)
299	//
300	class PortParamModel : public AbstractDeviceParamModel {
301	Q_OBJECT
302	public:
303	PortParamModel(QObject* parent = 0);
304
305	// overridden methods from subclass(es)
306	bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
307	void clear();
308
309	public slots:
310	void refresh(qsamplerDevicePort* pPort, bool bEditable);
311
312	private:
313	qsamplerDevicePort* port;
314	};
315
316	//-------------------------------------------------------------------------
317	// DeviceParamDelegate - table cell renderer for device/port parameters
318	//
319	class DeviceParamDelegate : public QItemDelegate {
320	Q_OBJECT
321	public:
322	DeviceParamDelegate(QObject* parent = 0);
323	QWidget* createEditor(QWidget* parent,
324	const QStyleOptionViewItem& option,
325	const QModelIndex& index) const;
326	void setEditorData(QWidget* editor, const QModelIndex& index) const;
327	void setModelData(QWidget* editor, QAbstractItemModel* model,
328	const QModelIndex& index) const;
329	void updateEditorGeometry(QWidget* editor,
330	const QStyleOptionViewItem& option,
331	const QModelIndex& index) const;
332	};
333
334	#endif // __qsamplerDevice_h
335
336	// end of qsamplerDevice.h