Work towards engine/GUI separation.

git-svn-id: http://svn.drobilla.net/lad/trunk/machina@5495 a436a847-0d15-0410-975c-d299462d15a1

1 files changed, 76 insertions, 74 deletions

diff --git a/src/engine/Controller.cpp b/src/engine/Controller.cpp
index 8c27503..8f9e1a2 100644
--- a/src/engine/Controller.cpp
+++ b/src/engine/Controller.cpp
@@ -1,6 +1,6 @@
 /*
   This file is part of Machina.
-  Copyright 2007-2013 David Robillard <http://drobilla.net>
+  Copyright 2007-2014 David Robillard <http://drobilla.net>
 
   Machina 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
@@ -14,12 +14,9 @@
   along with Machina.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "client/ClientModel.hpp"
-#include "client/ClientObject.hpp"
 #include "machina/Controller.hpp"
 #include "machina/Engine.hpp"
 #include "machina/Machine.hpp"
-#include "machina/Machine.hpp"
 #include "machina/Updates.hpp"
 
 #include "Edge.hpp"
@@ -27,26 +24,32 @@
 
 namespace machina {
 
-Controller::Controller(SPtr<Engine>         engine,
-                       client::ClientModel& client_model)
+Controller::Controller(SPtr<Engine> engine,
+                       Model&       model)
 	: _engine(engine)
-	, _client_model(client_model)
+	, _model(model)
 	, _updates(new Raul::RingBuffer(4096))
 {
 	_engine->driver()->set_update_sink(_updates);
 }
 
 uint64_t
-Controller::create(const client::ClientObject& properties)
+Controller::create(const Properties& properties)
 {
-	TimeDuration dur(
-		_engine->machine()->time().unit(),
-		properties.get(URIs::instance().machina_duration).get<float>());
+	std::map<URIInt, Atom>::const_iterator d = properties.find(
+		URIs::instance().machina_duration);
+
+	double duration = 0.0;
+	if (d != properties.end()) {
+		duration = d->second.get<float>();
+	} else {
+		std::cerr << "warning: new object has no duration" << std::endl;
+	}
+
+	TimeDuration dur(_engine->machine()->time().unit(), duration);
 	SPtr<Node> node(new Node(dur));
-	SPtr<client::ClientObject> obj(
-		new client::ClientObject(properties, node->id()));
 	_objects.insert(node);
-	_client_model.new_object(obj);
+	_model.new_object(node->id(), properties);
 	_engine->machine()->add_node(node);
 	return node->id();
 }
@@ -54,59 +57,55 @@ Controller::create(const client::ClientObject& properties)
 void
 Controller::announce(SPtr<Machine> machine)
 {
+	if (!machine) {
+		return;
+	}
+
 	Forge& forge = _engine->forge();
 
+	// Announce nodes
 	for (const auto& n : machine->nodes()) {
-		// Find or create a new client object if necessary
-		SPtr<client::ClientObject> obj = _client_model.find(n->id());
-		if (!obj) {
-			obj = SPtr<client::ClientObject>(new client::ClientObject(n->id()));
-			obj->set(URIs::instance().rdf_type,
-			         forge.make_urid(URIs::instance().machina_Node));
-			obj->set(URIs::instance().machina_duration,
-			         forge.make(float(n->duration().to_double())));
-			if (n->is_initial()) {
-				obj->set(URIs::instance().machina_initial, forge.make(true));
-			}
-
-			SPtr<MidiAction> midi_action = dynamic_ptr_cast<MidiAction>(
-				n->enter_action());
-			if (midi_action) {
-				SPtr<client::ClientObject> action = _client_model.find(
-					midi_action->id());
-				if (!action) {
-					action = SPtr<client::ClientObject>(
-						new client::ClientObject(midi_action->id()));
-					action->set(URIs::instance().machina_note_number,
-					            forge.make((int32_t)midi_action->event()[1]));
-					_client_model.new_object(action);
-				}
-				obj->set(URIs::instance().machina_enter_action,
-				         forge.make(int32_t(n->enter_action()->id())));
-			}
+		Properties properties {
+			{ URIs::instance().rdf_type,
+			  forge.make_urid(URIs::instance().machina_Node) },
+			{ URIs::instance().machina_duration,
+			  forge.make(float(n->duration().to_double())) } };
+		if (n->is_initial()) {
+			properties.insert({ URIs::instance().machina_initial,
+			                    forge.make(true) });
 		}
+
+		SPtr<MidiAction> midi_action = dynamic_ptr_cast<MidiAction>(
+			n->enter_action());
+		if (midi_action) {
+			Properties action_properties {
+				{ URIs::instance().machina_note_number,
+				  forge.make((int32_t)midi_action->event()[1]) } };
+
+			_model.new_object(midi_action->id(), action_properties);
+			properties.insert({ URIs::instance().machina_enter_action,
+			                    forge.make(int32_t(n->enter_action()->id())) });
+		}
+
 		_objects.insert(n);
-		_client_model.new_object(obj);
+		_model.new_object(n->id(), properties);
 	}
 
+	// Announce edges
 	for (const auto& n : machine->nodes()) {
 		for (const auto& e : n->edges()) {
-			SPtr<client::ClientObject> eobj = _client_model.find(e->id());
-			if (!eobj) {
-				eobj = SPtr<client::ClientObject>(
-					new client::ClientObject(e->id()));
-				eobj->set(URIs::instance().rdf_type,
-				          forge.make_urid(URIs::instance().machina_Edge));
-				eobj->set(URIs::instance().machina_probability,
-				          forge.make(e->probability()));
-				eobj->set(URIs::instance().machina_tail_id,
-				          forge.make((int32_t)n->id()));
-				eobj->set(URIs::instance().machina_head_id,
-				          forge.make((int32_t)e->head()->id()));
-			}
+			const Properties properties {
+				{ URIs::instance().rdf_type,
+				  forge.make_urid(URIs::instance().machina_Edge) },
+				{ URIs::instance().machina_probability,
+				  forge.make(e->probability()) },
+				{ URIs::instance().machina_tail_id,
+				  forge.make((int32_t)n->id()) },
+				{ URIs::instance().machina_head_id,
+				  forge.make((int32_t)e->head()->id()) } };
 
 			_objects.insert(e);
-			_client_model.new_object(eobj);
+			_model.new_object(e->id(), properties);
 		}
 	}
 }
@@ -142,7 +141,7 @@ Controller::set_property(uint64_t    object_id,
 	SPtr<Stateful> object = find(object_id);
 	if (object) {
 		object->set(key, value);
-		_client_model.property(object_id, key, value);
+		_model.set(object_id, key, value);
 	}
 }
 
@@ -152,20 +151,30 @@ Controller::connect(uint64_t tail_id, uint64_t head_id)
 	SPtr<Node> tail = dynamic_ptr_cast<Node>(find(tail_id));
 	SPtr<Node> head = dynamic_ptr_cast<Node>(find(head_id));
 
+	if (!tail) {
+		std::cerr << "error: tail node " << tail_id << " not found" << std::endl;
+		return 0;
+	} else if (!head) {
+		std::cerr << "error: head node " << head_id << " not found" << std::endl;
+		return 0;
+	}
+
 	SPtr<Edge> edge(new Edge(tail, head));
 	tail->add_edge(edge);
 	_objects.insert(edge);
 
 	Forge& forge = _engine->forge();
 
-	SPtr<client::ClientObject> obj(new client::ClientObject(edge->id()));
-	obj->set(URIs::instance().rdf_type,
-	         forge.make_urid(URIs::instance().machina_Edge));
-	obj->set(URIs::instance().machina_probability, forge.make(1.0f));
-	obj->set(URIs::instance().machina_tail_id, forge.make((int32_t)tail->id()));
-	obj->set(URIs::instance().machina_head_id, forge.make((int32_t)head->id()));
+	const Properties properties = {
+		{ URIs::instance().rdf_type,
+		  forge.make_urid(URIs::instance().machina_Edge) },
+		{ URIs::instance().machina_probability, forge.make(1.0f) },
+		{ URIs::instance().machina_tail_id,
+		  forge.make((int32_t)tail->id()) },
+		{ URIs::instance().machina_head_id,
+		  forge.make((int32_t)head->id()) } };
 
-	_client_model.new_object(obj);
+	_model.new_object(edge->id(), properties);
 
 	return edge->id();
 }
@@ -178,7 +187,7 @@ Controller::disconnect(uint64_t tail_id, uint64_t head_id)
 
 	SPtr<Edge> edge = tail->remove_edge_to(head);
 	if (edge) {
-		_client_model.erase_object(edge->id());
+		_model.erase_object(edge->id());
 	} else {
 		std::cerr << "Edge not found" << std::endl;
 	}
@@ -198,7 +207,7 @@ Controller::erase(uint64_t id)
 		_engine->machine()->remove_node(node);
 	}
 
-	_client_model.erase_object((*i)->id());
+	_model.erase_object((*i)->id());
 	_objects.erase(i);
 }
 
@@ -212,14 +221,7 @@ Controller::process_updates()
 	Atom     value;
 	for (uint32_t i = 0; i < read_space; ) {
 		i += read_set(_updates, &subject, &key, &value);
-		SPtr<client::ClientObject> obj = _client_model.find(subject);
-		if (obj) {
-			obj->set(key, value);
-		} else {
-			SPtr<client::ClientObject> obj(new client::ClientObject(subject));
-			obj->set(key, value);
-			_client_model.new_object(obj);
-		}
+		_model.set(subject, key, value);
 	}
 }