Added Om aka Graph aka god knows what

git-svn-id: http://svn.drobilla.net/lad/grauph@9 a436a847-0d15-0410-975c-d299462d15a1

1 files changed, 685 insertions, 0 deletions

diff --git a/src/clients/gtk/PatchController.cpp b/src/clients/gtk/PatchController.cpp
new file mode 100644
index 00000000..83ba62d9
--- /dev/null
+++ b/src/clients/gtk/PatchController.cpp
@@ -0,0 +1,685 @@
+/* This file is part of Om.  Copyright (C) 2006 Dave Robillard.
+ * 
+ * Om 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 2 of the License, or (at your option) any later
+ * version.
+ * 
+ * Om 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 details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "PatchController.h"
+#include <cassert>
+#include <cstdlib>
+#include "GladeFactory.h"
+#include "Configuration.h"
+#include "util/Path.h"
+#include "ControlPanel.h"
+#include "ConnectionModel.h"
+#include "OmFlowCanvas.h"
+#include "PatchView.h"
+#include "flowcanvas/Module.h"
+#include "PluginModel.h"
+#include "Controller.h"
+#include "SubpatchModule.h"
+#include "DSSIModule.h"
+#include "PatchWindow.h"
+#include "NodeModel.h"
+#include "OmModule.h"
+#include "OmPort.h"
+#include "ControlModel.h"
+#include "NodeControlWindow.h"
+#include "NodeController.h"
+#include "PortController.h"
+#include "App.h"
+#include "PatchTreeWindow.h"
+#include "DSSIController.h"
+#include "PatchModel.h"
+#include "Store.h"
+
+using std::cerr; using std::cout; using std::endl;
+using Om::Path;
+using namespace LibOmClient;
+
+namespace OmGtk {
+
+
+PatchController::PatchController(PatchModel* model)
+: NodeController(model),
+  m_window(NULL),
+  m_patch_view(NULL),
+  m_module_x(0),
+  m_module_y(0)
+{
+	assert(model->path().length() > 0);
+	assert(model->parent() == NULL);
+	assert(model->controller() == this); // NodeController() does this
+
+	if (model->path() != "/") {
+		PatchController* parent = Store::instance().patch(model->path().parent());
+		if (parent != NULL)
+			parent->add_subpatch(this);
+		else
+			cerr << "[PatchController] " << path() << " ERROR: Parent not found." << endl;
+	}
+}
+
+
+PatchController::~PatchController()
+{
+	if (m_patch_view != NULL) {
+		claim_patch_view();
+		m_patch_view->hide();
+		delete m_patch_view;
+		m_patch_view = NULL;
+	}
+	
+	if (m_control_window != NULL) {
+		m_control_window->hide();
+		delete m_control_window;
+		m_control_window = NULL;
+	}
+
+	if (m_window != NULL) {
+		m_window->hide();
+		delete m_window;
+		m_window = NULL;
+	}
+}
+
+
+void
+PatchController::add_to_store()
+{
+	Store::instance().add_object(this);
+}
+
+
+void
+PatchController::remove_from_store()
+{
+	Store::instance().remove_object(this);
+}
+
+
+void
+PatchController::clear()
+{
+	// Destroy model
+	// Destroying nodes removes models from patch model, which invalidates any
+	// iterator to nodes, so avoid the iterator problem by doing it this way:
+	const NodeModelMap& nodes = patch_model()->nodes();
+	size_t remaining = nodes.size();
+	
+	while (remaining > 0) {
+		NodeController* const nc = (NodeController*)(*nodes.begin()).second->controller();
+		assert(nc != NULL);
+		nc->destroy();
+		assert(nodes.size() == remaining - 1);
+		--remaining;
+	}
+	assert(nodes.empty());
+
+	patch_model()->clear();
+	
+	if (m_patch_view != NULL) {
+		assert(m_patch_view->canvas() != NULL);
+		m_patch_view->canvas()->destroy();
+	}
+}
+
+
+void
+PatchController::destroy()
+{
+	// Destroying nodes removes models from patch model, which invalidates any
+	// iterator to nodes, so avoid the iterator problem by doing it this way:
+	const NodeModelMap& nodes = patch_model()->nodes();
+	size_t remaining = nodes.size();
+	
+	while (remaining > 0) {
+		NodeController* const nc = (NodeController*)
+			(*nodes.begin()).second->controller();
+		assert(nc != NULL);
+		nc->destroy();
+		assert(nodes.size() == remaining - 1);
+		--remaining;
+	}
+	assert(nodes.empty());
+
+	//App::instance().remove_patch(this);
+	App::instance().patch_tree()->remove_patch(path());
+	
+	// Delete all children models
+	//patch_model()->clear();
+
+	// Remove self from object store
+	Store::instance().remove_object(this);
+	
+	// Delete self from parent (this will delete model)
+	if (patch_model()->parent() != NULL) {
+		PatchController* const parent = (PatchController*)patch_model()->parent()->controller();
+		assert(parent != NULL);
+		parent->remove_node(name());
+	} else {
+		delete m_model;
+	}
+}
+
+
+void
+PatchController::metadata_update(const string& key, const string& value)
+{
+	NodeController::metadata_update(key, value);
+	
+	if (key == "filename")
+		patch_model()->filename(value);
+}
+
+
+void
+PatchController::set_path(const Path& new_path)
+{
+	assert(m_model != NULL);
+	Path old_path = path();
+	
+	// Rename nodes
+	for (NodeModelMap::const_iterator i = patch_model()->nodes().begin();
+			i != patch_model()->nodes().end(); ++i) {
+		const NodeModel* const nm = (*i).second;
+		assert(nm != NULL);
+		NodeController* const nc = ((NodeController*)nm->controller());
+		assert(nc != NULL);
+		nc->set_path(new_path.base_path() + nc->node_model()->name());
+	}
+	
+#ifdef DEBUG
+	// Be sure ports were renamed by their bridge nodes
+	for (list<PortModel*>::const_iterator i = node_model()->ports().begin();
+			i != node_model()->ports().end(); ++i) {
+		GtkObjectController* const pc = (GtkObjectController*)((*i)->controller());
+		assert(pc != NULL);
+		assert(pc->path().parent()== new_path);
+	}
+#endif
+	
+	App::instance().patch_tree()->patch_renamed(old_path, new_path);
+	
+	if (m_window != NULL)
+		m_window->patch_renamed(new_path);
+
+	if (m_control_window != NULL)
+		m_control_window->set_title(new_path + " Controls");
+
+	if (m_module != NULL) {
+		assert(m_module->canvas() != NULL);
+		m_module->canvas()->rename_module(old_path.name(), new_path.name());
+		assert(m_module->name() == new_path.name());
+	}
+	
+	PatchController* parent = dynamic_cast<PatchController*>(
+		patch_model()->parent()->controller());
+	
+	if (parent != NULL && parent->window() != NULL)
+		parent->window()->node_renamed(old_path, new_path);
+
+	remove_from_store();
+	GtkObjectController::set_path(new_path);
+	add_to_store();
+	
+	if (old_path.name() != new_path.name())
+		parent->patch_model()->rename_node(old_path, new_path);
+}
+
+
+void
+PatchController::enable()
+{
+	if (m_patch_view != NULL)
+		m_patch_view->enabled(true);
+	
+	patch_model()->enabled(true);
+	
+	App::instance().patch_tree()->patch_enabled(m_model->path());
+}
+
+
+void
+PatchController::disable()
+{
+	if (m_patch_view != NULL)
+		m_patch_view->enabled(false);
+	
+	patch_model()->enabled(false);
+	
+	App::instance().patch_tree()->patch_disabled(m_model->path());
+}
+
+
+void
+PatchController::create_module(OmFlowCanvas* canvas)
+{
+	//cerr << "Creating patch module " << m_model->path() << endl;
+
+	assert(canvas != NULL);
+	assert(m_module == NULL);
+	
+	m_module = new SubpatchModule(canvas, this);
+
+
+	m_menu.remove(m_menu.items()[4]);
+
+	// Add navigation menu items
+	Gtk::Menu::MenuList& items = m_menu.items();
+	items.push_front(Gtk::Menu_Helpers::SeparatorElem());
+	items.push_front(Gtk::Menu_Helpers::MenuElem("Browse to Patch",
+		sigc::mem_fun((SubpatchModule*)m_module, &SubpatchModule::browse_to_patch)));
+	items.push_front(Gtk::Menu_Helpers::MenuElem("Open Patch in New Window",
+		sigc::mem_fun(this, &PatchController::show_patch_window)));
+	
+	create_all_ports();
+
+	m_module->move_to(node_model()->x(), node_model()->y());
+	m_module->store_location();
+}
+
+
+void
+PatchController::create_view()
+{
+	assert(m_patch_view == NULL);
+
+	Glib::RefPtr<Gnome::Glade::Xml> xml = GladeFactory::new_glade_reference();
+
+	xml->get_widget_derived("patch_view_vbox", m_patch_view);
+	assert(m_patch_view != NULL);
+	m_patch_view->patch_controller(this);
+	assert(m_patch_view->canvas() != NULL);
+
+	// Create modules for nodes
+	for (NodeModelMap::const_iterator i = patch_model()->nodes().begin();
+			i != patch_model()->nodes().end(); ++i) {
+
+		NodeModel* const nm = (*i).second;
+
+		string val = nm->get_metadata("module-x");
+		if (val != "")
+			nm->x(atof(val.c_str()));
+		val = nm->get_metadata("module-y");
+		if (val != "")
+			nm->y(atof(val.c_str()));
+
+		/* Set sane default coordinates if not set already yet */
+		if (nm->x() == 0.0f && nm->y() == 0.0f) {
+			int x, y;
+			get_new_module_location(x, y);
+			nm->x(x);
+			nm->y(y);
+		}
+
+		NodeController* nc = ((NodeController*)nm->controller());
+		assert(nc != NULL);
+		if (nc->module() == NULL);
+			nc->create_module(m_patch_view->canvas());
+		assert(nc->module() != NULL);
+		m_patch_view->canvas()->add_module(nc->module());
+	}
+
+	// Create connections
+	for (list<ConnectionModel*>::const_iterator i = patch_model()->connections().begin();
+			i != patch_model()->connections().end(); ++i) {
+		create_connection(*i);
+	}
+
+	// Set run checkbox
+	m_patch_view->enabled(patch_model()->enabled());
+}
+
+
+/** Create a connection in the view (canvas).
+ */
+void
+PatchController::create_connection(const ConnectionModel* cm)
+{
+	m_patch_view->canvas()->add_connection(
+			cm->src_port_path().parent().name(),
+			cm->src_port_path().name(),
+			cm->dst_port_path().parent().name(),
+			cm->dst_port_path().name());
+
+	// Disable control slider from destination node control window
+	
+	PortController* p = Store::instance().port(cm->dst_port_path());
+	assert(p != NULL);
+
+	if (p->control_panel() != NULL)
+		p->control_panel()->disable_port(p->path());
+	// FIXME: don't use canvas as a model (search object store)
+	/*OmModule* m = (OmModule*)m_patch_view->canvas()->find_module(
+			cm->dst_port_path().parent().name());
+
+	if (m != NULL) {
+		OmPort* p = m->port(cm->dst_port_path().name());
+		if (p != NULL && p->connections().size() == 1) {
+			p->model()->connected(true);
+			assert(m->node_model()->controller() != NULL);
+			NodeControlWindow* cw = (((NodeController*)
+				m->node_model()->controller())->control_window());
+			if (cw != NULL)
+				cw->control_panel()->disable_port(cm->dst_port_path());
+		}
+	}*/
+}
+
+
+/** Add a subpatch to this patch.
+ */
+void
+PatchController::add_subpatch(PatchController* patch)
+{
+	assert(patch != NULL);
+	assert(patch->patch_model() != NULL);
+	assert(patch->patch_model()->parent() == NULL);
+
+	/*if (pm->x() == 0 && pm->y() == 0) {
+		int x, y;
+		parent_pc->get_new_module_location(x, y);
+		pm->x(x);
+		pm->y(y);
+	}*/
+	
+	patch_model()->add_node(patch->patch_model());
+
+	if (m_patch_view != NULL) {
+		patch->create_module(m_patch_view->canvas());
+		m_patch_view->canvas()->add_module(patch->module());
+		patch->module()->resize(); 
+	}
+}
+
+
+void
+PatchController::add_node(NodeModel* nm)
+{
+	assert(nm != NULL);
+	assert(nm->parent() == NULL);
+	assert(nm->path().parent() == m_model->path());
+	
+	if (patch_model()->get_node(nm->name()) != NULL) {
+		// Node already exists, ignore
+		delete nm;
+	} else {
+		// FIXME: Should PatchController really be responsible for creating these?
+		NodeController* nc = NULL;
+		
+		if (nm->plugin()->type() == PluginModel::DSSI)
+			nc = new DSSIController(nm);
+		else
+			nc = new NodeController(nm);
+
+		assert(nc != NULL);
+		assert(nm->controller() == nc);
+		
+		// Check if this is a bridge node
+		PortModel* const pm = patch_model()->get_port(nm->path().name());
+		if (pm != NULL) {
+			cerr << "Bridge node." << endl;
+			PortController* pc = ((PortController*)pm->controller());
+			assert(pc != NULL);
+			nc->bridge_port(pc);
+		}
+		
+		nc->add_to_store();
+		patch_model()->add_node(nm);
+		
+		if (m_patch_view != NULL) {
+			
+			int x, y;
+			get_new_module_location(x, y);
+			nm->x(x);
+			nm->y(y);
+
+			// Set zoom to 1.0 so module isn't messed up (Death to GnomeCanvas)
+			float old_zoom = m_patch_view->canvas()->zoom();
+			if (old_zoom != 1.0)
+				m_patch_view->canvas()->zoom(1.0);
+			
+			if (nc->module() == NULL)
+				nc->create_module(m_patch_view->canvas());
+			assert(nc->module() != NULL);
+			m_patch_view->canvas()->add_module(nc->module());
+			nc->module()->resize();
+	
+			// Reset zoom
+			if (old_zoom != 1.0) {
+				m_patch_view->canvas()->zoom(old_zoom);
+				nc->module()->zoom(old_zoom);
+			}
+		}
+	}
+}
+
+
+/** Removes a node from this patch.
+ */
+void
+PatchController::remove_node(const string& name)
+{
+	assert(name.find("/") == string::npos);
+
+	// Update breadcrumbs if necessary
+	if (m_window != NULL)
+		m_window->node_removed(name);
+	
+	if (m_patch_view != NULL) {
+		assert(m_patch_view->canvas() != NULL);
+		m_patch_view->canvas()->remove_module(name);
+	}
+	
+	patch_model()->remove_node(name);
+}
+
+
+/** Add a port to this patch.
+ *
+ * Will add a port to the subpatch module and the control window, if they
+ * exist.
+ */
+void
+PatchController::add_port(PortModel* pm)
+{
+	assert(pm != NULL);
+	assert(pm->parent() == NULL);
+
+	//cerr << "[PatchController] Adding port " << pm->path() << endl;
+
+	if (patch_model()->get_port(pm->name()) != NULL) {
+		cerr << "[PatchController] Ignoring duplicate port "
+			<< pm->path() << endl;
+		delete pm;
+		return;
+	}
+	
+	node_model()->add_port(pm);
+	PortController* pc = new PortController(pm);
+
+	// Handle bridge ports/nodes (this is uglier than it should be)
+	NodeController* nc = Store::instance().node(pm->path());
+	if (nc != NULL)
+		nc->bridge_port(pc);
+	
+	if (m_module != NULL) {
+		pc->create_port(m_module);
+		m_module->resize();
+	}
+		
+	if (m_control_window != NULL) {
+		assert(m_control_window->control_panel() != NULL);
+		m_control_window->control_panel()->add_port(pc);
+		m_control_window->resize();
+	}
+
+	// Enable "Controls" menuitem on module and patch window, if necessary
+	if (has_control_inputs())
+		enable_controls_menuitem();
+}
+
+
+/** Removes a port from this patch
+ */
+void
+PatchController::remove_port(const Path& path, bool resize_module)
+{
+	assert(path.parent() == m_model->path());
+
+	//cerr << "[PatchController] Removing port " << path << endl;
+
+	/* FIXME
+	if (m_control_panel != NULL) {
+		m_control_panel->remove_port(path);
+		if (m_control_window != NULL) {
+			assert(m_control_window->control_panel() == m_control_panel);
+			m_control_window->resize();
+		}
+	}*/
+		
+	// Remove port on module
+	if (m_module != NULL) {
+		assert(m_module->port(path.name()) != NULL);
+		m_module->remove_port(path.name(), resize_module);
+		assert(m_module->port(path.name()) == NULL);
+	}
+	
+	patch_model()->remove_port(path);
+	assert(patch_model()->get_port(path.name()) == NULL);
+	
+	// Disable "Controls" menuitem on module and patch window, if necessary
+	if (!has_control_inputs())
+		disable_controls_menuitem();
+}
+
+
+void
+PatchController::connection(ConnectionModel* const cm)
+{
+	assert(cm != NULL);
+
+	patch_model()->add_connection(cm);
+	
+	if (m_patch_view != NULL)
+		create_connection(cm);
+}
+
+
+
+void
+PatchController::disconnection(const Path& src_port_path, const Path& dst_port_path)
+{
+	const string& src_node_name = src_port_path.parent().name();
+	const string& src_port_name = src_port_path.name();
+	const string& dst_node_name = dst_port_path.parent().name();
+	const string& dst_port_name = dst_port_path.name();
+	
+	if (m_patch_view != NULL)
+		m_patch_view->canvas()->remove_connection(
+			src_node_name, src_port_name, dst_node_name, dst_port_name);
+
+	patch_model()->remove_connection(src_port_path, dst_port_path);
+	
+	// Enable control slider in destination node control window
+	PortController* p = Store::instance().port(dst_port_path);
+	assert(p != NULL);
+
+	if (p->control_panel() != NULL)
+		p->control_panel()->enable_port(p->path());
+}
+
+
+/** Try to guess a suitable location for a new module.
+ */
+void
+PatchController::get_new_module_location(int& x, int& y)
+{
+	assert(m_patch_view != NULL);
+	assert(m_patch_view->canvas() != NULL);
+	m_patch_view->canvas()->get_scroll_offsets(x, y);
+	x += 20;
+	y += 20;
+}
+
+
+void
+PatchController::show_patch_window()
+{
+	if (m_window == NULL) {
+		Glib::RefPtr<Gnome::Glade::Xml> xml = GladeFactory::new_glade_reference();
+		
+		xml->get_widget_derived("patch_win", m_window);
+		assert(m_window != NULL);
+		
+		if (m_patch_view == NULL)
+			create_view();
+
+		m_window->patch_controller(this);
+	}
+	
+	assert(m_window != NULL);
+	m_window->present();
+}
+
+
+/** Become the parent of the patch view.
+ *
+ * Steals the view away from whatever window is currently showing it.
+ */
+void
+PatchController::claim_patch_view()
+{
+	assert(m_patch_view != NULL);
+	
+	m_patch_view->hide();
+	m_patch_view->reparent(m_patch_view_bin);
+}
+
+
+void
+PatchController::show_control_window()
+{
+	assert(patch_model() != NULL);
+
+	if (m_control_window == NULL)
+		m_control_window = new NodeControlWindow(this, patch_model()->poly());
+	
+	if (m_control_window->control_panel()->num_controls() > 0)
+		m_control_window->present();
+}
+
+
+void
+PatchController::enable_controls_menuitem()
+{
+	if (m_window != NULL)
+		m_window->menu_view_control_window()->property_sensitive() = true;
+	
+	NodeController::enable_controls_menuitem();
+}
+
+
+void
+PatchController::disable_controls_menuitem()
+{
+	if (m_window != NULL)
+		m_window->menu_view_control_window()->property_sensitive() = false;
+	
+	NodeController::disable_controls_menuitem();
+}
+
+
+} // namespace OmGtk