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