gui/canvas.cpp

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2008, 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  * Copyright (C) 2007 Dave Robillard <http://drobilla.net>
   7  *
   8  **************************************************************************
   9  * This file contains implements the canvas functionality through flowcanvas
  10  **************************************************************************
  11  *
  12  * LADI Session Handler is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * LADI Session Handler is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  24  * or write to the Free Software Foundation, Inc.,
  25  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  26  */
  27
  28 #include <flowcanvas/Canvas.hpp>
  29 #include <flowcanvas/Port.hpp>
  30 #include <flowcanvas/Module.hpp>
  31
  32 #include "canvas.h"
  33
  34 class canvas_cls: public FlowCanvas::Canvas
  35 {
  36 public:
  37   canvas_cls(
  38     double width,
  39     double height,
  40     void (* connect_request)(void * port1_context, void * port2_context),
  41     void (* disconnect_request)(void * port1_context, void * port2_context),
  42     void (* module_location_changed)(void * module_context, double x, double y))
  43     : FlowCanvas::Canvas(width, height)
  44     , m_connect_request(connect_request)
  45     , m_disconnect_request(disconnect_request)
  46     , m_module_location_changed(module_location_changed)
  47   {}
  48
  49   virtual ~canvas_cls() {}
  50
  51   virtual void on_realize()
  52   {
  53     log_info("canvas_cls::on_realize");
  54     FlowCanvas::Canvas::on_realize();
  55     scroll_to_center();
  56   }
  57
  58   virtual void on_size_allocate(Gtk::Allocation& allocation)
  59   {
  60     //log_info("canvas_cls::on_size_allocate");
  61     FlowCanvas::Canvas::on_size_allocate(allocation);
  62     if (is_realized())
  63     {
  64       //log_info("... realized");
  65       scroll_to_center();
  66     }
  67   }
  68
  69   virtual void connect(boost::shared_ptr<FlowCanvas::Connectable> port1, boost::shared_ptr<FlowCanvas::Connectable> port2);
  70   virtual void disconnect(boost::shared_ptr<FlowCanvas::Connectable> port1, boost::shared_ptr<FlowCanvas::Connectable> port2);
  71
  72   void (* m_connect_request)(void * port1_context, void * port2_context);
  73   void (* m_disconnect_request)(void * port1_context, void * port2_context);
  74   void (* m_module_location_changed)(void * module_context, double x, double y);
  75 };
  76
  77 class module_cls: public FlowCanvas::Module
  78 {
  79 public:
  80   module_cls(
  81     boost::shared_ptr<FlowCanvas::Canvas> canvas,
  82     const std::string& name,
  83     double x,
  84     double y,
  85     bool show_title,
  86     bool show_port_labels,
  87     void * module_context)
  88     : FlowCanvas::Module(canvas, name, x, y, show_title, show_port_labels)
  89     , m_context(module_context)
  90   {}
  91
  92   virtual ~module_cls() {}
  93
  94   virtual void store_location()
  95   {
  96     boost::dynamic_pointer_cast<canvas_cls>(canvas().lock())->m_module_location_changed(m_context, property_x(), property_y());
  97   }
  98
  99   void create_menu()
 100   {
 101     _menu = new Gtk::Menu();
 102     _menu->items().push_back(Gtk::Menu_Helpers::MenuElem("Disconnect All", sigc::mem_fun(this, &module_cls::menu_disconnect_all)));
 103   }
 104
 105   void menu_disconnect_all()
 106   {
 107     for (FlowCanvas::PortVector::iterator p = _ports.begin(); p != _ports.end(); p++)
 108     {
 109       (*p)->disconnect_all();
 110     }
 111   }
 112
 113   void * m_context;
 114 };
 115
 116 class port_cls: public FlowCanvas::Port
 117 {
 118 public:
 119   port_cls(
 120     boost::shared_ptr<FlowCanvas::Module> module,
 121     const std::string& name,
 122     bool is_input,
 123     uint32_t color,
 124     void * port_context)
 125     : FlowCanvas::Port(module, name, is_input, color)
 126     , context(port_context)
 127   {}
 128
 129   virtual ~port_cls() {}
 130
 131   void * context;
 132 };
 133
 134 bool
 135 canvas_init(
 136   void)
 137 {
 138   Gnome::Canvas::init();
 139   return true;
 140 }
 141
 142 bool
 143 canvas_create(
 144   double width,
 145   double height,
 146   void (* connect_request)(void * port1_context, void * port2_context),
 147   void (* disconnect_request)(void * port1_context, void * port2_context),
 148   void (* module_location_changed)(void * module_context, double x, double y),
 149   canvas_handle * canvas_handle_ptr)
 150 {
 151   boost::shared_ptr<canvas_cls> * canvas;
 152
 153   canvas = new boost::shared_ptr<canvas_cls>(new canvas_cls(width, height, connect_request, disconnect_request, module_location_changed));
 154
 155   *canvas_handle_ptr = (canvas_handle)canvas;
 156
 157   return true;
 158 }
 159
 160 #define canvas_ptr ((boost::shared_ptr<canvas_cls> *)canvas)
 161
 162 GtkWidget *
 163 canvas_get_widget(
 164   canvas_handle canvas)
 165 {
 166   return ((Gtk::Widget *)canvas_ptr->get())->gobj();
 167 }
 168
 169 void
 170 canvas_destroy(
 171   canvas_handle canvas)
 172 {
 173   delete canvas_ptr;
 174 }
 175
 176 void
 177 canvas_clear(
 178   canvas_handle canvas)
 179 {
 180   FlowCanvas::ItemList modules = canvas_ptr->get()->items(); // copy
 181   for (FlowCanvas::ItemList::iterator m = modules.begin(); m != modules.end(); ++m)
 182   {
 183     boost::shared_ptr<FlowCanvas::Module> module = boost::dynamic_pointer_cast<FlowCanvas::Module>(*m);
 184     if (!module)
 185       continue;
 186
 187     FlowCanvas::PortVector ports = module->ports(); // copy
 188     for (FlowCanvas::PortVector::iterator p = ports.begin(); p != ports.end(); ++p)
 189     {
 190       boost::shared_ptr<FlowCanvas::Port> port = boost::dynamic_pointer_cast<FlowCanvas::Port>(*p);
 191       ASSERT(port != NULL);
 192       module->remove_port(port);
 193       port->hide();
 194     }
 195
 196     ASSERT(module->ports().empty());
 197     canvas_ptr->get()->remove_item(module);
 198   }
 199 }
 200
 201 void
 202 canvas_get_size(
 203   canvas_handle canvas,
 204   double * width_ptr,
 205   double * height_ptr)
 206 {
 207   *width_ptr = canvas_ptr->get()->width();
 208   *height_ptr = canvas_ptr->get()->height();
 209 }
 210
 211 void
 212 canvas_scroll_to_center(
 213   canvas_handle canvas)
 214 {
 215   if (canvas_ptr->get()->is_realized())
 216   {
 217     //log_info("realized");
 218     canvas_ptr->get()->scroll_to_center();
 219   }
 220   else
 221   {
 222     //log_info("NOT realized");
 223   }
 224 }
 225
 226 void
 227 canvas_set_zoom(
 228   canvas_handle canvas,
 229   double pix_per_unit)
 230 {
 231   canvas_ptr->get()->set_zoom(pix_per_unit);
 232 }
 233
 234 void
 235 canvas_arrange(
 236   canvas_handle canvas)
 237 {
 238   Glib::RefPtr<Gdk::Window> win = canvas_ptr->get()->get_window();
 239   if (!win)
 240   {
 241     return;
 242   }
 243
 244   canvas_ptr->get()->arrange();
 245
 246   // arrange does not cause locations stored, emulate it
 247   FlowCanvas::ItemList modules = canvas_ptr->get()->items(); // copy
 248   for (FlowCanvas::ItemList::iterator m = modules.begin(); m != modules.end(); ++m)
 249   {
 250     boost::shared_ptr<FlowCanvas::Module> module = boost::dynamic_pointer_cast<FlowCanvas::Module>(*m);
 251     if (!module)
 252       continue;
 253
 254     module->store_location();
 255   }
 256 }
 257
 258 bool
 259 canvas_create_module(
 260   canvas_handle canvas,
 261   const char * name,
 262   double x,
 263   double y,
 264   bool show_title,
 265   bool show_port_labels,
 266   void * module_context,
 267   canvas_module_handle * module_handle_ptr)
 268 {
 269   boost::shared_ptr<FlowCanvas::Module> * module;
 270
 271   module = new boost::shared_ptr<FlowCanvas::Module>(new module_cls(*canvas_ptr, name, x, y, show_title, show_port_labels, module_context));
 272   canvas_ptr->get()->add_item(*module);
 273   module->get()->resize();
 274
 275   *module_handle_ptr = (canvas_module_handle)module;
 276
 277   return true;
 278 }
 279
 280 #define module_ptr ((boost::shared_ptr<FlowCanvas::Module> *)module)
 281
 282 void
 283 canvas_set_module_name(
 284   canvas_module_handle module,
 285   const char * name)
 286 {
 287   module_ptr->get()->set_name(name);
 288 }
 289
 290 bool
 291 canvas_destroy_module(
 292   canvas_handle canvas,
 293   canvas_module_handle module)
 294 {
 295   canvas_ptr->get()->remove_item(*module_ptr);
 296   delete module_ptr;
 297   return true;
 298 }
 299
 300 bool
 301 canvas_create_port(
 302   canvas_handle canvas,
 303   canvas_module_handle module,
 304   const char * name,
 305   bool is_input,
 306   int color,
 307   void * port_context,
 308   canvas_port_handle * port_handle_ptr)
 309 {
 310   boost::shared_ptr<port_cls> * port;
 311
 312   port = new boost::shared_ptr<port_cls>(new port_cls(*module_ptr, name, is_input, color, port_context));
 313
 314   module_ptr->get()->add_port(*port);
 315   module_ptr->get()->resize();
 316
 317   *port_handle_ptr = (canvas_port_handle)port;
 318
 319   return true;
 320 }
 321
 322 #undef module_ptr
 323 #define port_ptr ((boost::shared_ptr<port_cls> *)port)
 324
 325 bool
 326 canvas_destroy_port(
 327   canvas_handle canvas,
 328   canvas_port_handle port)
 329 {
 330   boost::shared_ptr<FlowCanvas::Module> module = port_ptr->get()->module().lock();
 331   module->remove_port(*port_ptr);
 332   delete port_ptr;
 333   module->resize();
 334   return true;
 335 }
 336
 337 int
 338 canvas_get_port_color(
 339   canvas_port_handle port)
 340 {
 341   return port_ptr->get()->color();
 342 }
 343
 344 void
 345 canvas_set_port_name(
 346   canvas_port_handle port,
 347   const char * name)
 348 {
 349   port_ptr->get()->set_name(name);
 350 }
 351
 352 #undef port_ptr
 353 #define port1_ptr ((boost::shared_ptr<port_cls> *)port1)
 354 #define port2_ptr ((boost::shared_ptr<port_cls> *)port2)
 355
 356 bool
 357 canvas_add_connection(
 358   canvas_handle canvas,
 359   canvas_port_handle port1,
 360   canvas_port_handle port2,
 361   uint32_t color)
 362 {
 363   canvas_ptr->get()->add_connection(*port1_ptr, *port2_ptr, color);
 364   return true;
 365 }
 366
 367 bool
 368 canvas_remove_connection(
 369   canvas_handle canvas,
 370   canvas_port_handle port1,
 371   canvas_port_handle port2)
 372 {
 373   canvas_ptr->get()->remove_connection(*port1_ptr, *port2_ptr);
 374   return true;
 375 }
 376
 377 #undef port1_ptr
 378 #undef port2_ptr
 379
 380 void
 381 canvas_cls::connect(
 382   boost::shared_ptr<FlowCanvas::Connectable> c1,
 383   boost::shared_ptr<FlowCanvas::Connectable> c2)
 384 {
 385   if (m_connect_request != NULL)
 386   {
 387     boost::shared_ptr<port_cls> port1 = boost::dynamic_pointer_cast<port_cls>(c1);
 388     boost::shared_ptr<port_cls> port2 = boost::dynamic_pointer_cast<port_cls>(c2);
 389     m_connect_request(port1->context, port2->context);
 390   }
 391 }
 392
 393 void
 394 canvas_cls::disconnect(
 395   boost::shared_ptr<FlowCanvas::Connectable> c1,
 396   boost::shared_ptr<FlowCanvas::Connectable> c2)
 397 {
 398   if (m_disconnect_request != NULL)
 399   {
 400     boost::shared_ptr<port_cls> port1 = boost::dynamic_pointer_cast<port_cls>(c1);
 401     boost::shared_ptr<port_cls> port2 = boost::dynamic_pointer_cast<port_cls>(c2);
 402     m_disconnect_request(port1->context, port2->context);
 403   }
 404 }
 405
 406 bool
 407 canvas_enum_modules(
 408   canvas_handle canvas,
 409   void * callback_context,
 410   bool (* callback)(void * context, canvas_module_handle module))
 411 {
 412   return false;
 413 }
 414
 415 bool
 416 canvas_enum_module_ports(
 417   canvas_handle canvas,
 418   canvas_module_handle module,
 419   void * callback_context,
 420   bool (* callback)(void * context, canvas_port_handle port))
 421 {
 422   return false;
 423 }