gui/Patchage.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 implementation of the application class
  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 "common.h"
  29
  30 #include <string.h>
  31 #include <cmath>
  32 #include <sstream>
  33 #include <fstream>
  34 #include <libgnomecanvasmm.h>
  35 #include <libglademm/xml.h>
  36 #include <gtk/gtkwindow.h>
  37 #include <boost/format.hpp>
  38
  39 #include "Patchage.hpp"
  40 #include "lash_proxy.hpp"
  41 #include "project_list.hpp"
  42 #include "session.hpp"
  43 #include "globals.hpp"
  44 #include "a2j_proxy.hpp"
  45 #include "dbus_helpers.h"
  46 #include "load_projects_dialog.hpp"
  47 #include "graph_canvas.h"
  48
  49 Patchage * g_app;
  50
  51 #define LOG_TO_STD
  52 //#define LOG_TO_STATUS
  53
  54 graph_canvas_handle g_jack_graph_canvas;
  55
  56 /* Gtk helpers (resize combo boxes) */
  57
  58 static void
  59 gtkmm_get_ink_pixel_size (Glib::RefPtr<Pango::Layout> layout,
  60              int& width,
  61              int& height)
  62 {
  63   Pango::Rectangle ink_rect = layout->get_ink_extents ();
  64
  65   width = (ink_rect.get_width() + PANGO_SCALE / 2) / PANGO_SCALE;
  66   height = (ink_rect.get_height() + PANGO_SCALE / 2) / PANGO_SCALE;
  67 }
  68
  69 static void
  70 gtkmm_set_width_for_given_text (Gtk::Widget &w, const gchar *text,
  71                gint hpadding/*, gint vpadding*/)
  72
  73 {
  74   int old_width, old_height;
  75   w.get_size_request(old_width, old_height);
  76
  77   int width, height;
  78   w.ensure_style ();
  79
  80   gtkmm_get_ink_pixel_size (w.create_pango_layout (text), width, height);
  81   w.set_size_request(width + hpadding, old_height);//height + vpadding);
  82 }
  83
  84 /* end Gtk helpers */
  85
  86
  87 #define INIT_WIDGET(x) x(g_xml, ((const char*)#x) + 1)
  88
  89 Patchage::Patchage(int argc, char** argv)
  90   : _max_dsp_load(0.0)
  91   , INIT_WIDGET(_about_win)
  92   , INIT_WIDGET(_buffer_size_combo)
  93   , INIT_WIDGET(_clear_load_but)
  94   , INIT_WIDGET(_main_scrolledwin)
  95   , INIT_WIDGET(_main_win)
  96   , INIT_WIDGET(_main_xrun_progress)
  97   , INIT_WIDGET(_main_a2j_status_label)
  98   , INIT_WIDGET(_menu_file_quit)
  99   , INIT_WIDGET(_menu_help_about)
 100   , INIT_WIDGET(_menu_jack_start)
 101   , INIT_WIDGET(_menu_jack_stop)
 102   , INIT_WIDGET(_menu_a2j_start)
 103   , INIT_WIDGET(_menu_a2j_stop)
 104   , INIT_WIDGET(_menu_load_project)
 105   , INIT_WIDGET(_menu_save_all_projects)
 106   , INIT_WIDGET(_menu_close_all_projects)
 107   , INIT_WIDGET(_menu_store_positions)
 108   , INIT_WIDGET(_menu_view_arrange)
 109   , INIT_WIDGET(_menu_view_projects)
 110   , INIT_WIDGET(_menu_view_refresh)
 111   , INIT_WIDGET(_menu_view_toolbar)
 112   , INIT_WIDGET(_project_list_viewport)
 113   , INIT_WIDGET(_sample_rate_label)
 114   , INIT_WIDGET(_toolbar)
 115   , INIT_WIDGET(_zoom_full_but)
 116   , INIT_WIDGET(_zoom_normal_but)
 117 {
 118   g_app = this;
 119
 120   graph_canvas_create(1600 * 2, 1200 * 2, &g_jack_graph_canvas);
 121
 122   while (argc > 0) {
 123     if (!strcmp(*argv, "--help")) {
 124       std::cout << "Usage: patchage [OPTIONS]\nOptions: --no-alsa" << std::endl;
 125       exit(0);
 126     }
 127
 128     argv++;
 129     argc--;
 130   }
 131
 132   patchage_dbus_init();
 133
 134   Glib::set_application_name("Patchage");
 135   _about_win->property_program_name() = "Patchage";
 136   _about_win->property_logo_icon_name() = "gladish";
 137   gtk_window_set_default_icon_name("gladish");
 138
 139   gtkmm_set_width_for_given_text(*_buffer_size_combo, "4096 frames", 40);
 140
 141   _main_scrolledwin->add(*Glib::wrap(canvas_get_widget(graph_canvas_get_canvas(g_jack_graph_canvas))));
 142
 143 //   _canvas->scroll_to(static_cast<int>(_canvas->width()/2 - 320),
 144 //                      static_cast<int>(_canvas->height()/2 - 240)); // FIXME: hardcoded
 145
 146   _main_scrolledwin->property_hadjustment().get_value()->set_step_increment(10);
 147   _main_scrolledwin->property_vadjustment().get_value()->set_step_increment(10);
 148
 149   _main_scrolledwin->signal_scroll_event().connect(
 150       sigc::mem_fun(this, &Patchage::on_scroll));
 151
 152   _buffer_size_combo->signal_changed().connect(
 153       sigc::mem_fun(this, &Patchage::buffer_size_changed));
 154   _clear_load_but->signal_clicked().connect(
 155       sigc::mem_fun(this, &Patchage::clear_load));
 156   _zoom_normal_but->signal_clicked().connect(sigc::bind(
 157       sigc::mem_fun(this, &Patchage::zoom), 1.0));
 158 //   _zoom_full_but->signal_clicked().connect(
 159 //       sigc::mem_fun(_canvas.get(), &PatchageCanvas::zoom_full));
 160
 161   _menu_load_project->signal_activate().connect(
 162       sigc::mem_fun(this, &Patchage::load_project_ask));
 163   _menu_save_all_projects->signal_activate().connect(
 164       sigc::mem_fun(this, &Patchage::save_all_projects));
 165   _menu_close_all_projects->signal_activate().connect(
 166       sigc::mem_fun(this, &Patchage::close_all_projects));
 167
 168   _menu_file_quit->signal_activate().connect(
 169       sigc::mem_fun(this, &Patchage::on_quit));
 170   _menu_view_refresh->signal_activate().connect(
 171       sigc::mem_fun(this, &Patchage::refresh));
 172   _menu_view_arrange->signal_activate().connect(
 173       sigc::mem_fun(this, &Patchage::on_arrange));
 174   _menu_view_toolbar->signal_activate().connect(
 175       sigc::mem_fun(this, &Patchage::on_view_toolbar));
 176   _menu_view_projects->signal_toggled().connect(
 177       sigc::mem_fun(this, &Patchage::on_show_projects));
 178   _menu_help_about->signal_activate().connect(
 179       sigc::mem_fun(this, &Patchage::on_help_about));
 180
 181   Glib::wrap(canvas_get_widget(graph_canvas_get_canvas(g_jack_graph_canvas)))->show();
 182   _main_win->present();
 183
 184   _about_win->set_transient_for(*_main_win);
 185
 186   _a2j = new a2j_proxy;
 187
 188   //info_msg(str(boost::format("a2j jack client name is '%s'") % _a2j->get_jack_client_name()));
 189
 190   _session = new session();
 191
 192   _project_list = new project_list(this, _session);
 193   _project_list_viewport->hide();
 194
 195   _lash = new lash_proxy(_session);
 196
 197   //_menu_jack_start->signal_activate().connect(sigc::mem_fun(_jack, &jack_proxy::start_server));
 198   //_menu_jack_stop->signal_activate().connect(sigc::mem_fun(_jack, &jack_proxy::stop_server));
 199
 200   _menu_a2j_start->signal_activate().connect(
 201     sigc::mem_fun(_a2j, &a2j_proxy::start_bridge));
 202   _menu_a2j_stop->signal_activate().connect(
 203     sigc::mem_fun(_a2j, &a2j_proxy::stop_bridge));
 204
 205   //jack_status_changed(_jack->is_started());
 206
 207   connect_widgets();
 208   update_state();
 209
 210 //   _canvas->grab_focus();
 211
 212   // Idle callback, check if we need to refresh
 213   Glib::signal_timeout().connect(
 214       sigc::mem_fun(this, &Patchage::idle_callback), 100);
 215 }
 216
 217 Patchage::~Patchage()
 218 {
 219   delete _lash;
 220   delete _project_list;
 221   delete _session;
 222   delete _a2j;
 223
 224   _about_win.destroy();
 225   //_main_win.destroy();
 226
 227   patchage_dbus_uninit();
 228 }
 229
 230 bool
 231 Patchage::idle_callback()
 232 {
 233   update_load();
 234
 235   return true;
 236 }
 237
 238 void
 239 Patchage::update_toolbar()
 240 {
 241 #if 0
 242   bool started;
 243
 244   started = _jack->is_started();
 245
 246   _buffer_size_combo->set_sensitive(started);
 247
 248   if (started)
 249   {
 250     _buffer_size_combo->set_active((int)log2f(_jack->buffer_size()) - 5);
 251   }
 252 #endif
 253 }
 254
 255 void
 256 Patchage::update_load()
 257 {
 258 #if 0
 259   if (!_jack->is_started())
 260   {
 261     _main_xrun_progress->set_text("JACK stopped");
 262     return;
 263   }
 264
 265   char tmp_buf[8];
 266   snprintf(tmp_buf, 8, "%zd", _jack->xruns());
 267
 268   _main_xrun_progress->set_text(std::string(tmp_buf) + " Dropouts");
 269
 270   float load = _jack->get_dsp_load();
 271
 272   load /= 100.0;                // dbus returns it in percents, we use 0..1
 273
 274   if (load > _max_dsp_load)
 275   {
 276     _max_dsp_load = load;
 277     _main_xrun_progress->set_fraction(load);
 278   }
 279 #endif
 280 }
 281
 282
 283 void
 284 Patchage::zoom(double z)
 285 {
 286 //   _canvas->set_zoom(z);
 287 }
 288
 289
 290 void
 291 Patchage::refresh()
 292 {
 293 //   assert(_canvas);
 294
 295 //   _canvas->destroy();
 296
 297 //   if (_jack)
 298 //     _jack->refresh();
 299
 300 //   for (ItemList::iterator i = _canvas->items().begin(); i != _canvas->items().end(); ++i) {
 301 //     (*i)->resize();
 302 //   }
 303 }
 304
 305 void
 306 Patchage::clear_load()
 307 {
 308 #if 0
 309   _main_xrun_progress->set_fraction(0.0);
 310   _jack->reset_xruns();
 311   _max_dsp_load = 0.0;
 312 #endif
 313 }
 314
 315
 316 void
 317 Patchage::error_msg(const std::string& msg)
 318 {
 319 #if defined(LOG_TO_STATUS)
 320   status_msg(msg);
 321 #endif
 322 #if defined(LOG_TO_STD)
 323   std::cerr << msg << std::endl;
 324 #endif
 325 }
 326
 327
 328 void
 329 Patchage::info_msg(const std::string& msg)
 330 {
 331 #if defined(LOG_TO_STATUS)
 332   status_msg(msg);
 333 #endif
 334 #if defined(LOG_TO_STD)
 335   std::cerr << msg << std::endl;
 336 #endif
 337 }
 338
 339
 340 void
 341 Patchage::status_msg(const std::string& msg)
 342 {
 343 }
 344
 345
 346 void
 347 Patchage::update_state()
 348 {
 349 //   for (ItemList::iterator i = _canvas->items().begin(); i != _canvas->items().end(); ++i) {
 350 //     shared_ptr<Module> module = dynamic_pointer_cast<Module>(*i);
 351 //     if (module)
 352 //       module->load_location();
 353 //   }
 354 }
 355
 356
 357 /** Update the sensitivity status of menus to reflect the present.
 358  *
 359  * (eg. disable "Connect to Jack" when Patchage is already connected to Jack)
 360  */
 361 void
 362 Patchage::connect_widgets()
 363 {
 364   //_jack->signal_started.connect(sigc::bind(sigc::mem_fun(this, &Patchage::jack_status_changed), true));
 365   //_jack->signal_stopped.connect(sigc::bind(sigc::mem_fun(this, &Patchage::jack_status_changed), false));
 366 }
 367
 368 void
 369 Patchage::jack_status_changed(
 370   bool started)
 371 {
 372   update_toolbar();
 373
 374   _menu_jack_start->set_sensitive(!started);
 375   _menu_jack_stop->set_sensitive(started);
 376   _clear_load_but->set_sensitive(started);
 377   if (!started)
 378   {
 379     _main_xrun_progress->set_fraction(0.0);
 380   }
 381 }
 382
 383 void
 384 Patchage::on_arrange()
 385 {
 386 //   assert(_canvas);
 387
 388 //   _canvas->arrange();
 389 }
 390
 391
 392 void
 393 Patchage::on_help_about()
 394 {
 395   _about_win->run();
 396   _about_win->hide();
 397 }
 398
 399
 400 void
 401 Patchage::on_quit()
 402 {
 403   _main_win->hide();
 404 }
 405
 406 void
 407 Patchage::on_show_projects()
 408 {
 409   if (_menu_view_projects->get_active())
 410     _project_list_viewport->show();
 411   else
 412     _project_list_viewport->hide();
 413 }
 414
 415 void
 416 Patchage::on_view_toolbar()
 417 {
 418   if (_menu_view_toolbar->get_active())
 419     _toolbar->show();
 420   else
 421     _toolbar->hide();
 422 }
 423
 424
 425 bool
 426 Patchage::on_scroll(GdkEventScroll* ev)
 427 {
 428   std::cout << "ON SCROLL" << std::endl;
 429   return false;
 430 }
 431
 432
 433 void
 434 Patchage::buffer_size_changed()
 435 {
 436 #if 0
 437   const int selected = _buffer_size_combo->get_active_row_number();
 438
 439   if (selected == -1)
 440   {
 441     update_toolbar();
 442   }
 443   else
 444   {
 445     uint32_t buffer_size = 1 << (selected+5);
 446
 447     // this check is temporal workaround for jack bug
 448     // we skip setting buffer size if it same as acutal one
 449     // proper place for such check is in jack
 450     if (_jack->buffer_size() != buffer_size)
 451     {
 452       if (!_jack->set_buffer_size(buffer_size))
 453       {
 454         update_toolbar(); // reset combo box to actual value
 455       }
 456     }
 457   }
 458 #endif
 459 }
 460
 461 void
 462 Patchage::set_studio_availability(
 463   bool available)
 464 {
 465   if (available)
 466   {
 467     _main_win->set_title("Active Studio - LADI Session Handler");
 468   }
 469   else
 470   {
 471     _main_win->set_title("LADI Session Handler");
 472   }
 473   _project_list->set_lash_availability(available);
 474   _menu_view_projects->set_active(available);
 475 }
 476
 477 void
 478 Patchage::set_a2j_status(
 479   unsigned int status)
 480 {
 481   const char * status_text;
 482
 483   switch (status)
 484   {
 485   case A2J_STATUS_NO_RESPONSE:
 486     status_text = "A2J N/A";
 487     _menu_a2j_start->set_sensitive(false);
 488     _menu_a2j_stop->set_sensitive(false);
 489     break;
 490   case A2J_STATUS_BRIDGE_STOPPED:
 491     status_text = "A2J bridge stopped";
 492     _menu_a2j_start->set_sensitive(true);
 493     _menu_a2j_stop->set_sensitive(false);
 494     break;
 495   case A2J_STATUS_BRIDGE_STARTED:
 496     status_text = "A2J bridge started";
 497     _menu_a2j_start->set_sensitive(false);
 498     _menu_a2j_stop->set_sensitive(true);
 499     break;
 500   default:
 501     error_msg(str(boost::format("Unknown A2J status %u") % status));
 502     status_text = "Unknown A2J status";
 503     _menu_a2j_start->set_sensitive(true);
 504     _menu_a2j_stop->set_sensitive(true);
 505     break;
 506   }
 507
 508   _main_a2j_status_label->set_text(status_text);
 509 }
 510
 511 void
 512 Patchage::load_project_ask()
 513 {
 514   std::list<lash_project_info> projects;
 515
 516   _lash->get_available_projects(projects);
 517   run_load_project_dialog(projects);
 518 }
 519
 520 void
 521 Patchage::load_project(
 522   const std::string& project_name)
 523 {
 524   _lash->load_project(project_name);
 525 }
 526
 527 void
 528 Patchage::save_all_projects()
 529 {
 530   _lash->save_all_projects();
 531 }
 532
 533 void
 534 Patchage::save_project(
 535   const std::string& project_name)
 536 {
 537   _lash->save_project(project_name);
 538 }
 539
 540 void
 541 Patchage::close_project(
 542   const std::string& project_name)
 543 {
 544   _lash->close_project(project_name);
 545 }
 546
 547 void
 548 Patchage::close_all_projects()
 549 {
 550   _lash->close_all_projects();
 551 }
 552
 553 #if 0
 554 void
 555 Patchage::on_port_added(
 556   const char * jack_client_name,
 557   const char * jack_port_name,
 558   PortType port_type,
 559   bool is_input,
 560   bool is_terminal)
 561 {
 562   bool is_a2j_mapped;
 563   std::string canvas_client_name;
 564   std::string canvas_port_name;
 565   uint32_t alsa_client_id;
 566   boost::shared_ptr<PatchageModule> module;
 567
 568   is_a2j_mapped = strcmp(_a2j->get_jack_client_name(), jack_client_name) == 0;
 569   if (is_a2j_mapped)
 570   {
 571     if (!_a2j->map_jack_port(jack_port_name, canvas_client_name, canvas_port_name, alsa_client_id))
 572     {
 573       return;
 574     }
 575
 576     canvas_port_name = str(boost::format(canvas_port_name + " [a2j:%u]") % alsa_client_id);
 577   }
 578   else
 579   {
 580     canvas_client_name = jack_client_name;
 581     canvas_port_name = jack_port_name;
 582   }
 583
 584   ModuleType module_type = InputOutput;
 585   if (_state_manager->get_module_split(canvas_client_name, is_terminal && !is_a2j_mapped)) {
 586     if (is_input) {
 587       module_type = Input;
 588     } else {
 589       module_type = Output;
 590     }
 591   }
 592
 593   module = _canvas->find_module(canvas_client_name, module_type);
 594   if (!module) {
 595     module = boost::shared_ptr<PatchageModule>(new PatchageModule(this, canvas_client_name, module_type));
 596     module->load_location();
 597     _canvas->add_item(module);
 598   }
 599
 600   if (module->get_port(canvas_port_name)) {
 601     return;
 602   }
 603
 604   boost::shared_ptr<PatchagePort> port = boost::shared_ptr<PatchagePort>(
 605     new PatchagePort(
 606       module,
 607       canvas_port_name,
 608       is_input,
 609       _state_manager->get_port_color(port_type)));
 610
 611   port->type = port_type;
 612   port->is_a2j_mapped = is_a2j_mapped;
 613   if (is_a2j_mapped)
 614   {
 615     port->a2j_jack_port_name = jack_port_name;
 616   }
 617
 618   module->add_port(port);
 619
 620   module->resize();
 621 }
 622
 623 boost::shared_ptr<PatchagePort>
 624 Patchage::lookup_port(
 625   const char * jack_client_name,
 626   const char * jack_port_name)
 627 {
 628   if (strcmp(_a2j->get_jack_client_name(), jack_client_name) == 0)
 629   {
 630     return _canvas->lookup_port_by_a2j_jack_port_name(jack_port_name);
 631   }
 632
 633   return _canvas->get_port(jack_client_name, jack_port_name);
 634 }
 635
 636 void
 637 Patchage::on_port_removed(
 638   const char * jack_client_name,
 639   const char * jack_port_name)
 640 {
 641   boost::shared_ptr<PatchagePort> port = lookup_port(jack_client_name, jack_port_name);
 642   if (!port) {
 643     error_msg(str(boost::format("Unable to remove unknown port '%s':'%s'") % jack_client_name % jack_port_name));
 644     return;
 645   }
 646
 647   boost::shared_ptr<PatchageModule> module = dynamic_pointer_cast<PatchageModule>(port->module().lock());
 648
 649   module->remove_port(port);
 650   port.reset();
 651
 652   // No empty modules (for now)
 653   if (module->num_ports() == 0) {
 654     _canvas->remove_item(module);
 655     module.reset();
 656   } else {
 657     module->resize();
 658   }
 659 }
 660
 661 void
 662 Patchage::on_ports_connected(
 663   const char * jack_client1_name,
 664   const char * jack_port1_name,
 665   const char * jack_client2_name,
 666   const char * jack_port2_name)
 667 {
 668   boost::shared_ptr<PatchagePort> port1 = lookup_port(jack_client1_name, jack_port1_name);
 669   if (!port1) {
 670     error_msg((std::string)"Unable to connect unknown port '" + jack_port1_name + "' of client '" + jack_client1_name + "'");
 671     return;
 672   }
 673
 674   boost::shared_ptr<PatchagePort> port2 = lookup_port(jack_client2_name, jack_port2_name);
 675   if (!port2) {
 676     error_msg((std::string)"Unable to connect unknown port '" + jack_port2_name + "' of client '" + jack_client2_name + "'");
 677     return;
 678   }
 679
 680   _canvas->add_connection(port1, port2, port1->color() + 0x22222200);
 681 }
 682
 683 void
 684 Patchage::on_ports_disconnected(
 685   const char * jack_client1_name,
 686   const char * jack_port1_name,
 687   const char * jack_client2_name,
 688   const char * jack_port2_name)
 689 {
 690   boost::shared_ptr<PatchagePort> port1 = lookup_port(jack_client1_name, jack_port1_name);
 691   if (!port1) {
 692     error_msg((std::string)"Unable to disconnect unknown port '" + jack_port1_name + "' of client '" + jack_client1_name + "'");
 693     return;
 694   }
 695
 696   boost::shared_ptr<PatchagePort> port2 = lookup_port(jack_client2_name, jack_port2_name);
 697   if (!port2) {
 698     error_msg((std::string)"Unable to disconnect unknown port '" + jack_port2_name + "' of client '" + jack_client2_name + "'");
 699     return;
 700   }
 701
 702   _canvas->remove_connection(port1, port2);
 703 }
 704
 705 static
 706 bool
 707 port_type_match(
 708   boost::shared_ptr<PatchagePort> port1,
 709   boost::shared_ptr<PatchagePort> port2)
 710 {
 711   return port1->type == port2->type;
 712 }
 713
 714 void
 715 Patchage::get_port_jack_names(
 716   boost::shared_ptr<PatchagePort> port,
 717   std::string& jack_client_name,
 718   std::string& jack_port_name)
 719 {
 720   if (port->is_a2j_mapped)
 721   {
 722     jack_client_name = _a2j->get_jack_client_name();
 723     jack_port_name = port->a2j_jack_port_name;
 724   }
 725   else
 726   {
 727     jack_client_name = port->module().lock()->name();
 728     jack_port_name = port->name();
 729   }
 730 }
 731
 732 void
 733 Patchage::connect(
 734   boost::shared_ptr<PatchagePort> port1,
 735   boost::shared_ptr<PatchagePort> port2)
 736 {
 737   std::string jack_client1_name;
 738   std::string jack_port1_name;
 739   std::string jack_client2_name;
 740   std::string jack_port2_name;
 741
 742   if (port_type_match(port1, port2))
 743   {
 744     get_port_jack_names(port1, jack_client1_name, jack_port1_name);
 745     get_port_jack_names(port2, jack_client2_name, jack_port2_name);
 746
 747     _jack->connect(
 748       jack_client1_name.c_str(),
 749       jack_port1_name.c_str(),
 750       jack_client2_name.c_str(),
 751       jack_port2_name.c_str());
 752   }
 753   else
 754   {
 755     status_msg("ERROR: Attempt to connect ports with mismatched types");
 756   }
 757 }
 758
 759 void
 760 Patchage::disconnect(
 761   boost::shared_ptr<PatchagePort> port1,
 762   boost::shared_ptr<PatchagePort> port2)
 763 {
 764   std::string jack_client1_name;
 765   std::string jack_port1_name;
 766   std::string jack_client2_name;
 767   std::string jack_port2_name;
 768
 769   if (port_type_match(port1, port2))
 770   {
 771     get_port_jack_names(port1, jack_client1_name, jack_port1_name);
 772     get_port_jack_names(port2, jack_client2_name, jack_port2_name);
 773
 774     _jack->disconnect(
 775       jack_client1_name.c_str(),
 776       jack_port1_name.c_str(),
 777       jack_client2_name.c_str(),
 778       jack_port2_name.c_str());
 779   }
 780   else
 781   {
 782     status_msg("ERROR: Attempt to disconnect ports with mismatched types");
 783   }
 784 }
 785
 786 /** Destroy all JACK (canvas) ports.
 787  */
 788 void
 789 Patchage::clear_canvas()
 790 {
 791   ItemList modules = _canvas->items(); // copy
 792   for (ItemList::iterator m = modules.begin(); m != modules.end(); ++m) {
 793     shared_ptr<Module> module = dynamic_pointer_cast<Module>(*m);
 794     if (!module)
 795       continue;
 796
 797     PortVector ports = module->ports(); // copy
 798     for (PortVector::iterator p = ports.begin(); p != ports.end(); ++p) {
 799       boost::shared_ptr<PatchagePort> port = boost::dynamic_pointer_cast<PatchagePort>(*p);
 800       if (port)
 801       {
 802         module->remove_port(port);
 803         port->hide();
 804       }
 805     }
 806
 807     if (module->ports().empty())
 808       _canvas->remove_item(module);
 809     else
 810       module->resize();
 811   }
 812 }
 813
 814 bool
 815 Patchage::is_canvas_empty()
 816 {
 817   return _canvas->items().empty();
 818 }
 819 #endif