comparison transform/TransformFactory.cpp @ 487:c45e6c6722e0

* Use enum for transform type instead of trying to do dumb things like
  compare translated strings

     m_uninstalledTransformsMutex.unlock();
     return TransformUnknown;
 }
     
 
-std::vector<QString>
+std::vector<TransformDescription::Type>
 TransformFactory::getAllTransformTypes()
 {
     populateTransforms();
 
-    std::set<QString> types;
+    std::set<TransformDescription::Type> types;
     for (TransformDescriptionMap::const_iterator i = m_transforms.begin();
 	 i != m_transforms.end(); ++i) {
         types.insert(i->second.type);
     }
 
-    std::vector<QString> rv;
-    for (std::set<QString>::iterator i = types.begin(); i != types.end(); ++i) {
+    std::vector<TransformDescription::Type> rv;
+    for (std::set<TransformDescription::Type>::iterator i = types.begin(); i != types.end(); ++i) {
         rv.push_back(*i);
     }
 
     return rv;
 }
 
 std::vector<QString>
-TransformFactory::getTransformCategories(QString transformType)
+TransformFactory::getTransformCategories(TransformDescription::Type transformType)
 {
     populateTransforms();
 
     std::set<QString> categories;
     for (TransformDescriptionMap::const_iterator i = m_transforms.begin();

 
     return rv;
 }
 
 std::vector<QString>
-TransformFactory::getTransformMakers(QString transformType)
+TransformFactory::getTransformMakers(TransformDescription::Type transformType)
 {
     populateTransforms();
 
     std::set<QString> makers;
     for (TransformDescriptionMap::const_iterator i = m_transforms.begin();

     }
 
     if (haveEmpty) rv.push_back(""); // make sure empty category sorts last
 
     return rv;
+}
+
+QString
+TransformFactory::getTransformTypeName(TransformDescription::Type type) const
+{
+    switch (type) {
+    case TransformDescription::Analysis: return tr("Analysis");
+    case TransformDescription::Effects: return tr("Effects");
+    case TransformDescription::EffectsData: return tr("Effects Data");
+    case TransformDescription::Generator: return tr("Generator");
+    case TransformDescription::UnknownType: return tr("Other");
+    }
 }
 
 void
 TransformFactory::populateTransforms()
 {

                                  !plugin->getParameterDescriptors().empty());
 
 //            cerr << "Feature extraction plugin transform: " << transformId.toStdString() << " friendly name: " << friendlyName.toStdString() << endl;
 
 	    transforms[transformId] = 
-                TransformDescription(tr("Analysis"),
+                TransformDescription(TransformDescription::Analysis,
                                      category,
                                      transformId,
                                      userName,
                                      friendlyName,
                                      description,

                         .arg(pluginName)
                         .arg(maker);
                 }
 
                 transforms[transformId] = 
-                    TransformDescription(tr("Effects Data"),
+                    TransformDescription(TransformDescription::EffectsData,
                                          category,
                                          transformId,
                                          userName,
                                          userName,
                                          "",

         if (!descriptor->isSynth || descriptor->audioInputPortCount > 0) {
 
             if (descriptor->audioOutputPortCount > 0) {
 
                 QString transformId = QString("%1:A").arg(pluginId);
-                QString type = tr("Effects");
+                TransformDescription::Type type = TransformDescription::Effects;
 
                 QString description = tr("Transform audio signal with \"%1\" effect plugin (from %2)")
                     .arg(pluginName)
                     .arg(maker);
 
                 if (descriptor->audioInputPortCount == 0) {
-                    type = tr("Generators");
+                    type = TransformDescription::Generator;
                     QString description = tr("Generate audio signal using \"%1\" plugin (from %2)")
                         .arg(pluginName)
                         .arg(maker);
                 }
 

 
             QString oname = desc.getOutputName(*j);
             if (oname == "") oname = *j;
             
             TransformDescription td;
-            td.type = tr("Analysis"); //!!! should be enum or something
+            td.type = TransformDescription::Analysis;
             td.category = "";
             td.identifier = tid;
 
             if (oids.size() == 1) {
                 td.name = name;

 
         TextMatcher::Match match;
 
         match.key = i->first;
         
-        matcher.test(match, keywords, i->second.type, tr("Plugin type"), 5);
+        matcher.test(match, keywords,
+                     getTransformTypeName(i->second.type),
+                     tr("Plugin type"), 5);
+
         matcher.test(match, keywords, i->second.category, tr("Category"), 20);
         matcher.test(match, keywords, i->second.identifier, tr("System Identifier"), 6);
         matcher.test(match, keywords, i->second.name, tr("Name"), 30);
         matcher.test(match, keywords, i->second.description, tr("Description"), 20);
         matcher.test(match, keywords, i->second.maker, tr("Maker"), 10);

 
         TextMatcher::Match match;
 
         match.key = i->first;
         
-        matcher.test(match, keywords, i->second.type, tr("Plugin type"), 2);
+        matcher.test(match, keywords,
+                     getTransformTypeName(i->second.type),
+                     tr("Plugin type"), 2);
+
         matcher.test(match, keywords, i->second.category, tr("Category"), 10);
         matcher.test(match, keywords, i->second.identifier, tr("System Identifier"), 3);
         matcher.test(match, keywords, i->second.name, tr("Name"), 15);
         matcher.test(match, keywords, i->second.description, tr("Description"), 10);
         matcher.test(match, keywords, i->second.maker, tr("Maker"), 5);