gui/graph_view.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009,2010,2011,2012 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of the graph view object
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "common.h"
  28 #include "graph_view.h"
  29 #include "gtk_builder.h"
  30 #include "world_tree.h"
  31 #include "menu.h"
  32 #include "../proxies/room_proxy.h"
  33 #include "../common/catdup.h"
  34
  35 struct graph_view
  36 {
  37   struct list_head siblings;
  38   char * view_name;
  39   char * project_name;
  40   char * full_name;
  41   graph_canvas_handle graph_canvas;
  42   graph_proxy_handle graph;
  43   GtkWidget * canvas_widget;
  44   ladish_app_supervisor_proxy_handle app_supervisor;
  45   ladish_room_proxy_handle room;
  46 };
  47
  48 struct list_head g_views;
  49
  50 GtkScrolledWindow * g_main_scrolledwin;
  51 static struct graph_view * g_current_view;
  52 GtkWidget * g_view_label;
  53
  54 const char * g_view_label_text = "";
  55
  56 void view_init(void)
  57 {
  58   g_view_label_text = _(
  59   "If you've started ladish for the first time, you should:\n\n"
  60   " 1. Create a new studio (in the menu, Studio -> New Studio)\n"
  61   " 2. Configure JACK (in the menu, Tools -> Configure JACK)\n"
  62   " 3. Start the studio (in the menu, Studio -> Start Studio)\n"
  63   " 4. Start apps (in the menu, Application -> Run)\n"
  64   " 5. Connect their ports by click & drag on canvas\n"
  65   " 6. Save the studio (in the menu, Studio -> Save Studio)\n");
  66
  67   g_main_scrolledwin = GTK_SCROLLED_WINDOW(get_gtk_builder_widget("main_scrolledwin"));
  68   INIT_LIST_HEAD(&g_views);
  69
  70   g_view_label = gtk_label_new(g_view_label_text);
  71   g_object_ref(g_view_label);
  72   gtk_widget_show(g_view_label);
  73
  74   g_current_view = NULL;
  75   gtk_scrolled_window_add_with_viewport(g_main_scrolledwin, g_view_label);
  76 }
  77
  78 void announce_view_name_change(struct graph_view * view_ptr)
  79 {
  80   world_tree_name_changed((graph_view_handle)view_ptr);
  81
  82   if (g_current_view == view_ptr)
  83   {
  84     set_main_window_title((graph_view_handle)view_ptr);
  85   }
  86
  87   menu_view_changed();
  88 }
  89
  90 static void detach_canvas(struct graph_view * view_ptr)
  91 {
  92   GtkWidget * child;
  93
  94   child = gtk_bin_get_child(GTK_BIN(g_main_scrolledwin));
  95   if (child == view_ptr->canvas_widget)
  96   {
  97     gtk_container_remove(GTK_CONTAINER(g_main_scrolledwin), view_ptr->canvas_widget);
  98     g_current_view = NULL;
  99     gtk_widget_show(g_view_label);
 100     gtk_scrolled_window_add_with_viewport(g_main_scrolledwin, g_view_label);
 101   }
 102 }
 103
 104 #define view_ptr ((struct graph_view *)context)
 105
 106 static void app_added(void * context, uint64_t id, const char * name, bool running, bool terminal, const char * level)
 107 {
 108   //log_info("app added. id=%"PRIu64", name='%s', %srunning, %s, level '%s'", id, name, running ? "" : "not ", terminal ? "terminal" : "shell", level);
 109   world_tree_add_app(context, id, name, running, terminal, level);
 110 }
 111
 112 static void app_state_changed(void * context, uint64_t id, const char * name, bool running, bool terminal, const char * level)
 113 {
 114   //log_info("app state changed. id=%"PRIu64", name='%s', %srunning, %s, level '%s'", id, name, running ? "" : "not ", terminal ? "terminal" : "shell", level);
 115   world_tree_app_state_changed(context, id, name, running, terminal, level);
 116 }
 117
 118 static void app_removed(void * context, uint64_t id)
 119 {
 120   //log_info("app removed. id=%"PRIu64, id);
 121   world_tree_remove_app(context, id);
 122 }
 123
 124 static
 125 void
 126 project_properties_changed(
 127   void * context,
 128   const char * project_dir,
 129   const char * project_name,
 130   const char * UNUSED(project_description),
 131   const char * UNUSED(project_notes))
 132 {
 133   bool empty;
 134   char * project_name_buffer;
 135   char * full_name_buffer;
 136
 137   log_info("Room '%s' project properties changed. name='%s', dir='%s'", view_ptr->view_name, project_name, project_dir);
 138
 139   empty = strlen(project_name) == 0;
 140
 141   if (!empty)
 142   {
 143     project_name_buffer = strdup(project_name);
 144     if (project_name_buffer == NULL)
 145     {
 146       return;
 147     }
 148
 149     full_name_buffer = catdup4(view_ptr->view_name, " (", project_name, ")");
 150     if (full_name_buffer == NULL)
 151     {
 152       free(project_name_buffer);
 153       return;
 154     }
 155
 156     if (view_ptr->full_name != NULL && view_ptr->full_name != view_ptr->view_name)
 157     {
 158       free(view_ptr->full_name);
 159     }
 160
 161     if (view_ptr->project_name != NULL)
 162     {
 163       free(view_ptr->project_name);
 164     }
 165
 166     view_ptr->full_name = full_name_buffer;
 167     view_ptr->project_name = project_name_buffer;
 168   }
 169   else
 170   {
 171     if (view_ptr->full_name != NULL && view_ptr->full_name != view_ptr->view_name)
 172     {
 173       free(view_ptr->full_name);
 174     }
 175
 176     if (view_ptr->project_name != NULL)
 177     {
 178       free(view_ptr->project_name);
 179     }
 180
 181     view_ptr->full_name = view_ptr->view_name;
 182     view_ptr->project_name = NULL;
 183   }
 184
 185   announce_view_name_change(view_ptr);
 186 }
 187
 188 #undef view_ptr
 189
 190 static void fill_canvas_menu(GtkMenu * menu)
 191 {
 192   fill_view_popup_menu(menu, (graph_view_handle)g_current_view);
 193 }
 194
 195 bool
 196 create_view(
 197   const char * name,
 198   const char * service,
 199   const char * object,
 200   bool graph_dict_supported,
 201   bool graph_manager_supported,
 202   bool app_supervisor_supported,
 203   bool force_activate,
 204   graph_view_handle * handle_ptr)
 205 {
 206   struct graph_view * view_ptr;
 207
 208   view_ptr = malloc(sizeof(struct graph_view));
 209   if (view_ptr == NULL)
 210   {
 211     log_error("malloc() failed for struct graph_view");
 212     goto fail;
 213   }
 214
 215   view_ptr->view_name = strdup(name);
 216   if (view_ptr->view_name == NULL)
 217   {
 218     log_error("strdup() failed for \"%s\"", name);
 219     goto free_view;
 220   }
 221
 222   view_ptr->app_supervisor = NULL;
 223   view_ptr->room = NULL;
 224   view_ptr->full_name = view_ptr->view_name;
 225   view_ptr->project_name = NULL;
 226
 227   if (!graph_proxy_create(service, object, graph_dict_supported, graph_manager_supported, &view_ptr->graph))
 228   {
 229     goto free_name;
 230   }
 231
 232   if (!graph_canvas_create(1600 * 2, 1200 * 2, fill_canvas_menu, &view_ptr->graph_canvas))
 233   {
 234     goto destroy_graph;
 235   }
 236
 237   if (!graph_canvas_attach(view_ptr->graph_canvas, view_ptr->graph))
 238   {
 239     goto destroy_graph_canvas;
 240   }
 241
 242   view_ptr->canvas_widget = canvas_get_widget(graph_canvas_get_canvas(view_ptr->graph_canvas));
 243
 244   list_add_tail(&view_ptr->siblings, &g_views);
 245
 246   gtk_widget_show(view_ptr->canvas_widget);
 247
 248   world_tree_add((graph_view_handle)view_ptr, force_activate);
 249
 250   if (app_supervisor_supported)
 251   {
 252     if (!ladish_app_supervisor_proxy_create(service, object, view_ptr, app_added, app_state_changed, app_removed, &view_ptr->app_supervisor))
 253     {
 254       goto remove_from_world_tree;
 255     }
 256   }
 257
 258   if (strcmp(object, STUDIO_OBJECT_PATH) != 0 && strcmp(object, JACKDBUS_OBJECT_PATH) != 0) /* TODO: this is a quite lame way to detect room views */
 259   {
 260     if (!ladish_room_proxy_create(service, object, view_ptr, project_properties_changed, &view_ptr->room))
 261     {
 262       goto free_app_supervisor;
 263     }
 264   }
 265
 266   if (!graph_proxy_activate(view_ptr->graph))
 267   {
 268     goto free_room_proxy;
 269   }
 270
 271   menu_view_changed();
 272
 273   *handle_ptr = (graph_view_handle)view_ptr;
 274
 275   return true;
 276
 277 free_room_proxy:
 278   if (view_ptr->room != NULL)
 279   {
 280     ladish_room_proxy_destroy(view_ptr->room);
 281   }
 282 free_app_supervisor:
 283   if (view_ptr->app_supervisor != NULL)
 284   {
 285     ladish_app_supervisor_proxy_destroy(view_ptr->app_supervisor);
 286   }
 287 remove_from_world_tree:
 288   list_del(&view_ptr->siblings);
 289   if (!list_empty(&g_views))
 290   {
 291     world_tree_activate((graph_view_handle)list_entry(g_views.next, struct graph_view, siblings));
 292   }
 293   else
 294   {
 295     set_main_window_title(NULL);
 296   }
 297
 298   detach_canvas(view_ptr);
 299
 300   world_tree_remove((graph_view_handle)view_ptr);
 301 destroy_graph_canvas:
 302   graph_canvas_destroy(view_ptr->graph_canvas);
 303 destroy_graph:
 304   graph_proxy_destroy(view_ptr->graph);
 305 free_name:
 306   if (view_ptr->full_name != NULL && view_ptr->full_name != view_ptr->view_name)
 307   {
 308     free(view_ptr->full_name);
 309   }
 310   if (view_ptr->project_name != NULL)
 311   {
 312     free(view_ptr->project_name);
 313   }
 314   free(view_ptr->view_name);
 315 free_view:
 316   free(view_ptr);
 317 fail:
 318   return false;
 319 }
 320
 321 static void attach_canvas(struct graph_view * view_ptr)
 322 {
 323   GtkWidget * child;
 324
 325   child = gtk_bin_get_child(GTK_BIN(g_main_scrolledwin));
 326
 327   if (child == view_ptr->canvas_widget)
 328   {
 329     return;
 330   }
 331
 332   if (child != NULL)
 333   {
 334     gtk_container_remove(GTK_CONTAINER(g_main_scrolledwin), child);
 335   }
 336
 337   g_current_view = view_ptr;
 338   gtk_container_add(GTK_CONTAINER(g_main_scrolledwin), view_ptr->canvas_widget);
 339
 340   //_main_scrolledwin->property_hadjustment().get_value()->set_step_increment(10);
 341   //_main_scrolledwin->property_vadjustment().get_value()->set_step_increment(10);
 342 }
 343
 344 #define view_ptr ((struct graph_view *)view)
 345
 346 void destroy_view(graph_view_handle view)
 347 {
 348   list_del(&view_ptr->siblings);
 349   if (!list_empty(&g_views))
 350   {
 351     world_tree_activate((graph_view_handle)list_entry(g_views.next, struct graph_view, siblings));
 352   }
 353   else
 354   {
 355     set_main_window_title(NULL);
 356   }
 357
 358   detach_canvas(view_ptr);
 359
 360   world_tree_remove(view);
 361
 362   graph_canvas_detach(view_ptr->graph_canvas);
 363   graph_canvas_destroy(view_ptr->graph_canvas);
 364   graph_proxy_destroy(view_ptr->graph);
 365
 366   if (view_ptr->app_supervisor != NULL)
 367   {
 368     ladish_app_supervisor_proxy_destroy(view_ptr->app_supervisor);
 369   }
 370
 371   if (view_ptr->room != NULL)
 372   {
 373     ladish_room_proxy_destroy(view_ptr->room);
 374   }
 375
 376   if (view_ptr->full_name != NULL && view_ptr->full_name != view_ptr->view_name)
 377   {
 378     free(view_ptr->full_name);
 379   }
 380   if (view_ptr->project_name != NULL)
 381   {
 382     free(view_ptr->project_name);
 383   }
 384   free(view_ptr->view_name);
 385
 386   free(view_ptr);
 387 }
 388
 389 void activate_view(graph_view_handle view)
 390 {
 391   attach_canvas(view_ptr);
 392   set_main_window_title(view);
 393   menu_view_changed();
 394 }
 395
 396 const char * get_view_name(graph_view_handle view)
 397 {
 398   return view_ptr->full_name;
 399 }
 400
 401 const char * get_view_opath(graph_view_handle view)
 402 {
 403   return graph_proxy_get_object(view_ptr->graph);
 404 }
 405
 406 bool set_view_name(graph_view_handle view, const char * name)
 407 {
 408   char * view_name_buffer;
 409   char * full_name_buffer;
 410
 411   view_name_buffer = strdup(name);
 412   if (view_name_buffer == NULL)
 413   {
 414     log_error("strdup() failed for \"%s\"", name);
 415     return false;
 416   }
 417
 418   if (view_ptr->project_name != NULL)
 419   {
 420     full_name_buffer = catdup4(view_name_buffer, " (", view_ptr->project_name, ")");
 421     if (full_name_buffer == NULL)
 422     {
 423       free(view_name_buffer);
 424       return false;
 425     }
 426   }
 427   else
 428   {
 429     full_name_buffer = view_name_buffer;
 430   }
 431
 432   if (view_ptr->full_name != NULL && view_ptr->full_name != view_ptr->view_name)
 433   {
 434     free(view_ptr->full_name);
 435   }
 436
 437   free(view_ptr->view_name);
 438
 439   view_ptr->view_name = view_name_buffer;
 440   view_ptr->full_name = full_name_buffer;
 441
 442   announce_view_name_change(view_ptr);
 443
 444   return true;
 445 }
 446
 447 canvas_handle get_current_canvas(void)
 448 {
 449   if (g_current_view == NULL)
 450   {
 451     return NULL;
 452   }
 453
 454   return graph_canvas_get_canvas(g_current_view->graph_canvas);
 455 }
 456
 457 const char * get_current_view_room_name(void)
 458 {
 459   if (g_current_view == NULL || !is_room_view((graph_view_handle)g_current_view))
 460   {
 461     return NULL;
 462   }
 463
 464   return g_current_view->view_name;
 465 }
 466
 467 graph_view_handle get_current_view(void)
 468 {
 469   return (graph_view_handle)g_current_view;
 470 }
 471
 472 bool is_room_view(graph_view_handle view)
 473 {
 474   return view_ptr->room != NULL;
 475 }
 476
 477 bool app_run_custom(graph_view_handle view, const char * command, const char * name, bool run_in_terminal, const char * level)
 478 {
 479   return ladish_app_supervisor_proxy_run_custom(view_ptr->app_supervisor, command, name, run_in_terminal, level);
 480 }
 481
 482 ladish_app_supervisor_proxy_handle graph_view_get_app_supervisor(graph_view_handle view)
 483 {
 484   return view_ptr->app_supervisor;
 485 }
 486
 487 ladish_room_proxy_handle graph_view_get_room(graph_view_handle view)
 488 {
 489   return view_ptr->room;
 490 }
 491
 492 bool room_has_project(graph_view_handle view)
 493 {
 494   return view_ptr->project_name != NULL;
 495 }