gui/main.c

   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 the code that implements main() and other top-level functionality
  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 <dbus/dbus-glib.h>
  31 #include <dbus/dbus-glib-lowlevel.h>
  32
  33 #include <math.h>
  34
  35 #include "glade.h"
  36 #include "canvas.h"
  37 #include "graph_canvas.h"
  38 #include "../proxies/jack_proxy.h"
  39 #include "../proxies/control_proxy.h"
  40 #include "../dbus_constants.h"
  41 #include "world_tree.h"
  42 #include "graph_view.h"
  43 #include "../catdup.h"
  44 #include "../proxies/studio_proxy.h"
  45 #include "ask_dialog.h"
  46 #include "../proxies/app_supervisor_proxy.h"
  47
  48 GtkWidget * g_main_win;
  49
  50 GtkWidget * g_clear_load_button;
  51 GtkWidget * g_xrun_progress_bar;
  52 GtkWidget * g_buffer_size_combo;
  53
  54 GtkWidget * g_menu_item_new_studio;
  55 GtkWidget * g_menu_item_start_studio;
  56 GtkWidget * g_menu_item_stop_studio;
  57 GtkWidget * g_menu_item_save_studio;
  58 GtkWidget * g_menu_item_unload_studio;
  59 GtkWidget * g_menu_item_rename_studio;
  60 GtkWidget * g_menu_item_create_room;
  61 GtkWidget * g_menu_item_destroy_room;
  62 GtkWidget * g_menu_item_load_project;
  63 GtkWidget * g_menu_item_daemon_exit;
  64 GtkWidget * g_menu_item_jack_configure;
  65 GtkWidget * g_studio_status_label;
  66 GtkWidget * g_menu_item_view_toolbar;
  67 GtkWidget * g_toolbar;
  68 GtkWidget * g_menu_item_start_app;
  69
  70 GtkWidget * g_name_dialog;
  71 GtkWidget * g_app_dialog;
  72
  73 graph_view_handle g_jack_view = NULL;
  74 graph_view_handle g_studio_view = NULL;
  75
  76 static guint g_jack_poll_source_tag;
  77 static guint g_ladishd_poll_source_tag;
  78 static double g_jack_max_dsp_load = 0.0;
  79
  80 #define STUDIO_STATE_UNKNOWN    0
  81 #define STUDIO_STATE_UNLOADED   1
  82 #define STUDIO_STATE_STOPPED    2
  83 #define STUDIO_STATE_STARTED    3
  84 #define STUDIO_STATE_CRASHED    4
  85 #define STUDIO_STATE_NA         5
  86 #define STUDIO_STATE_SICK       6
  87
  88 static unsigned int g_studio_state = STUDIO_STATE_UNKNOWN;
  89
  90 #define JACK_STATE_NA         0
  91 #define JACK_STATE_STOPPED    1
  92 #define JACK_STATE_STARTED    2
  93
  94 static unsigned int g_jack_state = JACK_STATE_NA;
  95
  96 struct studio_list
  97 {
  98   int count;
  99   GtkWidget * menu_item;
 100   GtkWidget * menu;
 101   void (* item_activate_callback)(GtkWidget * item);
 102   bool add_sensitive;
 103 };
 104
 105 static struct studio_list g_load_studio_list;
 106 static struct studio_list g_delete_studio_list;
 107
 108 #if 0
 109 static void
 110 gtkmm_get_ink_pixel_size (Glib::RefPtr<Pango::Layout> layout,
 111              int& width,
 112              int& height)
 113 {
 114   Pango::Rectangle ink_rect = layout->get_ink_extents ();
 115
 116   width = (ink_rect.get_width() + PANGO_SCALE / 2) / PANGO_SCALE;
 117   height = (ink_rect.get_height() + PANGO_SCALE / 2) / PANGO_SCALE;
 118 }
 119
 120 static void
 121 gtkmm_set_width_for_given_text (Gtk::Widget &w, const gchar *text,
 122                gint hpadding/*, gint vpadding*/)
 123
 124 {
 125   int old_width, old_height;
 126   w.get_size_request(old_width, old_height);
 127
 128   int width, height;
 129   w.ensure_style ();
 130
 131   gtkmm_get_ink_pixel_size (w.create_pango_layout (text), width, height);
 132   w.set_size_request(width + hpadding, old_height);//height + vpadding);
 133 }
 134
 135 #endif
 136
 137 static void set_buffer_size_combo_width(void)
 138 {
 139   //gtkmm_set_width_for_given_text(*_buffer_size_combo, "4096 frames", 40);
 140 }
 141
 142 static void buffer_size_clear()
 143 {
 144   gtk_entry_set_text(GTK_ENTRY(get_glade_widget("comboboxentry")), "");
 145 }
 146
 147 static void buffer_size_set(uint32_t size)
 148 {
 149   gtk_combo_box_set_active(GTK_COMBO_BOX(g_buffer_size_combo), (int)log2f(size) - 5);
 150 }
 151
 152 static void buffer_size_change_request(void)
 153 {
 154   const int selected = gtk_combo_box_get_active(GTK_COMBO_BOX(g_buffer_size_combo));
 155
 156   if (selected < 0 || !jack_proxy_set_buffer_size(1 << (selected + 5)))
 157   {
 158     log_error("cannot set JACK buffer size");
 159     buffer_size_clear();
 160   }
 161 }
 162
 163 static void update_buffer_size(void)
 164 {
 165   uint32_t size;
 166
 167   if (jack_proxy_get_buffer_size(&size))
 168   {
 169     buffer_size_set(size);
 170   }
 171   else
 172   {
 173     buffer_size_clear();
 174   }
 175 }
 176
 177 static void update_load(void)
 178 {
 179   uint32_t xruns;
 180   double load;
 181   char tmp_buf[100];
 182
 183   if (!jack_proxy_get_xruns(&xruns) || !jack_proxy_get_dsp_load(&load))
 184   {
 185     gtk_progress_bar_set_text(GTK_PROGRESS_BAR(g_xrun_progress_bar), "error");
 186     gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(g_xrun_progress_bar), 0.0);
 187   }
 188
 189   snprintf(tmp_buf, sizeof(tmp_buf), "%" PRIu32 " Dropouts", xruns);
 190   gtk_progress_bar_set_text(GTK_PROGRESS_BAR(g_xrun_progress_bar), tmp_buf);
 191
 192   load /= 100.0;           // dbus returns it in percents, we use 0..1
 193
 194   if (load > g_jack_max_dsp_load)
 195   {
 196     g_jack_max_dsp_load = load;
 197     gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(g_xrun_progress_bar), load);
 198   }
 199 }
 200
 201 static void clear_load(void)
 202 {
 203   jack_proxy_reset_xruns();
 204   g_jack_max_dsp_load = 0.0;
 205   gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(g_xrun_progress_bar), 0.0);
 206 }
 207
 208 bool name_dialog(const char * title, const char * object, const char * old_name, char ** new_name)
 209 {
 210   guint result;
 211   bool ok;
 212   GtkEntry * entry = GTK_ENTRY(get_glade_widget("name_entry"));
 213
 214   gtk_widget_show(g_name_dialog);
 215
 216   gtk_label_set_text(GTK_LABEL(get_glade_widget("name_label")), object);
 217   gtk_entry_set_text(entry, old_name);
 218   gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
 219
 220   result = gtk_dialog_run(GTK_DIALOG(g_name_dialog));
 221   ok = result == 2;
 222   if (ok)
 223   {
 224     *new_name = strdup(gtk_entry_get_text(entry));
 225     if (*new_name == NULL)
 226     {
 227       log_error("strdup failed for new name (name_dialog)");
 228       ok = false;
 229     }
 230   }
 231
 232   gtk_widget_hide(g_name_dialog);
 233
 234   return ok;
 235 }
 236
 237 void error_message_box(const char * failed_operation)
 238 {
 239   GtkWidget * dialog;
 240   dialog = get_glade_widget("error_dialog");
 241   gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), "<b><big>Error</big></b>");
 242   gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dialog), "%s", failed_operation);
 243   gtk_widget_show(dialog);
 244   gtk_dialog_run(GTK_DIALOG(dialog));
 245   gtk_widget_hide(dialog);
 246 }
 247
 248 void run_custom_command_dialog(void)
 249 {
 250   guint result;
 251   GtkEntry * command_entry = GTK_ENTRY(get_glade_widget("app_command_entry"));
 252   GtkEntry * name_entry = GTK_ENTRY(get_glade_widget("app_name_entry"));
 253   GtkToggleButton * terminal_button = GTK_TOGGLE_BUTTON(get_glade_widget("app_terminal_check_button"));
 254   /* GtkToggleButton * level0_button = GTK_TOGGLE_BUTTON(get_glade_widget("app_level0")); */
 255   /* GtkToggleButton * level1_button = GTK_TOGGLE_BUTTON(get_glade_widget("app_level1")); */
 256   /* GtkToggleButton * level2_button = GTK_TOGGLE_BUTTON(get_glade_widget("app_level2")); */
 257   /* GtkToggleButton * level3_button = GTK_TOGGLE_BUTTON(get_glade_widget("app_level3")); */
 258
 259   gtk_entry_set_text(name_entry, "");
 260   gtk_entry_set_text(command_entry, "");
 261   gtk_toggle_button_set_active(terminal_button, FALSE);
 262
 263   gtk_widget_show(g_app_dialog);
 264
 265   result = gtk_dialog_run(GTK_DIALOG(g_app_dialog));
 266   if (result == 2)
 267   {
 268     log_info("'%s':'%s' %s", gtk_entry_get_text(name_entry), gtk_entry_get_text(command_entry), gtk_toggle_button_get_active(terminal_button) ? "terminal" : "shell");
 269     if (!app_run_custom(g_studio_view, gtk_entry_get_text(command_entry), gtk_entry_get_text(name_entry), gtk_toggle_button_get_active(terminal_button)))
 270     {
 271       error_message_box("Execution failed. I know you want to know more for the reson but currently you can only check the log file.");
 272     }
 273   }
 274
 275   gtk_widget_hide(g_app_dialog);
 276 }
 277
 278 static void arrange(void)
 279 {
 280   canvas_handle canvas;
 281
 282   log_info("arrange request");
 283
 284   canvas = get_current_canvas();
 285   if (canvas != NULL)
 286   {
 287     canvas_arrange(canvas);
 288   }
 289 }
 290
 291 static void daemon_exit(GtkWidget * item)
 292 {
 293   log_info("Daemon exit request");
 294
 295   if (!control_proxy_exit())
 296   {
 297     error_message_box("Daemon exit command failed, please inspect logs.");
 298   }
 299 }
 300
 301 static void jack_configure(GtkWidget * item)
 302 {
 303   GError * error_ptr;
 304   gchar * argv[] = {"ladiconf", NULL};
 305   GtkWidget * dialog;
 306
 307   log_info("JACK configure request");
 308
 309   error_ptr = NULL;
 310   if (!g_spawn_async(
 311         NULL,                   /* working directory */
 312         argv,
 313         NULL,                   /* envp */
 314         G_SPAWN_SEARCH_PATH,    /* flags */
 315         NULL,                   /* child_setup callback */
 316         NULL,                   /* user_data */
 317         NULL,
 318         &error_ptr))
 319   {
 320     dialog = get_glade_widget("error_dialog");
 321     gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), "<b><big>Error executing ladiconf.\nAre LADI Tools installed?</big></b>");
 322     gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dialog), "%s", error_ptr->message);
 323     gtk_widget_show(dialog);
 324     gtk_dialog_run(GTK_DIALOG(dialog));
 325     gtk_widget_hide(dialog);
 326     g_error_free(error_ptr);
 327   }
 328 }
 329
 330 static void on_load_studio(GtkWidget * item)
 331 {
 332   const char * studio_name;
 333
 334   studio_name = gtk_label_get_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(item))));
 335   log_info("Load studio \"%s\"", studio_name);
 336
 337   if (!control_proxy_load_studio(studio_name))
 338   {
 339     error_message_box("Studio load failed, please inspect logs.");
 340   }
 341 }
 342
 343 static void on_delete_studio(GtkWidget * item)
 344 {
 345   const char * studio_name;
 346   bool result;
 347
 348   studio_name = gtk_label_get_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(item))));
 349
 350   if (!ask_dialog(&result, "<b><big>Confirm studio delete</big></b>", "Studio \"%s\" will be deleted. Are you sure?", studio_name) || !result)
 351   {
 352     return;
 353   }
 354
 355   log_info("Delete studio \"%s\"", studio_name);
 356
 357   if (!control_proxy_delete_studio(studio_name))
 358   {
 359     error_message_box("Studio delete failed, please inspect logs.");
 360   }
 361 }
 362
 363 #define studio_list_ptr ((struct studio_list *)context)
 364
 365 static void remove_studio_list_menu_entry(GtkWidget * item, gpointer context)
 366 {
 367   GtkWidget * label;
 368
 369   label = gtk_bin_get_child(GTK_BIN(item));
 370
 371   //log_debug("removing studio menu item \"%s\"", gtk_menu_item_get_label(GTK_MENU_ITEM(item));
 372   // gtk_menu_item_get_label() requries gtk 2.16
 373   log_debug("removing studio menu item \"%s\"", gtk_label_get_text(GTK_LABEL(label)));
 374
 375   gtk_container_remove(GTK_CONTAINER(item), label); /* destroy the label and drop the item refcount by one */
 376   //log_info("refcount == %d", (unsigned int)G_OBJECT(item)->ref_count);
 377   gtk_container_remove(GTK_CONTAINER(studio_list_ptr->menu), item); /* drop the refcount of item by one and thus destroy it */
 378   studio_list_ptr->count--;
 379 }
 380
 381 static void add_studio_list_menu_entry(void * context, const char * studio_name)
 382 {
 383   GtkWidget * item;
 384
 385   item = gtk_menu_item_new_with_label(studio_name);
 386   //log_info("refcount == %d", (unsigned int)G_OBJECT(item)->ref_count); // refcount == 2 because of the label
 387   gtk_widget_set_sensitive(item, studio_list_ptr->add_sensitive);
 388   gtk_widget_show(item);
 389   gtk_menu_shell_append(GTK_MENU_SHELL(studio_list_ptr->menu), item);
 390   g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(studio_list_ptr->item_activate_callback), item);
 391   studio_list_ptr->count++;
 392 }
 393
 394 #undef studio_list_ptr
 395
 396 static void menu_studio_list_clear(struct studio_list * studio_list_ptr)
 397 {
 398   gtk_container_foreach(GTK_CONTAINER(studio_list_ptr->menu), remove_studio_list_menu_entry, studio_list_ptr);
 399   ASSERT(studio_list_ptr->count == 0);
 400   studio_list_ptr->count = 0;
 401 }
 402
 403 static void populate_studio_list_menu(GtkMenuItem * menu_item, struct studio_list * studio_list_ptr)
 404 {
 405   menu_studio_list_clear(studio_list_ptr);
 406   studio_list_ptr->add_sensitive = true;
 407   if (!control_proxy_get_studio_list(add_studio_list_menu_entry, studio_list_ptr))
 408   {
 409     menu_studio_list_clear(studio_list_ptr);
 410     studio_list_ptr->add_sensitive = false;
 411     add_studio_list_menu_entry(studio_list_ptr, "Error obtaining studio list");
 412   }
 413   else if (studio_list_ptr->count == 0)
 414   {
 415     studio_list_ptr->add_sensitive = false;
 416     add_studio_list_menu_entry(studio_list_ptr, "Empty studio list");
 417   }
 418 }
 419
 420 static void save_studio(void)
 421 {
 422   log_info("save studio request");
 423   if (!studio_proxy_save())
 424   {
 425     error_message_box("Studio save failed, please inspect logs.");
 426   }
 427 }
 428
 429 static void new_studio(void)
 430 {
 431   char * new_name;
 432
 433   log_info("new studio request");
 434
 435   if (name_dialog("New studio", "Studio name", "", &new_name))
 436   {
 437     if (!control_proxy_new_studio(new_name))
 438     {
 439       error_message_box("Creation of new studio failed, please inspect logs.");
 440     }
 441
 442     free(new_name);
 443   }
 444 }
 445
 446 static void start_app(void)
 447 {
 448   run_custom_command_dialog();
 449 }
 450
 451 static void start_studio(void)
 452 {
 453   log_info("start studio request");
 454   if (!studio_proxy_start())
 455   {
 456     error_message_box("Studio start failed, please inspect logs.");
 457   }
 458 }
 459
 460 static void stop_studio(void)
 461 {
 462   log_info("stop studio request");
 463   if (!studio_proxy_stop())
 464   {
 465     error_message_box("Studio stop failed, please inspect logs.");
 466   }
 467 }
 468
 469 static void unload_studio(void)
 470 {
 471   log_info("unload studio request");
 472   if (!studio_proxy_unload())
 473   {
 474     error_message_box("Studio unload failed, please inspect logs.");
 475   }
 476 }
 477
 478 static void rename_studio(void)
 479 {
 480   char * new_name;
 481
 482   if (name_dialog("Rename studio", "Studio name", get_view_name(g_studio_view), &new_name))
 483   {
 484     if (!studio_proxy_rename(new_name))
 485     {
 486       error_message_box("Studio rename failed, please inspect logs.");
 487     }
 488
 489     free(new_name);
 490   }
 491 }
 492
 493 static gboolean poll_jack(gpointer data)
 494 {
 495   update_load();
 496   update_buffer_size();
 497
 498   return TRUE;
 499 }
 500
 501 static gboolean poll_ladishd(gpointer data)
 502 {
 503   control_proxy_ping();
 504   return TRUE;
 505 }
 506
 507 bool studio_state_changed(char ** name_ptr_ptr)
 508 {
 509   const char * status;
 510   const char * name;
 511   char * buffer;
 512
 513   gtk_widget_set_sensitive(g_menu_item_start_studio, g_studio_state == STUDIO_STATE_STOPPED);
 514   gtk_widget_set_sensitive(g_menu_item_stop_studio, g_studio_state == STUDIO_STATE_STARTED);
 515   gtk_widget_set_sensitive(g_menu_item_save_studio, g_studio_state == STUDIO_STATE_STARTED);
 516   gtk_widget_set_sensitive(g_menu_item_unload_studio, g_studio_state != STUDIO_STATE_UNLOADED);
 517   gtk_widget_set_sensitive(g_menu_item_rename_studio, g_studio_state == STUDIO_STATE_STOPPED || g_studio_state == STUDIO_STATE_STARTED);
 518   gtk_widget_set_sensitive(g_menu_item_start_app, g_studio_state == STUDIO_STATE_STOPPED || g_studio_state == STUDIO_STATE_STARTED);
 519   //gtk_widget_set_sensitive(g_menu_item_create_room, g_studio_loaded);
 520   //gtk_widget_set_sensitive(g_menu_item_destroy_room, g_studio_loaded);
 521   //gtk_widget_set_sensitive(g_menu_item_load_project, g_studio_loaded);
 522
 523   switch (g_jack_state)
 524   {
 525   case JACK_STATE_NA:
 526     status = "JACK is sick";
 527     break;
 528   case JACK_STATE_STOPPED:
 529     status = "Stopped";
 530     break;
 531   case JACK_STATE_STARTED:
 532     status = "xruns";
 533     break;
 534   default:
 535     status = "???";
 536   }
 537
 538   buffer = NULL;
 539
 540   switch (g_studio_state)
 541   {
 542   case STUDIO_STATE_NA:
 543     name = "ladishd is down";
 544     break;
 545   case STUDIO_STATE_SICK:
 546     name = "ladishd is sick";
 547     break;
 548   case STUDIO_STATE_UNLOADED:
 549     name = "No studio loaded";
 550     break;
 551   case STUDIO_STATE_CRASHED:
 552     status = "Crashed";
 553     /* fall through */
 554   case STUDIO_STATE_STOPPED:
 555   case STUDIO_STATE_STARTED:
 556     if (!studio_proxy_get_name(&buffer))
 557     {
 558       log_error("failed to get studio name");
 559     }
 560     else
 561     {
 562       name = buffer;
 563       break;
 564     }
 565   default:
 566     name = "???";
 567   }
 568
 569   gtk_progress_bar_set_text(GTK_PROGRESS_BAR(g_xrun_progress_bar), status);
 570   gtk_label_set_text(GTK_LABEL(g_studio_status_label), name);
 571
 572   if (buffer == NULL)
 573   {
 574     return false;
 575   }
 576
 577   if (name_ptr_ptr != NULL)
 578   {
 579     *name_ptr_ptr = buffer;
 580   }
 581   else
 582   {
 583     free(buffer);
 584   }
 585
 586   return true;
 587 }
 588
 589 void control_proxy_on_daemon_appeared(void)
 590 {
 591   if (g_studio_state == STUDIO_STATE_NA || g_studio_state == STUDIO_STATE_SICK)
 592   {
 593     log_info("ladishd appeared");
 594     g_source_remove(g_ladishd_poll_source_tag);
 595   }
 596
 597   g_studio_state = STUDIO_STATE_UNLOADED;
 598   studio_state_changed(NULL);
 599 }
 600
 601 void control_proxy_on_daemon_disappeared(bool clean_exit)
 602 {
 603   log_info("ladishd disappeared");
 604
 605   if (!clean_exit)
 606   {
 607     error_message_box("ladish daemon crashed");
 608     g_studio_state = STUDIO_STATE_SICK;
 609   }
 610   else
 611   {
 612     g_studio_state = STUDIO_STATE_NA;
 613   }
 614
 615   studio_state_changed(NULL);
 616
 617   if (g_studio_view != NULL)
 618   {
 619     destroy_view(g_studio_view);
 620     g_studio_view = NULL;
 621   }
 622
 623   g_ladishd_poll_source_tag = g_timeout_add(500, poll_ladishd, NULL);
 624 }
 625
 626 void control_proxy_on_studio_appeared(void)
 627 {
 628   char * name;
 629
 630   g_studio_state = STUDIO_STATE_STOPPED;
 631   if (studio_state_changed(&name))
 632   {
 633     if (g_studio_view != NULL)
 634     {
 635       log_error("studio appear signal received but studio already exists");
 636     }
 637     else if (!create_view(name, SERVICE_NAME, STUDIO_OBJECT_PATH, true, true, false, &g_studio_view))
 638     {
 639       log_error("create_view() failed for studio");
 640     }
 641
 642     free(name);
 643   }
 644 }
 645
 646 void control_proxy_on_studio_disappeared(void)
 647 {
 648   g_studio_state = STUDIO_STATE_UNLOADED;
 649   studio_state_changed(NULL);
 650
 651   if (g_studio_view == NULL)
 652   {
 653     log_error("studio disappear signal received but studio does not exists");
 654     return;
 655   }
 656
 657   if (g_studio_view != NULL)
 658   {
 659     destroy_view(g_studio_view);
 660     g_studio_view = NULL;
 661   }
 662 }
 663
 664 static void on_studio_renamed(const char * new_studio_name)
 665 {
 666   if (g_studio_view != NULL)
 667   {
 668     set_view_name(g_studio_view, new_studio_name);
 669     gtk_label_set_text(GTK_LABEL(g_studio_status_label), new_studio_name);
 670   }
 671 }
 672
 673 void on_studio_started(void)
 674 {
 675   g_studio_state = STUDIO_STATE_STARTED;
 676   studio_state_changed(NULL);
 677 }
 678
 679 void on_studio_stopped(void)
 680 {
 681   g_studio_state = STUDIO_STATE_STOPPED;
 682   studio_state_changed(NULL);
 683 }
 684
 685 void on_studio_crashed(void)
 686 {
 687   g_studio_state = STUDIO_STATE_CRASHED;
 688   studio_state_changed(NULL);
 689   error_message_box("JACK crashed or stopped unexpectedly. Save your work, then unload and reload the studio.");
 690 }
 691
 692 void jack_started(void)
 693 {
 694   log_info("JACK started");
 695
 696   g_jack_state = JACK_STATE_STARTED;
 697   studio_state_changed(NULL);
 698
 699   gtk_widget_set_sensitive(g_buffer_size_combo, true);
 700   gtk_widget_set_sensitive(g_clear_load_button, true);
 701
 702   g_jack_poll_source_tag = g_timeout_add(100, poll_jack, NULL);
 703 }
 704
 705 void jack_stopped(void)
 706 {
 707   if (g_jack_state == JACK_STATE_STARTED)
 708   {
 709     log_info("JACK stopped");
 710
 711     g_source_remove(g_jack_poll_source_tag);
 712   }
 713
 714   g_jack_state = JACK_STATE_STOPPED;
 715   studio_state_changed(NULL);
 716
 717   gtk_widget_set_sensitive(g_buffer_size_combo, false);
 718   buffer_size_clear();
 719   gtk_widget_set_sensitive(g_clear_load_button, false);
 720   gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(g_xrun_progress_bar), 0.0);
 721 }
 722
 723 void jack_appeared(void)
 724 {
 725   log_info("JACK appeared");
 726
 727   g_jack_state = JACK_STATE_STOPPED;
 728   studio_state_changed(NULL);
 729
 730 #if defined(SHOW_RAW_JACK)
 731   if (!create_view("Raw JACK", JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, false, false, true, &g_jack_view))
 732   {
 733     log_error("create_view() failed for jack");
 734     return;
 735   }
 736 #endif
 737 }
 738
 739 void jack_disappeared(void)
 740 {
 741   log_info("JACK disappeared");
 742
 743   jack_stopped();
 744
 745   g_jack_state = JACK_STATE_NA;
 746   studio_state_changed(NULL);
 747
 748 #if defined(SHOW_RAW_JACK)
 749   if (g_jack_view != NULL)
 750   {
 751     destroy_view(g_jack_view);
 752     g_jack_view = NULL;
 753   }
 754 #endif
 755 }
 756
 757 void
 758 set_main_window_title(
 759   graph_view_handle view)
 760 {
 761   char * title;
 762
 763   if (view != NULL)
 764   {
 765     title = catdup(get_view_name(view), " - LADI Session Handler");
 766     gtk_window_set_title(GTK_WINDOW(g_main_win), title);
 767     free(title);
 768   }
 769   else
 770   {
 771     gtk_window_set_title(GTK_WINDOW(g_main_win), "LADI Session Handler");
 772   }
 773 }
 774
 775 static
 776 void
 777 init_studio_list(
 778   struct studio_list * studio_list_ptr,
 779   const char * menu_item,
 780   const char * menu,
 781   void (* item_activate_callback)(GtkWidget * item))
 782 {
 783   studio_list_ptr->count = 0;
 784   studio_list_ptr->menu_item = get_glade_widget(menu_item);
 785   studio_list_ptr->menu = get_glade_widget(menu);
 786   studio_list_ptr->item_activate_callback = item_activate_callback;
 787   gtk_menu_item_set_submenu(GTK_MENU_ITEM(studio_list_ptr->menu_item), studio_list_ptr->menu);
 788   g_signal_connect(G_OBJECT(studio_list_ptr->menu_item), "activate", G_CALLBACK(populate_studio_list_menu), studio_list_ptr);
 789 }
 790
 791 static void toggle_toolbar(void)
 792 {
 793         if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(g_menu_item_view_toolbar)))
 794   {
 795                 gtk_widget_show(g_toolbar);
 796   }
 797         else
 798   {
 799                 gtk_widget_hide(g_toolbar);
 800   }
 801 }
 802
 803 static void show_about(void)
 804 {
 805   GtkWidget * dialog;
 806   dialog = get_glade_widget("about_win");
 807   gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), PACKAGE_VERSION);
 808   gtk_widget_show(dialog);
 809   gtk_dialog_run(GTK_DIALOG(dialog));
 810   gtk_widget_hide(dialog);
 811 }
 812
 813 static void dbus_init(void)
 814 {
 815   dbus_error_init(&g_dbus_error);
 816
 817   // Connect to the bus
 818   g_dbus_connection = dbus_bus_get(DBUS_BUS_SESSION, &g_dbus_error);
 819   if (dbus_error_is_set(&g_dbus_error))
 820   {
 821     //error_msg("dbus_bus_get() failed");
 822     //error_msg(g_dbus_error.message);
 823     dbus_error_free(&g_dbus_error);
 824   }
 825
 826   dbus_connection_setup_with_g_main(g_dbus_connection, NULL);
 827 }
 828
 829 void dbus_uninit(void)
 830 {
 831   if (g_dbus_connection)
 832   {
 833     dbus_connection_flush(g_dbus_connection);
 834   }
 835
 836   if (dbus_error_is_set(&g_dbus_error))
 837   {
 838     dbus_error_free(&g_dbus_error);
 839   }
 840 }
 841
 842 int main(int argc, char** argv)
 843 {
 844   gtk_init(&argc, &argv);
 845
 846   if (!canvas_init())
 847   {
 848     log_error("Canvas initialization failed.");
 849     return 1;
 850   }
 851
 852   if (!init_glade())
 853   {
 854     return 1;
 855   }
 856
 857   g_main_win = get_glade_widget("main_win");
 858   g_clear_load_button = get_glade_widget("clear_load_button");
 859   g_xrun_progress_bar = get_glade_widget("xrun_progress_bar");
 860   g_buffer_size_combo = get_glade_widget("buffer_size_combo");
 861   g_menu_item_new_studio = get_glade_widget("menu_item_new_studio");
 862   g_menu_item_start_app = get_glade_widget("menu_item_start_app");
 863   g_menu_item_start_studio = get_glade_widget("menu_item_start_studio");
 864   g_menu_item_stop_studio = get_glade_widget("menu_item_stop_studio");
 865   g_menu_item_save_studio = get_glade_widget("menu_item_save_studio");
 866   g_menu_item_unload_studio = get_glade_widget("menu_item_unload_studio");
 867   g_menu_item_rename_studio = get_glade_widget("menu_item_rename_studio");
 868   g_menu_item_create_room = get_glade_widget("menu_item_create_room");
 869   g_menu_item_destroy_room = get_glade_widget("menu_item_destroy_room");
 870   g_menu_item_load_project = get_glade_widget("menu_item_load_project");
 871   g_menu_item_daemon_exit = get_glade_widget("menu_item_daemon_exit");
 872   g_menu_item_jack_configure = get_glade_widget("menu_item_jack_configure");
 873   g_studio_status_label = get_glade_widget("studio_status_label");
 874   g_menu_item_view_toolbar = get_glade_widget("menu_item_view_toolbar");
 875   g_toolbar = get_glade_widget("toolbar");
 876
 877   g_name_dialog = get_glade_widget("name_dialog");
 878   g_app_dialog = get_glade_widget("app_dialog");
 879
 880   init_studio_list(&g_load_studio_list, "menu_item_load_studio", "load_studio_menu", on_load_studio);
 881   init_studio_list(&g_delete_studio_list, "menu_item_delete_studio", "delete_studio_menu", on_delete_studio);
 882
 883   world_tree_init();
 884   view_init();
 885
 886   dbus_init();
 887
 888   if (!jack_proxy_init(jack_started, jack_stopped, jack_appeared, jack_disappeared))
 889   {
 890     return 1;
 891   }
 892
 893   if (!control_proxy_init())
 894   {
 895     return 1;
 896   }
 897
 898   if (!studio_proxy_init())
 899   {
 900     return 1;
 901   }
 902
 903   studio_proxy_set_startstop_callbacks(on_studio_started, on_studio_stopped, on_studio_crashed);
 904
 905   studio_proxy_set_renamed_callback(on_studio_renamed);
 906
 907   set_buffer_size_combo_width();
 908
 909   g_signal_connect(G_OBJECT(g_main_win), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 910   g_signal_connect(G_OBJECT(get_glade_widget("menu_item_quit")), "activate", G_CALLBACK(gtk_main_quit), NULL);
 911   g_signal_connect(G_OBJECT(g_buffer_size_combo), "changed", G_CALLBACK(buffer_size_change_request), NULL);
 912   g_signal_connect(G_OBJECT(g_clear_load_button), "clicked", G_CALLBACK(clear_load), NULL);
 913   g_signal_connect(G_OBJECT(get_glade_widget("menu_item_view_arrange")), "activate", G_CALLBACK(arrange), NULL);
 914   g_signal_connect(G_OBJECT(g_menu_item_view_toolbar), "activate", G_CALLBACK(toggle_toolbar), NULL);
 915   g_signal_connect(G_OBJECT(g_menu_item_new_studio), "activate", G_CALLBACK(new_studio), NULL);
 916   g_signal_connect(G_OBJECT(g_menu_item_start_studio), "activate", G_CALLBACK(start_studio), NULL);
 917   g_signal_connect(G_OBJECT(g_menu_item_stop_studio), "activate", G_CALLBACK(stop_studio), NULL);
 918   g_signal_connect(G_OBJECT(g_menu_item_unload_studio), "activate", G_CALLBACK(unload_studio), NULL);
 919   g_signal_connect(G_OBJECT(g_menu_item_save_studio), "activate", G_CALLBACK(save_studio), NULL);
 920   g_signal_connect(G_OBJECT(g_menu_item_rename_studio), "activate", G_CALLBACK(rename_studio), NULL);
 921   g_signal_connect(G_OBJECT(g_menu_item_daemon_exit), "activate", G_CALLBACK(daemon_exit), NULL);
 922   g_signal_connect(G_OBJECT(g_menu_item_jack_configure), "activate", G_CALLBACK(jack_configure), NULL);
 923   g_signal_connect(G_OBJECT(get_glade_widget("menu_item_help_about")), "activate", G_CALLBACK(show_about), NULL);
 924   g_signal_connect(G_OBJECT(g_menu_item_start_app), "activate", G_CALLBACK(start_app), NULL);
 925
 926   gtk_widget_show(g_main_win);
 927
 928   //_about_win->set_transient_for(*_main_win);
 929
 930   gtk_main();
 931
 932   studio_proxy_uninit();
 933   control_proxy_uninit();
 934   dbus_uninit();
 935   uninit_glade();
 936
 937   return 0;
 938 }