Controller: initial commit

This adds a QVariant/QMetaObject based controller for object and properties
manipulation. Object types and objects are stored in std::map structures for
now. The API is based on the prototype controller. The get/set properties only
handle a single QVariant argument instead of a QVariantList argument as in the
prototype but this can be changed.

Controller.cpp

@@ -0,0 +1,123 @@
+/*
+ * Controller.cpp
+ *
+ * (c) 2013 Sofian Audry -- info(@)sofianaudry(.)com
+ * (c) 2013 Alexandre Quessy -- alexandre(@)quessy(.)net
+ * (c) 2013 Vasilis Liaskovitis -- vliaskov@gmail.com
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+#include "Controller.h"
+#include <QMetaObject>
+#include <QMetaType>
+#include <iostream>
+
+template<class T> void Controller::registerObjType(const char* objType)
+{
+  _mControllerTypes[objType] = &(T::staticMetaObject);
+}
+
+bool Controller::createObject(const char* objType, const char* objName)
+{
+  const QMetaObject *meta = _mControllerTypes[objType];
+
+  if (meta)
+  {  
+    _mControllerObjects[objName] = meta->newInstance();
+    return true;
+  }
+  //std::cout << "object creation " << objName << " failed\n";
+  return false;
+}
+
+bool Controller::setObjectProperty(const char* objName, const char* propName,
+            const QVariant &value)
+{
+  QObject *obj = _mControllerObjects[objName];
+  if (obj)
+  {
+    if (obj->setProperty(propName, value))
+    {
+      return true;
+    }
+    else
+    {
+      //std::cout << "setproperty failed " << propName << "\n";
+      return false;
+    }
+  }  
+  //std::cout << "object " << objName << " could not be found\n";
+  return false;
+}
+
+bool Controller::getObjectProperty(const char *objName, const char *propName,
+            QVariant &value)
+{
+  QObject *obj = _mControllerObjects[objName];
+  if (obj)
+  {
+      value = obj->property(propName);
+      return value.isValid();
+  }
+  //std::cout << "Failed to get property " << propName << "\n";
+  return false;
+}
+
+bool Controller::listObjectProperties(const char *objName, QList<QString>
+    &names, QVariantList &values)
+{
+  QObject *obj = _mControllerObjects[objName];
+  if (obj)
+  {
+    const QMetaObject *metaobject = obj->metaObject();
+    int count = metaobject->propertyCount();
+    for (int i = 0; i < count; ++i)
+    {
+      QMetaProperty metaproperty = metaobject->property(i);
+      const char *propname = metaproperty.name();
+      names.append(QString(propname));
+      values.append(obj->property(propname));
+    }
+    return true;
+  }
+  return false;
+}
+
+bool Controller::listObjects(const char *objType, QList<QString> &objNames)
+{
+  const QMetaObject *meta = _mControllerTypes[objType];
+  for (std::map<const char*, QObject*>::iterator i = _mControllerObjects.begin();
+      i != _mControllerObjects.end(); i++)
+  {
+    const QObject *obj = i->second;
+    const char *name = i->first;
+    const QMetaObject *metaobject = obj->metaObject();
+    if (meta == metaobject)
+    {
+      //std::cout << "found object " << name << " of type " << objType <<  " \n";
+      objNames.append(name);
+    }
+  }
+  return true;
+}
+
+Controller::Controller(MainWindow *owner)
+{
+  _owner = owner;
+  /* Register common types for properties
+   * FIXME, we can provide a method for other classes to register types of their
+   * properties instead of doing it in the controller constructor */
+  qRegisterMetaType<int>("int");
+  qRegisterMetaType<double>("double");
+}