From f43bdc8241e1bfab0980199bcd995e214ff94720 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sun, 11 Jun 2006 23:53:39 +0000 Subject: Moved Store code to client lib directory git-svn-id: http://svn.drobilla.net/lad/grauph@28 a436a847-0d15-0410-975c-d299462d15a1 --- src/libs/client/Makefile.am | 2 + src/libs/client/Store.cpp | 263 ++++++++++++++++++++++++++++++++++++++++++++ src/libs/client/Store.h | 84 ++++++++++++++ 3 files changed, 349 insertions(+) create mode 100644 src/libs/client/Store.cpp create mode 100644 src/libs/client/Store.h (limited to 'src/libs/client') diff --git a/src/libs/client/Makefile.am b/src/libs/client/Makefile.am index 4378d789..01cff357 100644 --- a/src/libs/client/Makefile.am +++ b/src/libs/client/Makefile.am @@ -35,6 +35,8 @@ libomclient_la_SOURCES = \ PatchLibrarian.cpp \ ConnectionModel.h \ ConnectionModel.cpp \ + Store.h \ + Store.cpp \ $(top_srcdir)/src/common/util/Path.h \ $(top_srcdir)/src/common/interface/ClientInterface.h \ $(top_srcdir)/src/common/interface/EngineInterface.h diff --git a/src/libs/client/Store.cpp b/src/libs/client/Store.cpp new file mode 100644 index 00000000..ae285305 --- /dev/null +++ b/src/libs/client/Store.cpp @@ -0,0 +1,263 @@ +/* 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 "Store.h" +#include "ObjectModel.h" +#include "PatchModel.h" +#include "NodeModel.h" +#include "PortModel.h" +#include "PluginModel.h" +#include "PatchModel.h" +#include "SigClientInterface.h" + +namespace LibOmClient { + +Store::Store(SigClientInterface& emitter) +{ + //emitter.new_plugin_sig.connect(sigc::mem_fun(this, &Store::add_plugin)); + emitter.object_destroyed_sig.connect(sigc::mem_fun(this, &Store::destruction_event)); + emitter.new_plugin_sig.connect(sigc::mem_fun(this, &Store::new_plugin_event)); + emitter.new_patch_sig.connect(sigc::mem_fun(this, &Store::new_patch_event)); + emitter.new_node_sig.connect(sigc::mem_fun(this, &Store::new_node_event)); + emitter.new_port_sig.connect(sigc::mem_fun(this, &Store::new_port_event)); +} + + +void +Store::add_object(CountedPtr object) +{ + assert(object->path() != ""); + assert(m_objects.find(object->path()) == m_objects.end()); + + m_objects[object->path()] = object; + + cout << "[Store] Added " << object->path() << endl; +} + + +CountedPtr +Store::remove_object(const string& path) +{ + map >::iterator i = m_objects.find(path); + + if (i != m_objects.end()) { + assert((*i).second->path() == path); + CountedPtr result = (*i).second; + m_objects.erase(i); + cout << "[Store] Removed " << path << endl; + return result; + } else { + cerr << "[Store] Unable to find object " << path << " to remove." << endl; + return NULL; + } +} + + +CountedPtr +Store::plugin(const string& uri) +{ + assert(uri.length() > 0); + map >::iterator i = m_plugins.find(uri); + if (i == m_plugins.end()) + return NULL; + else + return (*i).second; +} + + +CountedPtr +Store::object(const string& path) +{ + assert(path.length() > 0); + map >::iterator i = m_objects.find(path); + if (i == m_objects.end()) + return NULL; + else + return (*i).second; +} + + +CountedPtr +Store::patch(const string& path) +{ + assert(path.length() > 0); + map >::iterator i = m_objects.find(path); + if (i == m_objects.end()) + return NULL; + else + //return dynamic_cast((*i).second.get()); + return (CountedPtr)(*i).second; // FIXME +} + + +CountedPtr +Store::node(const string& path) +{ + assert(path.length() > 0); + map >::iterator i = m_objects.find(path); + if (i == m_objects.end()) + return NULL; + else + return (*i).second; +} + + +CountedPtr +Store::port(const string& path) +{ + assert(path.length() > 0); + map >::iterator i = m_objects.find(path); + if (i == m_objects.end()) { + return NULL; + } else { + // Normal port + /*PortModel* const pc = dynamic_cast((*i).second); + if (pc) + return pc;*/ + return (*i).second; + + // Patch port (corresponding Node is in store) + // FIXME + // + /* + NodeModel* const nc = dynamic_cast((*i).second); + if (nc) + return nc->as_port(); // Patch port (maybe) + */ + } + + return NULL; +} + + +void +Store::add_plugin(CountedPtr pm) +{ + if (m_plugins.find(pm->uri()) != m_plugins.end()) { + cerr << "DUPE PLUGIN: " << pm->uri() << endl; + } else { + m_plugins[pm->uri()] = pm; + } +} + + + +/* ****** Signal Handlers ******** */ + + +void +Store::destruction_event(const string& path) +{ + remove_object(path); + // FIXME: emit signals +} + +void +Store::new_plugin_event(const string& type, const string& uri, const string& name) +{ + PluginModel* const p = new PluginModel(type, uri); + p->name(name); + add_plugin(p); +} + + +void +Store::new_patch_event(const string& path, uint32_t poly) +{ + // FIXME: What to do with a conflict? + + if (m_objects.find(path) == m_objects.end()) { + PatchModel* const p = new PatchModel(path, poly); + add_object(p); + } +} + + +void +Store::new_node_event(const string& plugin_type, const string& plugin_uri, const string& node_path, bool is_polyphonic, uint32_t num_ports) +{ + // FIXME: What to do with a conflict? + // FIXME: resolve plugin here + + + if (m_objects.find(node_path) == m_objects.end()) { + + CountedPtr plug = plugin(plugin_uri); + assert(plug); + + CountedPtr n(new NodeModel(plug, node_path)); + n->polyphonic(is_polyphonic); + // FIXME: num_ports unused + add_object(n); + + std::map >::iterator pi = m_objects.find(n->path().parent()); + if (pi != m_objects.end()) { + PatchModel* parent = dynamic_cast((*pi).second.get()); + if (parent) + parent->add_node(n); + else + cerr << "ERROR: new node with no parent" << endl; + } + } +} + + +void +Store::new_port_event(const string& path, const string& type, bool is_output) +{ + // FIXME: this sucks + /* + if (m_objects.find(path) == m_objects.end()) { + PortModel::Type ptype = PortModel::CONTROL; + if (type == "AUDIO") ptype = PortModel::AUDIO; + else if (type == "CONTROL") ptype = PortModel::CONTROL; + else if (type== "MIDI") ptype = PortModel::MIDI; + else cerr << "[OSCListener] WARNING: Unknown port type received (" << type << ")" << endl; + + PortModel::Direction pdir = is_output ? PortModel::OUTPUT : PortModel::INPUT; + + PortModel* const p = new PortModel(path, ptype, pdir); + + add_object(p); + } else + */ + if (m_objects.find(path) == m_objects.end()) { + + PortModel::Type ptype = PortModel::CONTROL; + if (type == "AUDIO") ptype = PortModel::AUDIO; + else if (type == "CONTROL") ptype = PortModel::CONTROL; + else if (type== "MIDI") ptype = PortModel::MIDI; + else cerr << "[OSCListener] WARNING: Unknown port type received (" << type << ")" << endl; + + PortModel::Direction pdir = is_output ? PortModel::OUTPUT : PortModel::INPUT; + + CountedPtr p(new PortModel(path, ptype, pdir)); + add_object(p); + + std::map >::iterator pi = m_objects.find(p->path().parent()); + if (pi != m_objects.end()) { + NodeModel* parent = dynamic_cast((*pi).second.get()); + if (parent) + parent->add_port(p); + else + cerr << "ERROR: new port with no parent" << endl; + } + } +} + + +} // namespace LibOmClient + diff --git a/src/libs/client/Store.h b/src/libs/client/Store.h new file mode 100644 index 00000000..2b32dde6 --- /dev/null +++ b/src/libs/client/Store.h @@ -0,0 +1,84 @@ +/* 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 + */ + +#ifndef STORE_H +#define STORE_H + +// FIXME: for CountedPtr +#define WITH_RTTI + +#include +#include +#include +#include "util/CountedPtr.h" +using std::string; using std::map; + +namespace LibOmClient { + +class SigClientInterface; +class ObjectModel; +class PluginModel; +class PatchModel; +class NodeModel; +class PortModel; + +/** Singeton which holds all "Om Objects" for easy/fast lookup + * + * \ingroup OmGtk + */ +class Store { +public: + CountedPtr plugin(const string& uri); + CountedPtr object(const string& path); + CountedPtr patch(const string& path); + CountedPtr node(const string& path); + CountedPtr port(const string& path); + + size_t num_objects() { return m_objects.size(); } + + + const map >& plugins() const { return m_plugins; } + + static void instantiate(SigClientInterface& emitter) + { if (!_instance) _instance = new Store(emitter); } + + inline static Store& instance() { assert(_instance); return *_instance; } + +private: + Store(SigClientInterface& emitter); + + static Store* _instance; + + void add_object(CountedPtr object); + CountedPtr remove_object(const string& path); + + void add_plugin(CountedPtr plugin); + + // Slots for SigClientInterface signals + void destruction_event(const string& path); + void new_plugin_event(const string& type, const string& uri, const string& name); + void new_patch_event(const string& path, uint32_t poly); + void new_node_event(const string& plugin_type, const string& plugin_uri, const string& node_path, bool is_polyphonic, uint32_t num_ports); + void new_port_event(const string& path, const string& data_type, bool is_output); + + map > m_objects; ///< Keyed by Om path + map > m_plugins; ///< Keyed by URI +}; + + +} // namespace LibOmClient + +#endif // STORE_H -- cgit v1.2.1