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