comparison widgets/PluginParameterBox.cpp @ 207:a5b3c9f580c1

* Fixes for new Vamp API changes -- I think plugin parameters are not being
  set correctly yet though

         offset = 1;
     }
 
     for (size_t i = 0; i < params.size(); ++i) {
 
+        QString identifier = params[i].identifier.c_str();
         QString name = params[i].name.c_str();
-        QString description = params[i].description.c_str();
         QString unit = params[i].unit.c_str();
 
         float min = params[i].minValue;
         float max = params[i].maxValue;
         float deft = params[i].defaultValue;
-        float value = m_plugin->getParameter(params[i].name);
+        float value = m_plugin->getParameter(params[i].identifier);
 
         float qtz = 0.0;
         if (params[i].isQuantized) qtz = params[i].quantizeStep;
 
         std::vector<std::string> valueNames = params[i].valueNames;

         }
 
         //!!! would be nice to ensure the default value corresponds to
         // an integer!
 
-        QLabel *label = new QLabel(description);
+        QLabel *label = new QLabel(name);
         m_layout->addWidget(label, i + offset, 0);
 
         ParamRec rec;
         rec.param = params[i];
         rec.dial = 0;

         rec.combo = 0;
         
         if (params[i].isQuantized && !valueNames.empty()) {
             
             QComboBox *combobox = new QComboBox;
-            combobox->setObjectName(name);
+            combobox->setObjectName(identifier);
             for (unsigned int j = 0; j < valueNames.size(); ++j) {
                 combobox->addItem(valueNames[j].c_str());
                 if (lrintf((value - min) / qtz) == j) {
                     combobox->setCurrentIndex(j);
                 }

             rec.combo = combobox;
 
         } else if (min == 0.0 && max == 1.0 && qtz == 1.0) {
             
             QCheckBox *checkbox = new QCheckBox;
-            checkbox->setObjectName(name);
+            checkbox->setObjectName(identifier);
             checkbox->setCheckState(value == 0.0 ? Qt::Unchecked : Qt::Checked);
             connect(checkbox, SIGNAL(stateChanged(int)),
                     this, SLOT(checkBoxChanged(int)));
             m_layout->addWidget(checkbox, i + offset, 2);
             rec.check = checkbox;
 
         } else {
             
             AudioDial *dial = new AudioDial;
-            dial->setObjectName(description);
+            dial->setObjectName(name);
             dial->setMinimum(imin);
             dial->setMaximum(imax);
             dial->setPageStep(1);
             dial->setNotchesVisible((imax - imin) <= 12);
             dial->setDefaultValue(lrintf((deft - min) / qtz));

             connect(dial, SIGNAL(valueChanged(int)),
                     this, SLOT(dialChanged(int)));
             m_layout->addWidget(dial, i + offset, 1);
 
             QDoubleSpinBox *spinbox = new QDoubleSpinBox;
-            spinbox->setObjectName(name);
+            spinbox->setObjectName(identifier);
             spinbox->setMinimum(min);
             spinbox->setMaximum(max);
             spinbox->setSuffix(QString(" %1").arg(unit));
             spinbox->setSingleStep(qtz);
             spinbox->setValue(value);

             m_layout->addWidget(spinbox, i + offset, 2);
             rec.dial = dial;
             rec.spin = spinbox;
         }
 
-        m_params[name] = rec;
-        m_descriptionMap[description] = name;
+        m_params[identifier] = rec;
+        m_nameMap[name] = identifier;
     }
 }
 
 void
 PluginParameterBox::dialChanged(int ival)
 {
     QObject *obj = sender();
-    QString name = obj->objectName();
-
-    if (m_params.find(name) == m_params.end() &&
-        m_descriptionMap.find(name) != m_descriptionMap.end()) {
-        name = m_descriptionMap[name];
-    }
-
-    if (m_params.find(name) == m_params.end()) {
-        std::cerr << "WARNING: PluginParameterBox::dialChanged: Unknown parameter \"" << name.toStdString() << "\"" << std::endl;
+    QString identifier = obj->objectName();
+
+    if (m_params.find(identifier) == m_params.end() &&
+        m_nameMap.find(identifier) != m_nameMap.end()) {
+        identifier = m_nameMap[identifier];
+    }
+
+    if (m_params.find(identifier) == m_params.end()) {
+        std::cerr << "WARNING: PluginParameterBox::dialChanged: Unknown parameter \"" << identifier.toStdString() << "\"" << std::endl;
         return;
     }
 
-    Vamp::PluginBase::ParameterDescriptor params = m_params[name].param;
+    Vamp::PluginBase::ParameterDescriptor params = m_params[identifier].param;
 
     float min = params.minValue;
     float max = params.maxValue;
 
     float newValue;

             qtz = (max - min) / 100.0;
         }
         newValue = min + ival * qtz;
     }
 
-    QDoubleSpinBox *spin = m_params[name].spin;
+    QDoubleSpinBox *spin = m_params[identifier].spin;
     if (spin) {
         spin->blockSignals(true);
         spin->setValue(newValue);
         spin->blockSignals(false);
     }
 
-    m_plugin->setParameter(name.toStdString(), newValue);
+    m_plugin->setParameter(identifier.toStdString(), newValue);
 
     emit pluginConfigurationChanged(PluginXml(m_plugin).toXmlString());
 }
 
 void
 PluginParameterBox::checkBoxChanged(int state)
 {
     QObject *obj = sender();
-    QString name = obj->objectName();
-
-    if (m_params.find(name) == m_params.end() &&
-        m_descriptionMap.find(name) != m_descriptionMap.end()) {
-        name = m_descriptionMap[name];
-    }
-
-    if (m_params.find(name) == m_params.end()) {
-        std::cerr << "WARNING: PluginParameterBox::checkBoxChanged: Unknown parameter \"" << name.toStdString() << "\"" << std::endl;
+    QString identifier = obj->objectName();
+
+    if (m_params.find(identifier) == m_params.end() &&
+        m_nameMap.find(identifier) != m_nameMap.end()) {
+        identifier = m_nameMap[identifier];
+    }
+
+    if (m_params.find(identifier) == m_params.end()) {
+        std::cerr << "WARNING: PluginParameterBox::checkBoxChanged: Unknown parameter \"" << identifier.toStdString() << "\"" << std::endl;
         return;
     }
 
-    Vamp::PluginBase::ParameterDescriptor params = m_params[name].param;
-
-    if (state) m_plugin->setParameter(name.toStdString(), 1.0);
-    else m_plugin->setParameter(name.toStdString(), 0.0);
+    Vamp::PluginBase::ParameterDescriptor params = m_params[identifier].param;
+
+    if (state) m_plugin->setParameter(identifier.toStdString(), 1.0);
+    else m_plugin->setParameter(identifier.toStdString(), 0.0);
 
     emit pluginConfigurationChanged(PluginXml(m_plugin).toXmlString());
 }
 
 void
 PluginParameterBox::spinBoxChanged(double value)
 {
     QObject *obj = sender();
-    QString name = obj->objectName();
-
-    if (m_params.find(name) == m_params.end() &&
-        m_descriptionMap.find(name) != m_descriptionMap.end()) {
-        name = m_descriptionMap[name];
-    }
-
-    if (m_params.find(name) == m_params.end()) {
-        std::cerr << "WARNING: PluginParameterBox::spinBoxChanged: Unknown parameter \"" << name.toStdString() << "\"" << std::endl;
+    QString identifier = obj->objectName();
+
+    if (m_params.find(identifier) == m_params.end() &&
+        m_nameMap.find(identifier) != m_nameMap.end()) {
+        identifier = m_nameMap[identifier];
+    }
+
+    if (m_params.find(identifier) == m_params.end()) {
+        std::cerr << "WARNING: PluginParameterBox::spinBoxChanged: Unknown parameter \"" << identifier.toStdString() << "\"" << std::endl;
         return;
     }
 
-    Vamp::PluginBase::ParameterDescriptor params = m_params[name].param;
+    Vamp::PluginBase::ParameterDescriptor params = m_params[identifier].param;
 
     float min = params.minValue;
     float max = params.maxValue;
 
     float qtz = 0.0;

         qtz = (max - min) / 100.0;
     }
 
     int ival = (value - min) / qtz;
 
-    AudioDial *dial = m_params[name].dial;
+    AudioDial *dial = m_params[identifier].dial;
     if (dial) {
         dial->blockSignals(true);
         dial->setValue(ival);
         dial->blockSignals(false);
     }
 
-    m_plugin->setParameter(name.toStdString(), value);
+    m_plugin->setParameter(identifier.toStdString(), value);
 
     emit pluginConfigurationChanged(PluginXml(m_plugin).toXmlString());
 }
 
 void

 
     for (std::map<QString, ParamRec>::iterator i = m_params.begin();
          i != m_params.end(); ++i) {
 
         Vamp::PluginBase::ParameterDescriptor &param = i->second.param;
-        float value = m_plugin->getParameter(param.name);
+        float value = m_plugin->getParameter(param.identifier);
 
         if (i->second.spin) {
             i->second.spin->blockSignals(true);
             i->second.spin->setValue(value);
             i->second.spin->blockSignals(false);