trunk/src/qsamplerDevice.cpp

// qsamplerDevice.cpp
//
/****************************************************************************
   Copyright (C) 2003-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.

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

#include "qsamplerDevice.h"

#include "qsamplerMainForm.h"
#include "qsamplerDeviceForm.h"

#include "config.h"


//-------------------------------------------------------------------------
// qsamplerDeviceParam - MIDI/Audio Device parameter structure.
//

// Constructors.
qsamplerDeviceParam::qsamplerDeviceParam ( lscp_param_info_t *pParamInfo,
        const char *pszValue )
{
        setParam(pParamInfo, pszValue);
}


// Default destructor.
qsamplerDeviceParam::~qsamplerDeviceParam (void)
{
}


// Initializer.
void qsamplerDeviceParam::setParam ( lscp_param_info_t *pParamInfo,
        const char *pszValue )
{
        if (pParamInfo == NULL)
            return;
            
    // Info structure field members.

        type = pParamInfo->type;

        if (pParamInfo->description)
                description = pParamInfo->description;
        else
                description = QString::null;

    mandatory = (bool) pParamInfo->multiplicity;
    fix = (bool) pParamInfo->fix;
    multiplicity = (bool) pParamInfo->multiplicity;

        depends.clear();
        for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
            depends.append(pParamInfo->depends[i]);

        if (pParamInfo->defaultv)
                defaultv = pParamInfo->defaultv;
        else
                defaultv = QString::null;

        if (pParamInfo->range_min)
        range_min = pParamInfo->range_min;
        else
                range_min = QString::null;

        if (pParamInfo->range_max)
        range_max = pParamInfo->range_max;
        else
                range_max = QString::null;

        possibilities.clear();
        for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
            possibilities.append(pParamInfo->possibilities[i]);
            
    // The current parameter value.
        if (pszValue)
            value = pszValue;
        else
                value = QString::null;
}


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

// Constructor.
qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
        qsamplerDeviceType deviceType, int iDeviceID )
{
        setDevice(pClient, deviceType, iDeviceID);
}

// Default destructor.
qsamplerDevice::~qsamplerDevice (void)
{
}


// Initializer.
void qsamplerDevice::setDevice ( lscp_client_t *pClient,
        qsamplerDeviceType deviceType, int iDeviceID )
{
        if (pClient == NULL || iDeviceID < 0)
            return;
            
        lscp_device_info_t *pDeviceInfo = NULL;
        switch (deviceType) {
          case qsamplerDevice::Audio:
                m_sDeviceName = QObject::tr("Audio");
            pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
                break;
          case qsamplerDevice::Midi:
                m_sDeviceName = QObject::tr("MIDI");
                pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
                break;
        }
        if (pDeviceInfo == NULL)
            return;

        // Device properties...
        m_iDeviceID   = iDeviceID;
        m_deviceType  = deviceType;
        m_sDriverName = pDeviceInfo->driver;
        
        // Complete fake device name...
        m_sDeviceName += ' ' + m_sDriverName + ' ';
        m_sDeviceName += QObject::tr("Device %1").arg(m_iDeviceID);

        // Grab device/driver parameters...
        m_params.clear();
        for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
                const char *pszParam = pDeviceInfo->params[i].key;
                lscp_param_info_t *pParamInfo = NULL;
                switch (deviceType) {
                  case qsamplerDevice::Audio:
                    pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
                                m_sDriverName.latin1(), pszParam, NULL);
                        break;
                  case qsamplerDevice::Midi:
                    pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
                                m_sDriverName.latin1(), pszParam, NULL);
                        break;
                }
                m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pDeviceInfo->params[i].value);
        }
}


// Device property accessors.
int qsamplerDevice::deviceID (void) const
{
        return m_iDeviceID;
}

qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
{
        return m_deviceType;
}

const QString& qsamplerDevice::driverName (void) const
{
        return m_sDriverName;
}

const QString& qsamplerDevice::deviceName (void) const
{
        return m_sDeviceName;
}

// Device parameter accessor.
qsamplerDeviceParamMap& qsamplerDevice::params (void)
{
        return m_params;
}


// Update/refresh device/driver data.
void qsamplerDevice::refresh (void)
{
}

// Device enumerator.
int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
        qsamplerDeviceType deviceType )
{
        int *piDeviceIDs = NULL;
        switch (deviceType) {
          case qsamplerDevice::Audio:
            piDeviceIDs = ::lscp_list_audio_devices(pClient);
                break;
          case qsamplerDevice::Midi:
            piDeviceIDs = ::lscp_list_midi_devices(pClient);
                break;
        }
        return piDeviceIDs;
}

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

// Constructors.
qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView, lscp_client_t *pClient,
        qsamplerDevice::qsamplerDeviceType deviceType )
        : QListViewItem(pListView), m_device(pClient, deviceType)
{
        switch(m_device.deviceType()) {
          case qsamplerDevice::Audio:
                QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
                QListViewItem::setText(0, QObject::tr("Audio devices"));
                break;
          case qsamplerDevice::Midi:
                QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
                QListViewItem::setText(0, QObject::tr("MIDI devices"));
                break;
        }
}

qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem, lscp_client_t *pClient,
        qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )
        : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
{
        switch(m_device.deviceType()) {
          case qsamplerDevice::Audio:
                QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
                break;
          case qsamplerDevice::Midi:
                QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
                break;
        }

        QListViewItem::setText(0, m_device.deviceName());
}

// Default destructor.
qsamplerDeviceItem::~qsamplerDeviceItem (void)
{
}

// Instance accessors.
const qsamplerDevice& qsamplerDeviceItem::device (void)
{
        return m_device;
}

// To virtually distinguish between list view items.
int qsamplerDeviceItem::rtti() const
{
        return QSAMPLER_DEVICE_ITEM;
}


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

// Constructor.
qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent, const char *pszName )
        : QTable(pParent, pszName)
{
        m_pClient = NULL;
        m_iDeviceID = -1;

        // Set fixed number of columns.
        QTable::setNumCols(3);
        QTable::setShowGrid(false);
        QTable::setSorting(false);
        QTable::setFocusStyle(QTable::FollowStyle);
        QTable::setSelectionMode(QTable::NoSelection);
        // No vertical header.
        QTable::verticalHeader()->hide();
        QTable::setLeftMargin(0);
        // Initialize the fixed table column headings.
        QHeader *pHeader = QTable::horizontalHeader();
        pHeader->setLabel(0, tr("Parameter"));
        pHeader->setLabel(1, tr("Description"));
        pHeader->setLabel(2, tr("Value"));
        // Set read-onlyness of each column
        QTable::setColumnReadOnly(0, true);
        QTable::setColumnReadOnly(1, true);
//  QTable::setColumnReadOnly(2, true); -- of course not.
}

// Default destructor.
qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
{
}


// Client/device descriptor selector.
void qsamplerDeviceParamTable::setDevice ( lscp_client_t *pClient,
                qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )
{
        if (m_pClient
                && m_pClient    == pClient
                && m_deviceType == deviceType
                && m_iDeviceID  == iDeviceID)
            return;
            
    m_pClient = pClient;
    m_deviceType = deviceType;
    m_iDeviceID = iDeviceID;
    
    refresh();
}


// Client/device descriptor accessors.
lscp_client_t *qsamplerDeviceParamTable::client (void)
{
    return m_pClient;
}

int qsamplerDeviceParamTable::deviceID (void)
{
    return m_iDeviceID;
}


// The main table refresher.
void qsamplerDeviceParamTable::refresh (void)
{
        // Always (re)start it empty.
        QTable::setNumRows(0);

        if (m_pClient == NULL)
            return;
            
        // Construct the local device object here.
        qsamplerDevice device(m_pClient, m_deviceType, m_iDeviceID);


        // Now fill the parameter table...
        QHeader *pHeader = QTable::verticalHeader();
    qsamplerDeviceParamMap& params = device.params();
        QTable::insertRows(0, params.count());
        int iRow = 0;
        qsamplerDeviceParamMap::Iterator iter;
        for (iter = params.begin(); iter != params.end(); ++iter) {
        QTable::setText(iRow, 0, iter.key());
            QTable::setText(iRow, 1, iter.data().description);
            QTable::setText(iRow, 2, iter.data().value);
            ++iRow;
        }

        // Adjust optimal column width.
        for (int iCol = 0; iCol < QTable::numCols(); iCol++)
                QTable::adjustColumn(iCol);
}


// end of qsamplerDevice.cpp
1	capela	426	// qsamplerDevice.cpp
2			//
3			/****************************************************************************
4			Copyright (C) 2003-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			#include "qsamplerDevice.h"
23
24			#include "qsamplerMainForm.h"
25			#include "qsamplerDeviceForm.h"
26
27			#include "config.h"
28
29
30			//-------------------------------------------------------------------------
31	capela	429	// qsamplerDeviceParam - MIDI/Audio Device parameter structure.
32	capela	426	//
33
34	capela	429	// Constructors.
35			qsamplerDeviceParam::qsamplerDeviceParam ( lscp_param_info_t *pParamInfo,
36			const char *pszValue )
37			{
38			setParam(pParamInfo, pszValue);
39			}
40
41
42			// Default destructor.
43			qsamplerDeviceParam::~qsamplerDeviceParam (void)
44			{
45			}
46
47
48			// Initializer.
49			void qsamplerDeviceParam::setParam ( lscp_param_info_t *pParamInfo,
50			const char *pszValue )
51			{
52			if (pParamInfo == NULL)
53			return;
54
55			// Info structure field members.
56
57			type = pParamInfo->type;
58
59			if (pParamInfo->description)
60			description = pParamInfo->description;
61			else
62			description = QString::null;
63
64			mandatory = (bool) pParamInfo->multiplicity;
65			fix = (bool) pParamInfo->fix;
66			multiplicity = (bool) pParamInfo->multiplicity;
67
68			depends.clear();
69			for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
70			depends.append(pParamInfo->depends[i]);
71
72			if (pParamInfo->defaultv)
73			defaultv = pParamInfo->defaultv;
74			else
75			defaultv = QString::null;
76
77			if (pParamInfo->range_min)
78			range_min = pParamInfo->range_min;
79			else
80			range_min = QString::null;
81
82			if (pParamInfo->range_max)
83			range_max = pParamInfo->range_max;
84			else
85			range_max = QString::null;
86
87			possibilities.clear();
88			for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
89			possibilities.append(pParamInfo->possibilities[i]);
90
91			// The current parameter value.
92			if (pszValue)
93			value = pszValue;
94			else
95			value = QString::null;
96			}
97
98
99			//-------------------------------------------------------------------------
100			// qsamplerDevice - MIDI/Audio Device structure.
101			//
102
103	capela	426	// Constructor.
104	capela	429	qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
105			qsamplerDeviceType deviceType, int iDeviceID )
106			{
107			setDevice(pClient, deviceType, iDeviceID);
108			}
109
110			// Default destructor.
111			qsamplerDevice::~qsamplerDevice (void)
112			{
113			}
114
115
116			// Initializer.
117			void qsamplerDevice::setDevice ( lscp_client_t *pClient,
118			qsamplerDeviceType deviceType, int iDeviceID )
119			{
120			if (pClient == NULL \|\| iDeviceID < 0)
121			return;
122
123			lscp_device_info_t *pDeviceInfo = NULL;
124			switch (deviceType) {
125			case qsamplerDevice::Audio:
126			m_sDeviceName = QObject::tr("Audio");
127			pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
128			break;
129			case qsamplerDevice::Midi:
130			m_sDeviceName = QObject::tr("MIDI");
131			pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
132			break;
133			}
134			if (pDeviceInfo == NULL)
135			return;
136
137			// Device properties...
138			m_iDeviceID = iDeviceID;
139			m_deviceType = deviceType;
140			m_sDriverName = pDeviceInfo->driver;
141
142			// Complete fake device name...
143			m_sDeviceName += ' ' + m_sDriverName + ' ';
144			m_sDeviceName += QObject::tr("Device %1").arg(m_iDeviceID);
145
146			// Grab device/driver parameters...
147			m_params.clear();
148			for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
149			const char *pszParam = pDeviceInfo->params[i].key;
150			lscp_param_info_t *pParamInfo = NULL;
151			switch (deviceType) {
152			case qsamplerDevice::Audio:
153			pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
154			m_sDriverName.latin1(), pszParam, NULL);
155			break;
156			case qsamplerDevice::Midi:
157			pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
158			m_sDriverName.latin1(), pszParam, NULL);
159			break;
160			}
161			m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pDeviceInfo->params[i].value);
162			}
163			}
164
165
166			// Device property accessors.
167			int qsamplerDevice::deviceID (void) const
168			{
169			return m_iDeviceID;
170			}
171
172			qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
173			{
174			return m_deviceType;
175			}
176
177			const QString& qsamplerDevice::driverName (void) const
178			{
179			return m_sDriverName;
180			}
181
182			const QString& qsamplerDevice::deviceName (void) const
183			{
184			return m_sDeviceName;
185			}
186
187			// Device parameter accessor.
188			qsamplerDeviceParamMap& qsamplerDevice::params (void)
189			{
190			return m_params;
191			}
192
193
194			// Update/refresh device/driver data.
195			void qsamplerDevice::refresh (void)
196			{
197			}
198
199			// Device enumerator.
200			int qsamplerDevice::getDevices ( lscp_client_t pClient,
201			qsamplerDeviceType deviceType )
202			{
203			int *piDeviceIDs = NULL;
204			switch (deviceType) {
205			case qsamplerDevice::Audio:
206			piDeviceIDs = ::lscp_list_audio_devices(pClient);
207			break;
208			case qsamplerDevice::Midi:
209			piDeviceIDs = ::lscp_list_midi_devices(pClient);
210			break;
211			}
212			return piDeviceIDs;
213			}
214
215			//-------------------------------------------------------------------------
216			// qsamplerDeviceItem - QListView device item.
217			//
218
219			// Constructors.
220			qsamplerDeviceItem::qsamplerDeviceItem ( QListView pListView, lscp_client_t pClient,
221			qsamplerDevice::qsamplerDeviceType deviceType )
222			: QListViewItem(pListView), m_device(pClient, deviceType)
223			{
224			switch(m_device.deviceType()) {
225			case qsamplerDevice::Audio:
226			QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
227			QListViewItem::setText(0, QObject::tr("Audio devices"));
228			break;
229			case qsamplerDevice::Midi:
230			QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
231			QListViewItem::setText(0, QObject::tr("MIDI devices"));
232			break;
233			}
234			}
235
236			qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem pItem, lscp_client_t pClient,
237			qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )
238			: QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
239			{
240			switch(m_device.deviceType()) {
241			case qsamplerDevice::Audio:
242			QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
243			break;
244			case qsamplerDevice::Midi:
245			QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
246			break;
247			}
248
249			QListViewItem::setText(0, m_device.deviceName());
250			}
251
252			// Default destructor.
253			qsamplerDeviceItem::~qsamplerDeviceItem (void)
254			{
255			}
256
257			// Instance accessors.
258			const qsamplerDevice& qsamplerDeviceItem::device (void)
259			{
260			return m_device;
261			}
262
263			// To virtually distinguish between list view items.
264			int qsamplerDeviceItem::rtti() const
265			{
266			return QSAMPLER_DEVICE_ITEM;
267			}
268
269
270
271			//-------------------------------------------------------------------------
272			// qsamplerDeviceParamTable - Device parameter view table.
273			//
274
275			// Constructor.
276			qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget pParent, const char pszName )
277	capela	426	: QTable(pParent, pszName)
278			{
279			m_pClient = NULL;
280	capela	429	m_iDeviceID = -1;
281	capela	428
282			// Set fixed number of columns.
283	capela	429	QTable::setNumCols(3);
284	capela	428	QTable::setShowGrid(false);
285			QTable::setSorting(false);
286			QTable::setFocusStyle(QTable::FollowStyle);
287			QTable::setSelectionMode(QTable::NoSelection);
288			// No vertical header.
289			QTable::verticalHeader()->hide();
290			QTable::setLeftMargin(0);
291			// Initialize the fixed table column headings.
292			QHeader *pHeader = QTable::horizontalHeader();
293	capela	429	pHeader->setLabel(0, tr("Parameter"));
294	capela	428	pHeader->setLabel(1, tr("Description"));
295	capela	429	pHeader->setLabel(2, tr("Value"));
296	capela	428	// Set read-onlyness of each column
297			QTable::setColumnReadOnly(0, true);
298			QTable::setColumnReadOnly(1, true);
299	capela	429	// QTable::setColumnReadOnly(2, true); -- of course not.
300	capela	426	}
301
302			// Default destructor.
303	capela	429	qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
304	capela	426	{
305			}
306
307
308	capela	429	// Client/device descriptor selector.
309			void qsamplerDeviceParamTable::setDevice ( lscp_client_t *pClient,
310			qsamplerDevice::qsamplerDeviceType deviceType, int iDeviceID )
311	capela	426	{
312	capela	429	if (m_pClient
313			&& m_pClient == pClient
314			&& m_deviceType == deviceType
315			&& m_iDeviceID == iDeviceID)
316			return;
317
318	capela	426	m_pClient = pClient;
319	capela	429	m_deviceType = deviceType;
320			m_iDeviceID = iDeviceID;
321
322			refresh();
323	capela	426	}
324
325	capela	429
326			// Client/device descriptor accessors.
327			lscp_client_t *qsamplerDeviceParamTable::client (void)
328	capela	426	{
329			return m_pClient;
330			}
331
332	capela	429	int qsamplerDeviceParamTable::deviceID (void)
333			{
334			return m_iDeviceID;
335			}
336	capela	426
337	capela	429
338			// The main table refresher.
339			void qsamplerDeviceParamTable::refresh (void)
340			{
341			// Always (re)start it empty.
342			QTable::setNumRows(0);
343
344			if (m_pClient == NULL)
345			return;
346
347			// Construct the local device object here.
348			qsamplerDevice device(m_pClient, m_deviceType, m_iDeviceID);
349
350
351			// Now fill the parameter table...
352			QHeader *pHeader = QTable::verticalHeader();
353			qsamplerDeviceParamMap& params = device.params();
354			QTable::insertRows(0, params.count());
355			int iRow = 0;
356			qsamplerDeviceParamMap::Iterator iter;
357			for (iter = params.begin(); iter != params.end(); ++iter) {
358			QTable::setText(iRow, 0, iter.key());
359			QTable::setText(iRow, 1, iter.data().description);
360			QTable::setText(iRow, 2, iter.data().value);
361			++iRow;
362			}
363
364			// Adjust optimal column width.
365			for (int iCol = 0; iCol < QTable::numCols(); iCol++)
366			QTable::adjustColumn(iCol);
367			}
368
369
370	capela	426	// end of qsamplerDevice.cpp