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 { 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&      driverName() const;
        const QString&      deviceName() const;

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

        // Update/refresh device/driver data.
        void refresh();

        // 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_sDriverName;
        QString            m_sDeviceName;

        // Device 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();

        // Client/device descriptor selector.
        void refresh(qsamplerDevice& device);
};


#endif  // __qsamplerDevice_h


// end of qsamplerDevice.h
1	capela	426	// qsamplerDevice.h
2			//
3			/****************************************************************************
4	capela	430	Copyright (C) 2005, rncbc aka Rui Nuno Capela. All rights reserved.
5	capela	426
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	capela	429	#include <qlistview.h>
26	capela	426	#include <qtable.h>
27
28			#include <lscp/client.h>
29			#include <lscp/device.h>
30
31			#include "qsamplerOptions.h"
32
33
34	capela	430	// Special QListViewItem::rtti() unique return value.
35	capela	429	#define QSAMPLER_DEVICE_ITEM 1001
36
37
38	capela	426	//-------------------------------------------------------------------------
39	capela	429	// qsamplerDeviceParam - MIDI/Audio Device parameter structure.
40	capela	426	//
41	capela	429	class qsamplerDeviceParam
42			{
43			public:
44	capela	426
45	capela	431	// Constructor.
46			qsamplerDeviceParam(lscp_param_info_t *pParamInfo = NULL,
47	capela	429	const char *pszValue = NULL);
48	capela	431	// Default destructor.
49			~qsamplerDeviceParam();
50	capela	429
51			// Initializer.
52			void setParam(lscp_param_info_t *pParamInfo,
53			const char *pszValue = NULL);
54
55	capela	431	// 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	capela	429	};
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	capela	426	{
80	capela	429	public:
81
82	capela	431	// We use the same class for MIDI and audio device management
83			enum qsamplerDeviceType { Midi, Audio };
84	capela	429
85	capela	431	// Constructor.
86			qsamplerDevice(lscp_client_t *pClient,
87	capela	429	qsamplerDeviceType deviceType, int iDeviceID = -1);
88	capela	431	// Default destructor.
89			~qsamplerDevice();
90	capela	429
91			// Initializer.
92			void setDevice(lscp_client_t *pClient,
93			qsamplerDeviceType deviceType, int iDeviceID = -1);
94	capela	431
95			// Driver name initializer.
96			void setDriver(lscp_client_t *pClient,
97			const QString& sDriverName);
98
99	capela	429	// Device property accessors.
100	capela	431	int deviceID() const;
101			qsamplerDeviceType deviceType() const;
102			const QString& driverName() const;
103			const QString& deviceName() const;
104	capela	429
105			// Device parameters accessor.
106			qsamplerDeviceParamMap& params();
107
108			// Update/refresh device/driver data.
109			void refresh();
110
111	capela	430	// Device ids enumerator.
112	capela	431	static int getDevices(lscp_client_t pClient,
113	capela	429	qsamplerDeviceType deviceType);
114
115	capela	430	// Driver names enumerator.
116	capela	431	static QStringList getDrivers(lscp_client_t *pClient,
117	capela	430	qsamplerDeviceType deviceType);
118
119	capela	429	private:
120
121			// Instance variables.
122	capela	431	int m_iDeviceID;
123			qsamplerDeviceType m_deviceType;
124			QString m_sDriverName;
125			QString m_sDeviceName;
126	capela	429
127			// Device parameter list.
128			qsamplerDeviceParamMap m_params;
129			};
130
131
132			//-------------------------------------------------------------------------
133			// qsamplerDeviceItem - QListView device item.
134			//
135
136			class qsamplerDeviceItem : public QListViewItem
137			{
138			public:
139
140	capela	431	// Constructors.
141			qsamplerDeviceItem(QListView pListView, lscp_client_t pClient,
142	capela	429	qsamplerDevice::qsamplerDeviceType deviceType);
143	capela	431	qsamplerDeviceItem(QListViewItem pItem, lscp_client_t pClient,
144	capela	429	qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID);
145	capela	431	// Default destructor.
146			~qsamplerDeviceItem();
147	capela	429
148	capela	431	// Instance accessors.
149			qsamplerDevice& device();
150	capela	429
151	capela	431	// To virtually distinguish between list view items.
152			virtual int rtti() const;
153	capela	429
154			private:
155
156	capela	431	// Instance variables.
157			qsamplerDevice m_device;
158	capela	429	};
159
160
161			//-------------------------------------------------------------------------
162			// qsamplerDeviceParamTable - Device parameter view table.
163			//
164
165			class qsamplerDeviceParamTable : public QTable
166			{
167	capela	431	Q_OBJECT
168	capela	426
169			public:
170
171	capela	431	// Constructor.
172			qsamplerDeviceParamTable(QWidget pParent = 0, const char pszName = 0);
173			// Default destructor.
174			~qsamplerDeviceParamTable();
175	capela	426
176	capela	431	// Client/device descriptor selector.
177			void refresh(qsamplerDevice& device);
178	capela	426	};
179
180
181			#endif // __qsamplerDevice_h
182
183
184			// end of qsamplerDevice.h