trunk/src/qsamplerDevice.cpp

// qsamplerDevice.cpp
//
/****************************************************************************
   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.

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

#include "qsamplerDevice.h"

#include <qspinbox.h>
#include <qlineedit.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 )
{
        // Device id and type should be always set.
        m_iDeviceID  = iDeviceID;
        m_deviceType = deviceType;

        // Retrieve device info, if any.
        lscp_device_info_t *pDeviceInfo = NULL;
        switch (deviceType) {
        case qsamplerDevice::Audio:
                m_sDeviceType = QObject::tr("Audio");
                pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
                break;
        case qsamplerDevice::Midi:
                m_sDeviceType = QObject::tr("MIDI");
                pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
                break;
        case qsamplerDevice::None:
                m_sDeviceType = QString::null;
                break;
        }

        // If we're bogus, bail out...
        if (pDeviceInfo == NULL) {
                m_sDriverName = QString::null;
                m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
                return;
        }

        // Other device properties...
        m_sDriverName = pDeviceInfo->driver;
        m_sDeviceName = m_sDriverName + ' '
                + QObject::tr("Device %1").arg(m_iDeviceID);

        // Grab device 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;
                case qsamplerDevice::None:
                        break;
                }
                if (pParamInfo) {
                        m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
                                pDeviceInfo->params[i].value);
                }
        }
}


// Driver name initializer/settler.
void qsamplerDevice::setDriver ( lscp_client_t *pClient,
        const QString& sDriverName )
{
        // Valid only for scratch devices.
        if (m_sDriverName == sDriverName)
                return;

        // Retrieve driver info, if any.
        lscp_driver_info_t *pDriverInfo = NULL;
        switch (m_deviceType) {
        case qsamplerDevice::Audio:
                pDriverInfo = ::lscp_get_audio_driver_info(pClient,
                        sDriverName.latin1());
                break;
        case qsamplerDevice::Midi:
                pDriverInfo = ::lscp_get_midi_driver_info(pClient,
                        sDriverName.latin1());
                break;
        case qsamplerDevice::None:
                break;
        }

        // If we're bogus, bail out...
        if (pDriverInfo == NULL)
                return;

        // Remember device parameters...
        m_sDriverName = sDriverName;

        // Grab driver parameters...
        m_params.clear();
        for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
                const char *pszParam = pDriverInfo->parameters[i];
                lscp_param_info_t *pParamInfo = NULL;
                switch (m_deviceType) {
                case qsamplerDevice::Audio:
                        pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
                                sDriverName.latin1(), pszParam, NULL);
                        break;
                case qsamplerDevice::Midi:
                        pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
                                sDriverName.latin1(), pszParam, NULL);
                        break;
                case qsamplerDevice::None:
                        break;
                }
                if (pParamInfo)
                        m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
        }
}


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

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

const QString& qsamplerDevice::deviceTypeName (void) const
{
        return m_sDeviceType;
}

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

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

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


// Set the proper device parameter value.
void qsamplerDevice::setParam ( const QString& sParam,
        const QString& sValue )
{
        m_params[sParam].value = sValue;
}


// Device ids 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;
        case qsamplerDevice::None:
                break;
        }
        return piDeviceIDs;
}


// Driver names enumerator.
QStringList qsamplerDevice::getDrivers ( lscp_client_t *pClient,
        qsamplerDeviceType deviceType )
{
        QStringList drivers;
        
        const char **ppszDrivers = NULL;
        switch (deviceType) {
        case qsamplerDevice::Audio:
                ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
                break;
        case qsamplerDevice::Midi:
                ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
                break;
        case qsamplerDevice::None:
                break;
        }
        
        for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
                drivers.append(ppszDrivers[iDriver]);

        return drivers;
}


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

// Constructor.
qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,
        const qsamplerDevice& device, int iPortID )
{
        setDevicePort(pClient, device, iPortID);
}

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


// Initializer.
void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,
        const qsamplerDevice& device, int iPortID )
{
        // Device port id should be always set.
        m_iPortID = iPortID;

        // Retrieve device port/channel info, if any.
        lscp_device_port_info_t *pPortInfo = NULL;
        switch (device.deviceType()) {
        case qsamplerDevice::Audio:
                pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);
                break;
        case qsamplerDevice::Midi:
                pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);
                break;
        case qsamplerDevice::None:
                break;
        }

        // If we're bogus, bail out...
        if (pPortInfo == NULL) {
                m_sPortName = QString::null;
                return;
        }

        // Set device port/channel properties...
        m_sPortName = pPortInfo->name;

        // Grab device port/channel parameters...
        m_params.clear();
        for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
                const char *pszParam = pPortInfo->params[i].key;
                lscp_param_info_t *pParamInfo = NULL;
                switch (device.deviceType()) {
                case qsamplerDevice::Audio:
                        pParamInfo = ::lscp_get_audio_channel_param_info(pClient,
                                device.deviceID(), iPortID, pszParam);
                        break;
                case qsamplerDevice::Midi:
                        pParamInfo = ::lscp_get_midi_port_param_info(pClient,
                                device.deviceID(), iPortID, pszParam);
                        break;
                case qsamplerDevice::None:
                        break;
                }
                if (pParamInfo) {
                        m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
                                pPortInfo->params[i].value);
                }
        }
}


// Device port/channel property accessors.
int qsamplerDevicePort::portID (void) const
{
        return m_iPortID;
}

const QString& qsamplerDevicePort::portName (void) const
{
        return m_sPortName;
}

// Device port/channel parameter accessor.
const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
{
        return m_params;
}


// Set the proper device port/channel parameter value.
void qsamplerDevicePort::setParam ( const QString& sParam,
        const QString& sValue )
{
        m_params[sParam].value = sValue;
}


//-------------------------------------------------------------------------
// 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;
        case qsamplerDevice::None:
                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;
        case qsamplerDevice::None:
                break;
        }

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

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

// Instance accessors.
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)
{
        // 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.
        QTable::setColumnStretchable(1, true);
}

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


// Common parameter table renderer.
void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
        bool bEditable )
{
        // Always (re)start it empty.
        QTable::setUpdatesEnabled(false);
        QTable::setNumRows(0);

        // Fill the parameter table...
        QTable::insertRows(0, params.count());
        int iRow = 0;
        qsamplerDeviceParamMap::ConstIterator iter;
        for (iter = params.begin(); iter != params.end(); ++iter) {
                const qsamplerDeviceParam& param = iter.data();
                bool bEnabled = (bEditable || !param.fix);
                QTable::setText(iRow, 0, iter.key());
                QTable::setText(iRow, 1, param.description);
                if (param.type == LSCP_TYPE_BOOL) {
                        QStringList opts;
                        opts.append(tr("False"));
                        opts.append(tr("True"));
                        QComboTableItem *pComboItem = new QComboTableItem(this, opts);
                        pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
                        pComboItem->setEnabled(bEnabled);
                        QTable::setItem(iRow, 2, pComboItem);
                } else if (param.possibilities.count() > 0 && bEnabled) {
                        QComboTableItem *pComboItem = new QComboTableItem(this,
                                param.possibilities);
                        pComboItem->setCurrentItem(param.value);
                        pComboItem->setEnabled(bEnabled);
                        pComboItem->setEditable(bEnabled && param.multiplicity);
                        QTable::setItem(iRow, 2, pComboItem);
                } else if (param.type == LSCP_TYPE_INT && bEnabled
                                && !param.range_min.isEmpty()
                                && !param.range_max.isEmpty()) {
                        qsamplerDeviceParamTableSpinBox *pSpinItem =
                                new qsamplerDeviceParamTableSpinBox(this,
                                        bEnabled ? QTableItem::OnTyping : QTableItem::Never,
                                        param.value);
                        pSpinItem->setMinValue(param.range_min.toInt());
                        pSpinItem->setMaxValue(param.range_max.toInt());
                        QTable::setItem(iRow, 2, pSpinItem);
                } else {
                        qsamplerDeviceParamTableEditBox *pEditItem =
                                new qsamplerDeviceParamTableEditBox(this,
                                        bEnabled ? QTableItem::OnTyping : QTableItem::Never,
                                        param.value);
                        QTable::setItem(iRow, 2, pEditItem);
                }
                ++iRow;
        }

        // Adjust optimal column widths.
        QTable::adjustColumn(0);
        QTable::adjustColumn(2);

        QTable::setUpdatesEnabled(true);
        QTable::updateContents();
}


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

// Constructor.
qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
        QTable *pTable, EditType editType, const QString& sText )
        : QTableItem(pTable, editType, sText)
{
        m_iValue = sText.toInt();
        m_iMinValue = m_iMaxValue = 0;
}

// Public accessors.
void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
{
        m_iValue = iValue;
        QTableItem::setText(QString::number(m_iValue));
}

void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
{
        m_iMinValue = iMinValue;
}

void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
{
        m_iMaxValue = iMaxValue;
}

// Virtual implemetations.
QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
{
        QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
        QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
                QTableItem::table(), SLOT(doValueChanged()));
        if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
                pSpinBox->setMinValue(m_iMinValue);
                pSpinBox->setMaxValue(m_iMaxValue);
        }
        pSpinBox->setValue(m_iValue);
        return pSpinBox;
}

void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
{
        if (pWidget->inherits("QSpinBox"))
                QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
        else
                QTableItem::setContentFromEditor(pWidget);
}


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

// Constructor.
qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
        QTable *pTable, EditType editType, const QString& sText )
        : QTableItem(pTable, editType, sText)
{
}

// Virtual implemetations.
QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
{
        QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
        QObject::connect(pEditBox, SIGNAL(returnPressed()),
                QTableItem::table(), SLOT(doValueChanged()));
        pEditBox->setText(QTableItem::text());
        return pEditBox;
}

void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
{
        if (pWidget->inherits("QLineEdit"))
                QTableItem::setText(((QLineEdit *) pWidget)->text());
        else
                QTableItem::setContentFromEditor(pWidget);
}


// end of qsamplerDevice.cpp
1	// qsamplerDevice.cpp
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	#include "qsamplerDevice.h"
23
24	#include <qspinbox.h>
25	#include <qlineedit.h>
26
27	#include "qsamplerMainForm.h"
28	#include "qsamplerDeviceForm.h"
29
30	#include "config.h"
31
32
33	//-------------------------------------------------------------------------
34	// qsamplerDeviceParam - MIDI/Audio Device parameter structure.
35	//
36
37	// Constructors.
38	qsamplerDeviceParam::qsamplerDeviceParam ( lscp_param_info_t *pParamInfo,
39	const char *pszValue )
40	{
41	setParam(pParamInfo, pszValue);
42	}
43
44
45	// Default destructor.
46	qsamplerDeviceParam::~qsamplerDeviceParam (void)
47	{
48	}
49
50
51	// Initializer.
52	void qsamplerDeviceParam::setParam ( lscp_param_info_t *pParamInfo,
53	const char *pszValue )
54	{
55	if (pParamInfo == NULL)
56	return;
57
58	// Info structure field members.
59
60	type = pParamInfo->type;
61
62	if (pParamInfo->description)
63	description = pParamInfo->description;
64	else
65	description = QString::null;
66
67	mandatory = (bool) pParamInfo->multiplicity;
68	fix = (bool) pParamInfo->fix;
69	multiplicity = (bool) pParamInfo->multiplicity;
70
71	depends.clear();
72	for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
73	depends.append(pParamInfo->depends[i]);
74
75	if (pParamInfo->defaultv)
76	defaultv = pParamInfo->defaultv;
77	else
78	defaultv = QString::null;
79
80	if (pParamInfo->range_min)
81	range_min = pParamInfo->range_min;
82	else
83	range_min = QString::null;
84
85	if (pParamInfo->range_max)
86	range_max = pParamInfo->range_max;
87	else
88	range_max = QString::null;
89
90	possibilities.clear();
91	for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
92	possibilities.append(pParamInfo->possibilities[i]);
93
94	// The current parameter value.
95	if (pszValue)
96	value = pszValue;
97	else
98	value = QString::null;
99	}
100
101
102	//-------------------------------------------------------------------------
103	// qsamplerDevice - MIDI/Audio Device structure.
104	//
105
106	// Constructor.
107	qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
108	qsamplerDeviceType deviceType, int iDeviceID )
109	{
110	setDevice(pClient, deviceType, iDeviceID);
111	}
112
113	// Default destructor.
114	qsamplerDevice::~qsamplerDevice (void)
115	{
116	}
117
118
119	// Initializer.
120	void qsamplerDevice::setDevice ( lscp_client_t *pClient,
121	qsamplerDeviceType deviceType, int iDeviceID )
122	{
123	// Device id and type should be always set.
124	m_iDeviceID = iDeviceID;
125	m_deviceType = deviceType;
126
127	// Retrieve device info, if any.
128	lscp_device_info_t *pDeviceInfo = NULL;
129	switch (deviceType) {
130	case qsamplerDevice::Audio:
131	m_sDeviceType = QObject::tr("Audio");
132	pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
133	break;
134	case qsamplerDevice::Midi:
135	m_sDeviceType = QObject::tr("MIDI");
136	pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
137	break;
138	case qsamplerDevice::None:
139	m_sDeviceType = QString::null;
140	break;
141	}
142
143	// If we're bogus, bail out...
144	if (pDeviceInfo == NULL) {
145	m_sDriverName = QString::null;
146	m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
147	return;
148	}
149
150	// Other device properties...
151	m_sDriverName = pDeviceInfo->driver;
152	m_sDeviceName = m_sDriverName + ' '
153	+ QObject::tr("Device %1").arg(m_iDeviceID);
154
155	// Grab device parameters...
156	m_params.clear();
157	for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
158	const char *pszParam = pDeviceInfo->params[i].key;
159	lscp_param_info_t *pParamInfo = NULL;
160	switch (deviceType) {
161	case qsamplerDevice::Audio:
162	pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
163	m_sDriverName.latin1(), pszParam, NULL);
164	break;
165	case qsamplerDevice::Midi:
166	pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
167	m_sDriverName.latin1(), pszParam, NULL);
168	break;
169	case qsamplerDevice::None:
170	break;
171	}
172	if (pParamInfo) {
173	m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
174	pDeviceInfo->params[i].value);
175	}
176	}
177	}
178
179
180	// Driver name initializer/settler.
181	void qsamplerDevice::setDriver ( lscp_client_t *pClient,
182	const QString& sDriverName )
183	{
184	// Valid only for scratch devices.
185	if (m_sDriverName == sDriverName)
186	return;
187
188	// Retrieve driver info, if any.
189	lscp_driver_info_t *pDriverInfo = NULL;
190	switch (m_deviceType) {
191	case qsamplerDevice::Audio:
192	pDriverInfo = ::lscp_get_audio_driver_info(pClient,
193	sDriverName.latin1());
194	break;
195	case qsamplerDevice::Midi:
196	pDriverInfo = ::lscp_get_midi_driver_info(pClient,
197	sDriverName.latin1());
198	break;
199	case qsamplerDevice::None:
200	break;
201	}
202
203	// If we're bogus, bail out...
204	if (pDriverInfo == NULL)
205	return;
206
207	// Remember device parameters...
208	m_sDriverName = sDriverName;
209
210	// Grab driver parameters...
211	m_params.clear();
212	for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
213	const char *pszParam = pDriverInfo->parameters[i];
214	lscp_param_info_t *pParamInfo = NULL;
215	switch (m_deviceType) {
216	case qsamplerDevice::Audio:
217	pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
218	sDriverName.latin1(), pszParam, NULL);
219	break;
220	case qsamplerDevice::Midi:
221	pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
222	sDriverName.latin1(), pszParam, NULL);
223	break;
224	case qsamplerDevice::None:
225	break;
226	}
227	if (pParamInfo)
228	m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);
229	}
230	}
231
232
233	// Device property accessors.
234	int qsamplerDevice::deviceID (void) const
235	{
236	return m_iDeviceID;
237	}
238
239	qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
240	{
241	return m_deviceType;
242	}
243
244	const QString& qsamplerDevice::deviceTypeName (void) const
245	{
246	return m_sDeviceType;
247	}
248
249	const QString& qsamplerDevice::driverName (void) const
250	{
251	return m_sDriverName;
252	}
253
254	const QString& qsamplerDevice::deviceName (void) const
255	{
256	return m_sDeviceName;
257	}
258
259	// Device parameter accessor.
260	const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
261	{
262	return m_params;
263	}
264
265
266	// Set the proper device parameter value.
267	void qsamplerDevice::setParam ( const QString& sParam,
268	const QString& sValue )
269	{
270	m_params[sParam].value = sValue;
271	}
272
273
274	// Device ids enumerator.
275	int qsamplerDevice::getDevices ( lscp_client_t pClient,
276	qsamplerDeviceType deviceType )
277	{
278	int *piDeviceIDs = NULL;
279	switch (deviceType) {
280	case qsamplerDevice::Audio:
281	piDeviceIDs = ::lscp_list_audio_devices(pClient);
282	break;
283	case qsamplerDevice::Midi:
284	piDeviceIDs = ::lscp_list_midi_devices(pClient);
285	break;
286	case qsamplerDevice::None:
287	break;
288	}
289	return piDeviceIDs;
290	}
291
292
293	// Driver names enumerator.
294	QStringList qsamplerDevice::getDrivers ( lscp_client_t *pClient,
295	qsamplerDeviceType deviceType )
296	{
297	QStringList drivers;
298
299	const char **ppszDrivers = NULL;
300	switch (deviceType) {
301	case qsamplerDevice::Audio:
302	ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
303	break;
304	case qsamplerDevice::Midi:
305	ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
306	break;
307	case qsamplerDevice::None:
308	break;
309	}
310
311	for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
312	drivers.append(ppszDrivers[iDriver]);
313
314	return drivers;
315	}
316
317
318	//-------------------------------------------------------------------------
319	// qsamplerDevicePort - MIDI/Audio Device port/channel structure.
320	//
321
322	// Constructor.
323	qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,
324	const qsamplerDevice& device, int iPortID )
325	{
326	setDevicePort(pClient, device, iPortID);
327	}
328
329	// Default destructor.
330	qsamplerDevicePort::~qsamplerDevicePort (void)
331	{
332	}
333
334
335	// Initializer.
336	void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,
337	const qsamplerDevice& device, int iPortID )
338	{
339	// Device port id should be always set.
340	m_iPortID = iPortID;
341
342	// Retrieve device port/channel info, if any.
343	lscp_device_port_info_t *pPortInfo = NULL;
344	switch (device.deviceType()) {
345	case qsamplerDevice::Audio:
346	pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);
347	break;
348	case qsamplerDevice::Midi:
349	pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);
350	break;
351	case qsamplerDevice::None:
352	break;
353	}
354
355	// If we're bogus, bail out...
356	if (pPortInfo == NULL) {
357	m_sPortName = QString::null;
358	return;
359	}
360
361	// Set device port/channel properties...
362	m_sPortName = pPortInfo->name;
363
364	// Grab device port/channel parameters...
365	m_params.clear();
366	for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
367	const char *pszParam = pPortInfo->params[i].key;
368	lscp_param_info_t *pParamInfo = NULL;
369	switch (device.deviceType()) {
370	case qsamplerDevice::Audio:
371	pParamInfo = ::lscp_get_audio_channel_param_info(pClient,
372	device.deviceID(), iPortID, pszParam);
373	break;
374	case qsamplerDevice::Midi:
375	pParamInfo = ::lscp_get_midi_port_param_info(pClient,
376	device.deviceID(), iPortID, pszParam);
377	break;
378	case qsamplerDevice::None:
379	break;
380	}
381	if (pParamInfo) {
382	m_params[pszParam] = qsamplerDeviceParam(pParamInfo,
383	pPortInfo->params[i].value);
384	}
385	}
386	}
387
388
389	// Device port/channel property accessors.
390	int qsamplerDevicePort::portID (void) const
391	{
392	return m_iPortID;
393	}
394
395	const QString& qsamplerDevicePort::portName (void) const
396	{
397	return m_sPortName;
398	}
399
400	// Device port/channel parameter accessor.
401	const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
402	{
403	return m_params;
404	}
405
406
407	// Set the proper device port/channel parameter value.
408	void qsamplerDevicePort::setParam ( const QString& sParam,
409	const QString& sValue )
410	{
411	m_params[sParam].value = sValue;
412	}
413
414
415	//-------------------------------------------------------------------------
416	// qsamplerDeviceItem - QListView device item.
417	//
418
419	// Constructors.
420	qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
421	lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
422	: QListViewItem(pListView), m_device(pClient, deviceType)
423	{
424	switch(m_device.deviceType()) {
425	case qsamplerDevice::Audio:
426	QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
427	QListViewItem::setText(0, QObject::tr("Audio devices"));
428	break;
429	case qsamplerDevice::Midi:
430	QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
431	QListViewItem::setText(0, QObject::tr("MIDI devices"));
432	break;
433	case qsamplerDevice::None:
434	break;
435	}
436	}
437
438	qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
439	lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
440	int iDeviceID )
441	: QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
442	{
443	switch(m_device.deviceType()) {
444	case qsamplerDevice::Audio:
445	QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
446	break;
447	case qsamplerDevice::Midi:
448	QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
449	break;
450	case qsamplerDevice::None:
451	break;
452	}
453
454	QListViewItem::setText(0, m_device.deviceName());
455	}
456
457	// Default destructor.
458	qsamplerDeviceItem::~qsamplerDeviceItem (void)
459	{
460	}
461
462	// Instance accessors.
463	qsamplerDevice& qsamplerDeviceItem::device (void)
464	{
465	return m_device;
466	}
467
468	// To virtually distinguish between list view items.
469	int qsamplerDeviceItem::rtti() const
470	{
471	return QSAMPLER_DEVICE_ITEM;
472	}
473
474
475
476	//-------------------------------------------------------------------------
477	// qsamplerDeviceParamTable - Device parameter view table.
478	//
479
480	// Constructor.
481	qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
482	const char *pszName )
483	: QTable(pParent, pszName)
484	{
485	// Set fixed number of columns.
486	QTable::setNumCols(3);
487	QTable::setShowGrid(false);
488	QTable::setSorting(false);
489	QTable::setFocusStyle(QTable::FollowStyle);
490	QTable::setSelectionMode(QTable::NoSelection);
491	// No vertical header.
492	QTable::verticalHeader()->hide();
493	QTable::setLeftMargin(0);
494	// Initialize the fixed table column headings.
495	QHeader *pHeader = QTable::horizontalHeader();
496	pHeader->setLabel(0, tr("Parameter"));
497	pHeader->setLabel(1, tr("Description"));
498	pHeader->setLabel(2, tr("Value"));
499	// Set read-onlyness of each column
500	QTable::setColumnReadOnly(0, true);
501	QTable::setColumnReadOnly(1, true);
502	// QTable::setColumnReadOnly(2, true); -- of course not.
503	QTable::setColumnStretchable(1, true);
504	}
505
506	// Default destructor.
507	qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
508	{
509	}
510
511
512	// Common parameter table renderer.
513	void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
514	bool bEditable )
515	{
516	// Always (re)start it empty.
517	QTable::setUpdatesEnabled(false);
518	QTable::setNumRows(0);
519
520	// Fill the parameter table...
521	QTable::insertRows(0, params.count());
522	int iRow = 0;
523	qsamplerDeviceParamMap::ConstIterator iter;
524	for (iter = params.begin(); iter != params.end(); ++iter) {
525	const qsamplerDeviceParam& param = iter.data();
526	bool bEnabled = (bEditable \|\| !param.fix);
527	QTable::setText(iRow, 0, iter.key());
528	QTable::setText(iRow, 1, param.description);
529	if (param.type == LSCP_TYPE_BOOL) {
530	QStringList opts;
531	opts.append(tr("False"));
532	opts.append(tr("True"));
533	QComboTableItem *pComboItem = new QComboTableItem(this, opts);
534	pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
535	pComboItem->setEnabled(bEnabled);
536	QTable::setItem(iRow, 2, pComboItem);
537	} else if (param.possibilities.count() > 0 && bEnabled) {
538	QComboTableItem *pComboItem = new QComboTableItem(this,
539	param.possibilities);
540	pComboItem->setCurrentItem(param.value);
541	pComboItem->setEnabled(bEnabled);
542	pComboItem->setEditable(bEnabled && param.multiplicity);
543	QTable::setItem(iRow, 2, pComboItem);
544	} else if (param.type == LSCP_TYPE_INT && bEnabled
545	&& !param.range_min.isEmpty()
546	&& !param.range_max.isEmpty()) {
547	qsamplerDeviceParamTableSpinBox *pSpinItem =
548	new qsamplerDeviceParamTableSpinBox(this,
549	bEnabled ? QTableItem::OnTyping : QTableItem::Never,
550	param.value);
551	pSpinItem->setMinValue(param.range_min.toInt());
552	pSpinItem->setMaxValue(param.range_max.toInt());
553	QTable::setItem(iRow, 2, pSpinItem);
554	} else {
555	qsamplerDeviceParamTableEditBox *pEditItem =
556	new qsamplerDeviceParamTableEditBox(this,
557	bEnabled ? QTableItem::OnTyping : QTableItem::Never,
558	param.value);
559	QTable::setItem(iRow, 2, pEditItem);
560	}
561	++iRow;
562	}
563
564	// Adjust optimal column widths.
565	QTable::adjustColumn(0);
566	QTable::adjustColumn(2);
567
568	QTable::setUpdatesEnabled(true);
569	QTable::updateContents();
570	}
571
572
573	//-------------------------------------------------------------------------
574	// qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
575	//
576
577	// Constructor.
578	qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
579	QTable *pTable, EditType editType, const QString& sText )
580	: QTableItem(pTable, editType, sText)
581	{
582	m_iValue = sText.toInt();
583	m_iMinValue = m_iMaxValue = 0;
584	}
585
586	// Public accessors.
587	void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
588	{
589	m_iValue = iValue;
590	QTableItem::setText(QString::number(m_iValue));
591	}
592
593	void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
594	{
595	m_iMinValue = iMinValue;
596	}
597
598	void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
599	{
600	m_iMaxValue = iMaxValue;
601	}
602
603	// Virtual implemetations.
604	QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
605	{
606	QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
607	QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
608	QTableItem::table(), SLOT(doValueChanged()));
609	if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
610	pSpinBox->setMinValue(m_iMinValue);
611	pSpinBox->setMaxValue(m_iMaxValue);
612	}
613	pSpinBox->setValue(m_iValue);
614	return pSpinBox;
615	}
616
617	void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
618	{
619	if (pWidget->inherits("QSpinBox"))
620	QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
621	else
622	QTableItem::setContentFromEditor(pWidget);
623	}
624
625
626	//-------------------------------------------------------------------------
627	// qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
628	//
629
630	// Constructor.
631	qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
632	QTable *pTable, EditType editType, const QString& sText )
633	: QTableItem(pTable, editType, sText)
634	{
635	}
636
637	// Virtual implemetations.
638	QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
639	{
640	QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
641	QObject::connect(pEditBox, SIGNAL(returnPressed()),
642	QTableItem::table(), SLOT(doValueChanged()));
643	pEditBox->setText(QTableItem::text());
644	return pEditBox;
645	}
646
647	void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
648	{
649	if (pWidget->inherits("QLineEdit"))
650	QTableItem::setText(((QLineEdit *) pWidget)->text());
651	else
652	QTableItem::setContentFromEditor(pWidget);
653	}
654
655
656	// end of qsamplerDevice.cpp