implemented much of the project loading logic

Still not functional, but much of the groundwork is done.

app/node/input.cpp

@@ -26,6 +26,7 @@
 
 #include "common/bezier.h"
 #include "common/lerp.h"
+#include "common/xmlreadloop.h"
 #include "node.h"
 #include "output.h"
 #include "inputarray.h"
@@ -84,6 +85,85 @@ QString NodeInput::name()
   return NodeParam::name();
 }
 
+void NodeInput::Load(QXmlStreamReader *reader)
+{
+  XMLAttributeLoop(reader, attr) {
+    if (attr.name() == "keyframing") {
+      set_is_keyframing(attr.value() == "1");
+    }
+  }
+
+  XMLReadLoop(reader, "input") {
+    if (reader->isStartElement()) {
+      if (reader->name() == "standard") {
+        // Load standard value
+        int val_index = 0;
+
+        XMLReadLoop(reader, "standard") {
+          if (reader->name() == "value") {
+            reader->readNext();
+
+            QString value_text = reader->text().toString();
+
+            if (value_text.isEmpty()) {
+              standard_value_.replace(val_index, QVariant());
+            } else {
+              standard_value_.replace(val_index, value_text);
+            }
+
+            val_index++;
+          }
+        }
+      } else if (reader->name() == "keyframes") {
+        int track = 0;
+
+        XMLReadLoop(reader, "keyframes") {
+          if (reader->name() == "track") {
+            XMLReadLoop(reader, "track") {
+              if (reader->name() == "key") {
+                rational key_time;
+                NodeKeyframe::Type key_type;
+                QVariant key_value;
+                QPointF key_in_handle;
+                QPointF key_out_handle;
+
+                XMLAttributeLoop(reader, attr) {
+                  if (attr.name() == "time") {
+                    key_time = rational::fromString(attr.value().toString());
+                  } else if (attr.name() == "type") {
+                    key_type = static_cast<NodeKeyframe::Type>(attr.value().toInt());
+                  } else if (attr.name() == "inhandlex") {
+                    key_in_handle.setX(attr.value().toDouble());
+                  } else if (attr.name() == "inhandley") {
+                    key_in_handle.setY(attr.value().toDouble());
+                  } else if (attr.name() == "outhandlex") {
+                    key_out_handle.setX(attr.value().toDouble());
+                  } else if (attr.name() == "outhandley") {
+                    key_out_handle.setY(attr.value().toDouble());
+                  }
+                }
+
+                reader->readNext();
+
+                key_value = reader->text().toString();
+
+                NodeKeyframePtr key = NodeKeyframe::Create(key_time, key_value, key_type, track);
+                key->set_bezier_control_in(key_in_handle);
+                key->set_bezier_control_out(key_out_handle);
+                keyframe_tracks_[track].append(key);
+              }
+            }
+
+            track++;
+          }
+        }
+      } else {
+
+      }
+    }
+  }
+}
+
 void NodeInput::Save(QXmlStreamWriter *writer) const
 {
   writer->writeStartElement("input");
@@ -114,6 +194,10 @@ void NodeInput::Save(QXmlStreamWriter *writer) const
 
       writer->writeAttribute("time", key->time().toString());
       writer->writeAttribute("type", QString::number(key->type()));
+      writer->writeAttribute("inhandlex", QString::number(key->bezier_control_in().x()));
+      writer->writeAttribute("inhandley", QString::number(key->bezier_control_in().y()));
+      writer->writeAttribute("outhandlex", QString::number(key->bezier_control_out().x()));
+      writer->writeAttribute("outhandley", QString::number(key->bezier_control_out().y()));
 
       writer->writeCharacters(key->value().toString());
 
@@ -137,6 +221,10 @@ const NodeParam::DataType &NodeInput::data_type() const
   return data_type_;
 }
 
+void NodeInput::LoadInternal(QXmlStreamReader *reader)
+{
+}
+
 void NodeInput::SaveInternal(QXmlStreamWriter *writer) const
 {
 }

app/node/input.h

@@ -54,6 +54,8 @@ public:
 
   virtual QString name() override;
 
+  virtual void Load(QXmlStreamReader* reader) override;
+
   virtual void Save(QXmlStreamWriter* writer) const override;
 
   /**
@@ -241,6 +243,8 @@ signals:
   void KeyframeRemoved(NodeKeyframePtr key);
 
 protected:
+  virtual void LoadInternal(QXmlStreamReader* reader);
+
   virtual void SaveInternal(QXmlStreamWriter* writer) const;
 
 private:

app/node/inputarray.cpp

@@ -1,5 +1,6 @@
 #include "inputarray.h"
 
+#include "common/xmlreadloop.h"
 #include "node.h"
 
 NodeInputArray::NodeInputArray(const QString &id, const DataType &type, const QVariant &default_value) :
@@ -167,6 +168,18 @@ void NodeInputArray::RemoveAt(int index)
   RemoveLast();
 }
 
+void NodeInputArray::LoadInternal(QXmlStreamReader *reader)
+{
+  if (reader->name() == "subparameters") {
+    XMLReadLoop(reader, "subparameters") {
+      if (reader->name() == "input") {
+        Append();
+        At(GetSize() - 1)->Load(reader);
+      }
+    }
+  }
+}
+
 void NodeInputArray::SaveInternal(QXmlStreamWriter *writer) const
 {
   writer->writeStartElement("subparameters");

app/node/inputarray.h

@@ -33,6 +33,8 @@ signals:
   void SizeChanged(int size);
 
 protected:
+  virtual void LoadInternal(QXmlStreamReader* reader) override;
+
   virtual void SaveInternal(QXmlStreamWriter* writer) const override;
 
 private:

app/node/node.cpp

@@ -23,6 +23,8 @@
 #include <QDebug>
 #include <QFile>
 
+#include "common/xmlreadloop.h"
+
 Node::Node() :
   can_be_deleted_(true)
 {
@@ -47,6 +49,39 @@ Node::~Node()
   }
 }
 
+void Node::Load(QXmlStreamReader *reader)
+{
+  XMLReadLoop(reader, "node") {
+    if (reader->isStartElement()) {
+      if (reader->name() == "input" || reader->name() == "output") {
+        QString param_id;
+
+        XMLAttributeLoop(reader, attr) {
+          if (attr.name() == "id") {
+            param_id = attr.value().toString();
+
+            break;
+          }
+        }
+
+        if (param_id.isEmpty()) {
+          qDebug() << "Found parameter with no ID";
+          continue;
+        }
+
+        NodeParam* param = GetParameterWithID(param_id);
+
+        if (!param) {
+          qDebug() << "No parameter in" << id() << "with parameter" << param_id;
+          continue;
+        }
+
+        param->Load(reader);
+      }
+    }
+  }
+}
+
 void Node::Save(QXmlStreamWriter *writer) const
 {
   writer->writeStartElement("node");

app/node/node.h

@@ -65,6 +65,11 @@ public:
    */
   virtual Node* copy() const = 0;
 
+  /**
+   * @brief Clear current node variables and replace them with
+   */
+  void Load(QXmlStreamReader* reader);
+
   /**
    * @brief Save this node into a text/XML format
    */

app/node/output.cpp

@@ -41,6 +41,10 @@ QString NodeOutput::name()
   return NodeParam::name();
 }
 
+void NodeOutput::Load(QXmlStreamReader *reader)
+{
+}
+
 void NodeOutput::Save(QXmlStreamWriter *writer) const
 {
   writer->writeStartElement("output");

app/node/output.h

@@ -42,6 +42,8 @@ public:
 
   virtual QString name() override;
 
+  virtual void Load(QXmlStreamReader *reader) override;
+
   virtual void Save(QXmlStreamWriter* writer) const override;
 
 private:

app/node/param.h

@@ -230,6 +230,11 @@ public:
 
   virtual ~NodeParam() override;
 
+  /**
+   * @brief Load function
+   */
+  virtual void Load(QXmlStreamReader* reader) = 0;
+
   /**
    * @brief Save function
    */