/[svn]/qsampler/trunk/src/qsamplerDevice.cpp
ViewVC logotype

Diff of /qsampler/trunk/src/qsamplerDevice.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 442 by capela, Thu Mar 10 15:48:38 2005 UTC revision 467 by capela, Tue Mar 15 23:54:14 2005 UTC
# Line 107  void qsamplerDeviceParam::setParam ( lsc Line 107  void qsamplerDeviceParam::setParam ( lsc
107  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
108          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
109  {  {
110            m_ports.setAutoDelete(true);
111            
112          setDevice(pClient, deviceType, iDeviceID);          setDevice(pClient, deviceType, iDeviceID);
113  }  }
114    
# Line 121  void qsamplerDevice::setDevice ( lscp_cl Line 123  void qsamplerDevice::setDevice ( lscp_cl
123          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
124  {  {
125          // Device id and type should be always set.          // Device id and type should be always set.
126          m_iDeviceID   = iDeviceID;          m_iDeviceID  = iDeviceID;
127          m_deviceType  = deviceType;          m_deviceType = deviceType;
128            
129            // Reset device parameters and ports anyway.
130            m_params.clear();
131            m_ports.clear();
132    
133          // Retrieve device info, if any.          // Retrieve device info, if any.
134          lscp_device_info_t *pDeviceInfo = NULL;          lscp_device_info_t *pDeviceInfo = NULL;
# Line 143  void qsamplerDevice::setDevice ( lscp_cl Line 149  void qsamplerDevice::setDevice ( lscp_cl
149          // If we're bogus, bail out...          // If we're bogus, bail out...
150          if (pDeviceInfo == NULL) {          if (pDeviceInfo == NULL) {
151                  m_sDriverName = QString::null;                  m_sDriverName = QString::null;
152                  m_sDeviceName = QObject::tr("New device");                  m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
153                  return;                  return;
154          }          }
155    
# Line 153  void qsamplerDevice::setDevice ( lscp_cl Line 159  void qsamplerDevice::setDevice ( lscp_cl
159                  + QObject::tr("Device %1").arg(m_iDeviceID);                  + QObject::tr("Device %1").arg(m_iDeviceID);
160    
161          // Grab device parameters...          // Grab device parameters...
         m_params.clear();  
162          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
163                  const char *pszParam = pDeviceInfo->params[i].key;                  const QString sParam = pDeviceInfo->params[i].key;
164                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
165                  switch (deviceType) {                  switch (deviceType) {
166                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
167                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
168                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), sParam.latin1(), NULL);
169                          break;                          break;
170                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
171                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
172                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), sParam.latin1(), NULL);
173                          break;                          break;
174                  case qsamplerDevice::None:                  case qsamplerDevice::None:
175                          break;                          break;
176                  }                  }
177                  if (pParamInfo) {                  if (pParamInfo) {
178                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo,                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
179                                  pDeviceInfo->params[i].value);                                  pDeviceInfo->params[i].value);
180                  }                  }
181          }          }
182    
183            // Refresh parameter dependencies...
184            refreshParams(pClient);
185            // Set port/channel list...
186            refreshPorts(pClient);
187  }  }
188    
189    
190  // Driver name initializer.  // Driver name initializer/settler.
191  void qsamplerDevice::setDriver ( lscp_client_t *pClient,  void qsamplerDevice::setDriver ( lscp_client_t *pClient,
192          const QString& sDriverName )          const QString& sDriverName )
193  {  {
# Line 185  void qsamplerDevice::setDriver ( lscp_cl Line 195  void qsamplerDevice::setDriver ( lscp_cl
195          if (m_sDriverName == sDriverName)          if (m_sDriverName == sDriverName)
196                  return;                  return;
197    
198            // Reset device parameters and ports anyway.
199            m_params.clear();
200            m_ports.clear();
201    
202          // Retrieve driver info, if any.          // Retrieve driver info, if any.
203          lscp_driver_info_t *pDriverInfo = NULL;          lscp_driver_info_t *pDriverInfo = NULL;
204          switch (m_deviceType) {          switch (m_deviceType) {
# Line 208  void qsamplerDevice::setDriver ( lscp_cl Line 222  void qsamplerDevice::setDriver ( lscp_cl
222          m_sDriverName = sDriverName;          m_sDriverName = sDriverName;
223    
224          // Grab driver parameters...          // Grab driver parameters...
         m_params.clear();  
225          for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {          for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
226                  const char *pszParam = pDriverInfo->parameters[i];                  const QString sParam = pDriverInfo->parameters[i];
227                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
228                  switch (m_deviceType) {                  switch (m_deviceType) {
229                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
230                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
231                                  sDriverName.latin1(), pszParam, NULL);                                  sDriverName.latin1(), sParam.latin1(), NULL);
232                          break;                          break;
233                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
234                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
235                                  sDriverName.latin1(), pszParam, NULL);                                  sDriverName.latin1(), sParam.latin1(), NULL);
236                          break;                          break;
237                  case qsamplerDevice::None:                  case qsamplerDevice::None:
238                          break;                          break;
239                  }                  }
240                  if (pParamInfo)                  if (pParamInfo) {
241                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
242                                    pParamInfo->defaultv);
243                    }
244          }          }
245    
246            // Refresh parameter dependencies...
247            refreshParams(pClient);
248            // Set port/channel list...
249            refreshPorts(pClient);
250  }  }
251    
252    
# Line 256  const QString& qsamplerDevice::deviceNam Line 276  const QString& qsamplerDevice::deviceNam
276          return m_sDeviceName;          return m_sDeviceName;
277  }  }
278    
279    
280    // Set the proper device parameter value.
281    void qsamplerDevice::setParam ( const QString& sParam,
282            const QString& sValue )
283    {
284            m_params[sParam.upper()].value = sValue;
285    }
286    
287    
288  // Device parameter accessor.  // Device parameter accessor.
289  qsamplerDeviceParamMap& qsamplerDevice::params (void)  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
290  {  {
291          return m_params;          return m_params;
292  }  }
293    
294    
295  // Update/refresh device/driver data.  // Device port/channel list accessor.
296  void qsamplerDevice::refresh (void)  qsamplerDevicePortList& qsamplerDevice::ports (void)
297    {
298            return m_ports;
299    }
300    
301    
302    // Device parameter dependencies refreshner.
303    int qsamplerDevice::refreshParams ( lscp_client_t *pClient )
304    {
305            // Refresh all parameters that have dependencies...
306            int iParams = 0;
307            qsamplerDeviceParamMap::ConstIterator iter;
308            for (iter = m_params.begin(); iter != m_params.end(); ++iter)
309                    iParams += refreshParam(pClient, iter.key());
310            // Return how many parameters have been refreshed...
311            return iParams;
312    }
313    
314    
315    // Device port/channel list refreshner.
316    int qsamplerDevice::refreshPorts ( lscp_client_t *pClient )
317    {
318            // Port/channel count determination...
319            int iPorts = 0;
320            switch (m_deviceType) {
321            case qsamplerDevice::Audio:
322                    iPorts = m_params["CHANNELS"].value.toInt();
323                    break;
324            case qsamplerDevice::Midi:
325                    iPorts = m_params["PORTS"].value.toInt();
326                    break;
327            case qsamplerDevice::None:
328                    break;
329            }
330            // Retrieve port/channel information...
331            m_ports.clear();
332            for (int iPort = 0; iPort < iPorts; iPort++)
333                    m_ports.append(new qsamplerDevicePort(pClient, *this, iPort));
334            // Return how many ports have been refreshed...
335            return iPorts;
336    }
337    
338    
339    // Refresh/set dependencies given that some parameter has changed.
340    int qsamplerDevice::refreshDepends ( lscp_client_t *pClient,
341            const QString& sParam )
342  {  {
343            // Refresh all parameters that depend on this one...
344            int iDepends = 0;
345            qsamplerDeviceParamMap::ConstIterator iter;
346            for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
347                    const QStringList& depends = iter.data().depends;
348                    if (depends.find(sParam) != depends.end())
349                            iDepends += refreshParam(pClient, iter.key());
350            }
351            // Return how many dependencies have been refreshed...
352            return iDepends;
353  }  }
354    
355    
356    // Refresh/set given parameter based on driver supplied dependencies.
357    int qsamplerDevice::refreshParam ( lscp_client_t *pClient,
358            const QString& sParam )
359    {
360            // Check if we have dependencies...
361            qsamplerDeviceParam& param = m_params[sParam.upper()];
362            if (param.depends.isEmpty())
363                    return 0;
364    
365            int iRefresh = 0;
366    
367            // Build dependency list...
368            lscp_param_t *pDepends = new lscp_param_t [param.depends.count() + 1];
369            int iDepend = 0;
370            QStringList::ConstIterator iter;
371            for (iter = param.depends.begin(); iter != param.depends.end(); ++iter) {
372                    const QString& sDepend = *iter;
373                    pDepends[iDepend].key   = (char *) sDepend.latin1();
374                    pDepends[iDepend].value = (char *) m_params[sDepend.upper()].value.latin1();
375                    ++iDepend;
376            }
377            // Null terminated.
378            pDepends[iDepend].key   = NULL;
379            pDepends[iDepend].value = NULL;
380    
381    #if 0
382            // FIXME: Some parameter dependencies (e.g.ALSA CARD)
383            // are blocking for no reason, causing timeout-crashes.
384    
385            // Retrieve some modern parameters...
386            lscp_param_info_t *pParamInfo = NULL;
387            switch (m_deviceType) {
388            case qsamplerDevice::Audio:
389                    pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
390                            m_sDriverName.latin1(), sParam.latin1(), pDepends);
391                    break;
392            case qsamplerDevice::Midi:
393                    pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
394                            m_sDriverName.latin1(), sParam.latin1(), pDepends);
395                    break;
396            case qsamplerDevice::None:
397                    break;
398            }
399            if (pParamInfo) {
400                    param = qsamplerDeviceParam(pParamInfo, QString(param.value));
401                    iRefresh++;
402            }
403    #endif
404            // Free used parameter array.
405            delete pDepends;
406    
407            // Return whether the parameters has been changed...
408            return iRefresh;
409    }
410    
411    
412  // Device ids enumerator.  // Device ids enumerator.
413  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,  int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
414          qsamplerDeviceType deviceType )          qsamplerDeviceType deviceType )
# Line 313  QStringList qsamplerDevice::getDrivers ( Line 454  QStringList qsamplerDevice::getDrivers (
454    
455    
456  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
457    // qsamplerDevicePort - MIDI/Audio Device port/channel structure.
458    //
459    
460    // Constructor.
461    qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,
462            const qsamplerDevice& device, int iPortID )
463    {
464            setDevicePort(pClient, device, iPortID);
465    }
466    
467    // Default destructor.
468    qsamplerDevicePort::~qsamplerDevicePort (void)
469    {
470    }
471    
472    
473    // Initializer.
474    void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,
475            const qsamplerDevice& device, int iPortID )
476    {
477            // Device port id should be always set.
478            m_iPortID = iPortID;
479    
480            // Reset port parameters anyway.
481            m_params.clear();
482    
483            // Retrieve device port/channel info, if any.
484            QString sPrefix = device.driverName() + ' ';
485            lscp_device_port_info_t *pPortInfo = NULL;
486            switch (device.deviceType()) {
487            case qsamplerDevice::Audio:
488                    sPrefix += QObject::tr("Channel");
489                    pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);
490                    break;
491            case qsamplerDevice::Midi:
492                    sPrefix += QObject::tr("Port");
493                    pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);
494                    break;
495            case qsamplerDevice::None:
496                    break;
497            }
498    
499            // If we're bogus, bail out...
500            if (pPortInfo == NULL) {
501                    m_sPortName = QString::null;
502                    return;
503            }
504    
505            // Set device port/channel properties...
506            sPrefix += " %1:";
507            m_sPortName = sPrefix.arg(m_iPortID)  + ' ' + pPortInfo->name;
508    
509            // Grab device port/channel parameters...
510            m_params.clear();
511            for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
512                    const QString sParam = pPortInfo->params[i].key;
513                    lscp_param_info_t *pParamInfo = NULL;
514                    switch (device.deviceType()) {
515                    case qsamplerDevice::Audio:
516                            pParamInfo = ::lscp_get_audio_channel_param_info(pClient,
517                                    device.deviceID(), iPortID, sParam.latin1());
518                            break;
519                    case qsamplerDevice::Midi:
520                            pParamInfo = ::lscp_get_midi_port_param_info(pClient,
521                                    device.deviceID(), iPortID, sParam.latin1());
522                            break;
523                    case qsamplerDevice::None:
524                            break;
525                    }
526                    if (pParamInfo) {
527                            m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
528                                    pPortInfo->params[i].value);
529                    }
530            }
531    }
532    
533    
534    // Device port/channel property accessors.
535    int qsamplerDevicePort::portID (void) const
536    {
537            return m_iPortID;
538    }
539    
540    const QString& qsamplerDevicePort::portName (void) const
541    {
542            return m_sPortName;
543    }
544    
545    // Device port/channel parameter accessor.
546    const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
547    {
548            return m_params;
549    }
550    
551    
552    // Set the proper device port/channel parameter value.
553    void qsamplerDevicePort::setParam ( const QString& sParam,
554            const QString& sValue )
555    {
556            m_params[sParam.upper()].value = sValue;
557    }
558    
559    
560    //-------------------------------------------------------------------------
561  // qsamplerDeviceItem - QListView device item.  // qsamplerDeviceItem - QListView device item.
562  //  //
563    
# Line 409  qsamplerDeviceParamTable::~qsamplerDevic Line 654  qsamplerDeviceParamTable::~qsamplerDevic
654  }  }
655    
656    
657  // The main table refresher.  // Common parameter table renderer.
658  void qsamplerDeviceParamTable::refresh ( qsamplerDevice& device )  void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
659            bool bEditable )
660  {  {
661          // Always (re)start it empty.          // Always (re)start it empty.
662          QTable::setUpdatesEnabled(false);          QTable::setUpdatesEnabled(false);
663          QTable::setNumRows(0);          QTable::setNumRows(0);
664    
665          // Now fill the parameter table...          // Fill the parameter table...
         qsamplerDeviceParamMap& params = device.params();  
666          QTable::insertRows(0, params.count());          QTable::insertRows(0, params.count());
667          int iRow = 0;          int iRow = 0;
668          qsamplerDeviceParamMap::ConstIterator iter;          qsamplerDeviceParamMap::ConstIterator iter;
669          for (iter = params.begin(); iter != params.end(); ++iter) {          for (iter = params.begin(); iter != params.end(); ++iter) {
670                  const qsamplerDeviceParam& param = iter.data();                  const qsamplerDeviceParam& param = iter.data();
671                  bool bEnabled = (device.deviceID() < 0 || !param.fix);                  bool bEnabled = (bEditable || !param.fix);
672                  QTable::setText(iRow, 0, iter.key());                  QTable::setText(iRow, 0, iter.key());
673                  QTable::setText(iRow, 1, param.description);                  QTable::setText(iRow, 1, param.description);
674                  if (param.type == LSCP_TYPE_BOOL) {                  if (param.type == LSCP_TYPE_BOOL) {
# Line 431  void qsamplerDeviceParamTable::refresh ( Line 676  void qsamplerDeviceParamTable::refresh (
676                          opts.append(tr("false"));                          opts.append(tr("false"));
677                          opts.append(tr("true"));                          opts.append(tr("true"));
678                          QComboTableItem *pComboItem = new QComboTableItem(this, opts);                          QComboTableItem *pComboItem = new QComboTableItem(this, opts);
679                      pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);                          pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
680                      pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
681                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
682                  } else if (param.possibilities.count() > 0) {                  } else if (param.possibilities.count() > 0 && bEnabled) {
683                          QComboTableItem *pComboItem = new QComboTableItem(this,                          QComboTableItem *pComboItem = new QComboTableItem(this,
684                                  param.possibilities);                                  param.possibilities);
685                      pComboItem->setCurrentItem(param.value);                          pComboItem->setCurrentItem(param.value);
686                      pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
687                      pComboItem->setEditable(bEnabled && param.multiplicity);                          pComboItem->setEditable(bEnabled && param.multiplicity);
688                          QTable::setItem(iRow, 2, pComboItem);                          QTable::setItem(iRow, 2, pComboItem);
689              } else if (param.type == LSCP_TYPE_INT) {                  } else if (param.type == LSCP_TYPE_INT && bEnabled
690                  qsamplerDeviceParamTableSpinBox *pSpinItem =                                  && !param.range_min.isEmpty()
691                                    && !param.range_max.isEmpty()) {
692                            qsamplerDeviceParamTableSpinBox *pSpinItem =
693                                  new qsamplerDeviceParamTableSpinBox(this,                                  new qsamplerDeviceParamTableSpinBox(this,
694                                          bEnabled ? QTableItem::OnTyping : QTableItem::Never);                                          bEnabled ? QTableItem::OnTyping : QTableItem::Never,
695                                            param.value);
696                          pSpinItem->setMinValue(param.range_min.toInt());                          pSpinItem->setMinValue(param.range_min.toInt());
697                          pSpinItem->setMaxValue(param.range_max.toInt());                          pSpinItem->setMaxValue(param.range_max.toInt());
                         pSpinItem->setValue(param.value.toInt());  
698                          QTable::setItem(iRow, 2, pSpinItem);                          QTable::setItem(iRow, 2, pSpinItem);
699                  } else {                  } else {
700              qsamplerDeviceParamTableEditBox *pEditItem =                          qsamplerDeviceParamTableEditBox *pEditItem =
701                                  new qsamplerDeviceParamTableEditBox(this,                                  new qsamplerDeviceParamTableEditBox(this,
702                                      bEnabled ? QTableItem::OnTyping : QTableItem::Never,                                          bEnabled ? QTableItem::OnTyping : QTableItem::Never,
703                                          param.value);                                          param.value);
704                          QTable::setItem(iRow, 2, pEditItem);                          QTable::setItem(iRow, 2, pEditItem);
705                  }                  }
# Line 474  void qsamplerDeviceParamTable::refresh ( Line 721  void qsamplerDeviceParamTable::refresh (
721    
722  // Constructor.  // Constructor.
723  qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (  qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
724          QTable *pTable, EditType editType )          QTable *pTable, EditType editType, const QString& sText )
725          : QTableItem(pTable, editType, QString::null)          : QTableItem(pTable, editType, sText)
726  {  {
727          m_iValue = m_iMinValue = m_iMaxValue = 0;          m_iValue = sText.toInt();
728            m_iMinValue = m_iMaxValue = 0;
729  }  }
730    
731  // Public accessors.  // Public accessors.
# Line 508  QWidget *qsamplerDeviceParamTableSpinBox Line 756  QWidget *qsamplerDeviceParamTableSpinBox
756                  pSpinBox->setMaxValue(m_iMaxValue);                  pSpinBox->setMaxValue(m_iMaxValue);
757          }          }
758          pSpinBox->setValue(m_iValue);          pSpinBox->setValue(m_iValue);
 //      pSpinBox->setEnabled(QTableItem::isEnabled());  
759          return pSpinBox;          return pSpinBox;
760  }  }
761    
762  void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )  void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
763  {  {
764          if (pWidget->inherits("QSpinBox"))          if (pWidget->inherits("QSpinBox"))
765              QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));                  QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
766          else          else
767              QTableItem::setContentFromEditor(pWidget);                  QTableItem::setContentFromEditor(pWidget);
768  }  }
769    
770    
# Line 539  QWidget *qsamplerDeviceParamTableEditBox Line 786  QWidget *qsamplerDeviceParamTableEditBox
786          QObject::connect(pEditBox, SIGNAL(returnPressed()),          QObject::connect(pEditBox, SIGNAL(returnPressed()),
787                  QTableItem::table(), SLOT(doValueChanged()));                  QTableItem::table(), SLOT(doValueChanged()));
788          pEditBox->setText(QTableItem::text());          pEditBox->setText(QTableItem::text());
 //      pEditBox->setEnabled(QTableItem::isEnabled());  
789          return pEditBox;          return pEditBox;
790  }  }
791    
792  void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )  void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
793  {  {
794          if (pWidget->inherits("QLineEdit"))          if (pWidget->inherits("QLineEdit"))
795              QTableItem::setText(((QLineEdit *) pWidget)->text());                  QTableItem::setText(((QLineEdit *) pWidget)->text());
796          else          else
797              QTableItem::setContentFromEditor(pWidget);                  QTableItem::setContentFromEditor(pWidget);
798  }  }
799    
800    
Legend:
Removed from v.442  
changed lines
  Added in v.467
  ViewVC Help
Powered by ViewVC