gui/world_tree.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2008, 2009, 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of the project_list class
   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 "world_tree.h"
  29 #include "gtk_builder.h"
  30 #include "../common/catdup.h"
  31 #include "menu.h"
  32
  33 #include <libintl.h>
  34
  35 enum entry_type
  36 {
  37   entry_type_view,
  38   entry_type_app
  39 };
  40
  41 enum
  42 {
  43   COL_TYPE = 0,
  44   COL_NAME,
  45   COL_VIEW,
  46   COL_ID,
  47   COL_RUNNING,
  48   COL_TERMINAL,
  49   COL_LEVEL,
  50   NUM_COLS
  51 };
  52
  53 GtkWidget * g_world_tree_widget;
  54 GtkTreeStore * g_treestore;
  55
  56 bool get_app_view(GtkTreeIter * app_iter_ptr, graph_view_handle * view_ptr)
  57 {
  58   GtkTreeIter view_iter;
  59   gint type;
  60
  61   if (!gtk_tree_model_iter_parent(GTK_TREE_MODEL(g_treestore), &view_iter, app_iter_ptr))
  62   {
  63     ASSERT_NO_PASS;
  64     return false;
  65   }
  66
  67   gtk_tree_model_get(
  68     GTK_TREE_MODEL(g_treestore),
  69     &view_iter,
  70     COL_TYPE, &type,
  71     COL_VIEW, view_ptr,
  72     -1);
  73   if (type != entry_type_view)
  74   {
  75     ASSERT_NO_PASS;
  76     return false;
  77   }
  78
  79   return true;
  80 }
  81
  82 static
  83 gboolean
  84 on_select(
  85   GtkTreeSelection * selection,
  86   GtkTreeModel * model,
  87   GtkTreePath * path,
  88   gboolean path_currently_selected,
  89   gpointer data)
  90 {
  91   GtkTreeIter iter;
  92   graph_view_handle view;
  93   gint type;
  94   uint64_t id;
  95
  96   if (gtk_tree_model_get_iter(model, &iter, path))
  97   {
  98     gtk_tree_model_get(model, &iter, COL_TYPE, &type, COL_VIEW, &view, COL_ID, &id, -1);
  99     switch (type)
 100     {
 101     case entry_type_app:
 102       if (!get_app_view(&iter, &view))
 103       {
 104         ASSERT_NO_PASS;
 105         break;
 106       }
 107     case entry_type_view:
 108       //log_info("%s is going to be %s.", get_view_name(view), path_currently_selected ? "unselected" : "selected");
 109       if (!path_currently_selected)
 110       {
 111         activate_view(view);
 112       }
 113       break;
 114     }
 115   }
 116
 117   return TRUE;
 118 }
 119
 120 bool get_selected_app_id(graph_view_handle * view_ptr, uint64_t * id_ptr)
 121 {
 122   GtkTreeSelection * selection;
 123   GtkTreeIter app_iter;
 124   gint type;
 125   uint64_t id;
 126   graph_view_handle view;
 127
 128   selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_world_tree_widget));
 129   if (!gtk_tree_selection_get_selected(selection, NULL, &app_iter))
 130   {
 131     return false;
 132   }
 133
 134   gtk_tree_model_get(
 135     GTK_TREE_MODEL(g_treestore),
 136     &app_iter,
 137     COL_TYPE, &type,
 138     COL_ID, &id,
 139     -1);
 140   if (type != entry_type_app)
 141   {
 142     return false;
 143   }
 144
 145   if (!get_app_view(&app_iter, &view))
 146   {
 147     ASSERT_NO_PASS;
 148     return false;
 149   }
 150
 151   *view_ptr = view;
 152   *id_ptr = id;
 153
 154   return true;
 155 }
 156
 157 void on_popup_menu_action_app_start(GtkWidget * menuitem, gpointer userdata)
 158 {
 159   uint64_t id;
 160   ladish_app_supervisor_proxy_handle proxy;
 161   graph_view_handle view;
 162
 163   if (!get_selected_app_id(&view, &id))
 164   {
 165     return;
 166   }
 167
 168   log_info("start app %"PRIu64, id);
 169
 170   proxy = graph_view_get_app_supervisor(view);
 171   ladish_app_supervisor_proxy_start_app(proxy, id);
 172 }
 173
 174 void on_popup_menu_action_app_stop(GtkWidget * menuitem, gpointer userdata)
 175 {
 176   uint64_t id;
 177   ladish_app_supervisor_proxy_handle proxy;
 178   graph_view_handle view;
 179
 180   if (!get_selected_app_id(&view, &id))
 181   {
 182     return;
 183   }
 184
 185   log_info("stop app %"PRIu64, id);
 186
 187   proxy = graph_view_get_app_supervisor(view);
 188   ladish_app_supervisor_proxy_stop_app(proxy, id);
 189 }
 190
 191 void on_popup_menu_action_app_kill(GtkWidget * menuitem, gpointer userdata)
 192 {
 193   uint64_t id;
 194   ladish_app_supervisor_proxy_handle proxy;
 195   graph_view_handle view;
 196
 197   if (!get_selected_app_id(&view, &id))
 198   {
 199     return;
 200   }
 201
 202   log_info("kill app %"PRIu64, id);
 203
 204   proxy = graph_view_get_app_supervisor(view);
 205   ladish_app_supervisor_proxy_kill_app(proxy, id);
 206 }
 207
 208 void on_popup_menu_action_app_remove(GtkWidget * menuitem, gpointer userdata)
 209 {
 210   uint64_t id;
 211   ladish_app_supervisor_proxy_handle proxy;
 212   graph_view_handle view;
 213
 214   if (!get_selected_app_id(&view, &id))
 215   {
 216     return;
 217   }
 218
 219   log_info("remove app %"PRIu64, id);
 220
 221   proxy = graph_view_get_app_supervisor(view);
 222   ladish_app_supervisor_proxy_remove_app(proxy, id);
 223 }
 224
 225 void on_popup_menu_action_app_properties(GtkWidget * menuitem, gpointer userdata)
 226 {
 227   uint64_t id;
 228   ladish_app_supervisor_proxy_handle proxy;
 229   graph_view_handle view;
 230   char * name;
 231   char * command;
 232   bool running;
 233   bool terminal;
 234   uint8_t level;
 235   guint result;
 236   GtkEntry * command_entry = GTK_ENTRY(get_gtk_builder_widget("app_command_entry"));
 237   GtkEntry * name_entry = GTK_ENTRY(get_gtk_builder_widget("app_name_entry"));
 238   GtkToggleButton * terminal_button = GTK_TOGGLE_BUTTON(get_gtk_builder_widget("app_terminal_check_button"));
 239   GtkToggleButton * level0_button = GTK_TOGGLE_BUTTON(get_gtk_builder_widget("app_level0"));
 240   GtkToggleButton * level1_button = GTK_TOGGLE_BUTTON(get_gtk_builder_widget("app_level1"));
 241   GtkToggleButton * level2_button = GTK_TOGGLE_BUTTON(get_gtk_builder_widget("app_level2"));
 242   GtkToggleButton * level3_button = GTK_TOGGLE_BUTTON(get_gtk_builder_widget("app_level3"));
 243
 244   if (!get_selected_app_id(&view, &id))
 245   {
 246     return;
 247   }
 248
 249   log_info("app %"PRIu64" properties", id);
 250
 251   proxy = graph_view_get_app_supervisor(view);
 252
 253   if (!ladish_app_supervisor_get_app_properties(proxy, id, &name, &command, &running, &terminal, &level))
 254   {
 255     error_message_box(_("Cannot get app properties"));
 256     return;
 257   }
 258
 259   log_info("'%s':'%s' %s level %"PRIu8, name, command, terminal ? "terminal" : "shell", level);
 260
 261   gtk_entry_set_text(name_entry, name);
 262   gtk_entry_set_text(command_entry, command);
 263   gtk_toggle_button_set_active(terminal_button, terminal);
 264
 265   gtk_widget_set_sensitive(GTK_WIDGET(command_entry), !running);
 266   gtk_widget_set_sensitive(GTK_WIDGET(terminal_button), !running);
 267   gtk_widget_set_sensitive(GTK_WIDGET(level0_button), !running);
 268   gtk_widget_set_sensitive(GTK_WIDGET(level1_button), !running);
 269
 270   switch (level)
 271   {
 272   case 0:
 273     gtk_toggle_button_set_active(level0_button, TRUE);
 274     break;
 275   case 1:
 276     gtk_toggle_button_set_active(level1_button, TRUE);
 277     break;
 278   case 2:
 279     gtk_toggle_button_set_active(level2_button, TRUE);
 280     break;
 281   case 3:
 282     gtk_toggle_button_set_active(level3_button, TRUE);
 283     break;
 284   default:
 285     log_error("unknown level");
 286     ASSERT_NO_PASS;
 287     gtk_toggle_button_set_active(level0_button, TRUE);
 288   }
 289
 290   free(name);
 291   free(command);
 292
 293   gtk_window_set_focus(GTK_WINDOW(g_app_dialog), running ? GTK_WIDGET(name_entry) : GTK_WIDGET(command_entry));
 294   gtk_window_set_title(GTK_WINDOW(g_app_dialog), _("App properties"));
 295
 296   gtk_widget_show(g_app_dialog);
 297
 298   result = gtk_dialog_run(GTK_DIALOG(g_app_dialog));
 299   if (result == 2)
 300   {
 301     if (gtk_toggle_button_get_active(level0_button))
 302     {
 303       level = 0;
 304     }
 305     else if (gtk_toggle_button_get_active(level1_button))
 306     {
 307       level = 1;
 308     }
 309     else if (gtk_toggle_button_get_active(level2_button))
 310     {
 311       level = 2;
 312     }
 313     else if (gtk_toggle_button_get_active(level3_button))
 314     {
 315       level = 3;
 316     }
 317     else
 318     {
 319       log_error("unknown level");
 320       ASSERT_NO_PASS;
 321       level = 0;
 322     }
 323
 324     log_info("'%s':'%s' %s level %"PRIu8, gtk_entry_get_text(name_entry), gtk_entry_get_text(command_entry), gtk_toggle_button_get_active(terminal_button) ? "terminal" : "shell", level);
 325     if (!ladish_app_supervisor_set_app_properties(proxy, id, gtk_entry_get_text(name_entry), gtk_entry_get_text(command_entry), gtk_toggle_button_get_active(terminal_button), level))
 326     {
 327       error_message_box(_("Cannot set app properties."));
 328     }
 329   }
 330
 331   gtk_widget_hide(g_app_dialog);
 332 }
 333
 334 void popup_menu(GtkWidget * treeview, GdkEventButton * event)
 335 {
 336   GtkTreeSelection * selection;
 337   GtkTreeIter iter;
 338   GtkWidget * menu;
 339   GtkWidget * menuitem;
 340   gint type;
 341   graph_view_handle view;
 342   uint64_t id;
 343   gboolean running;
 344   gboolean terminal;
 345   uint8_t level;
 346
 347   selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_world_tree_widget));
 348   if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
 349   {
 350     return;
 351   }
 352
 353   gtk_tree_model_get(
 354     GTK_TREE_MODEL(g_treestore),
 355     &iter,
 356     COL_TYPE, &type,
 357     COL_VIEW, &view,
 358     COL_ID, &id,
 359     COL_RUNNING, &running,
 360     COL_TERMINAL, &terminal,
 361     COL_LEVEL, &level,
 362     -1);
 363
 364   menu = gtk_menu_new();
 365
 366   if (type == entry_type_app)
 367   {
 368     if (running)
 369     {
 370       menuitem = gtk_menu_item_new_with_label(_("Stop"));
 371       g_signal_connect(menuitem, "activate", (GCallback)on_popup_menu_action_app_stop, NULL);
 372       gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 373
 374       menuitem = gtk_menu_item_new_with_label(_("Kill"));
 375       g_signal_connect(menuitem, "activate", (GCallback)on_popup_menu_action_app_kill, NULL);
 376       gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 377     }
 378     else
 379     {
 380       menuitem = gtk_menu_item_new_with_label(_("Start"));
 381       g_signal_connect(menuitem, "activate", (GCallback)on_popup_menu_action_app_start, NULL);
 382       gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 383     }
 384
 385     menuitem = gtk_menu_item_new_with_label(_("Properties"));
 386     g_signal_connect(menuitem, "activate", (GCallback)on_popup_menu_action_app_properties, NULL);
 387     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 388
 389     menuitem = gtk_separator_menu_item_new(); /* separator */
 390     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 391
 392     menuitem = gtk_menu_item_new_with_label(_("Remove"));
 393     g_signal_connect(menuitem, "activate", (GCallback)on_popup_menu_action_app_remove, NULL);
 394     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 395   }
 396   else if (type == entry_type_view)
 397   {
 398     fill_view_popup_menu(GTK_MENU(menu), view);
 399   }
 400   else
 401   {
 402     g_object_ref(menu);
 403     g_object_unref(menu);
 404     return;
 405   }
 406
 407   gtk_widget_show_all(menu);
 408
 409   /* Note: event can be NULL here when called from view_onPopupMenu;
 410    *  gdk_event_get_time() accepts a NULL argument */
 411   gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, (event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent *)event));
 412 }
 413
 414 gboolean on_button_pressed(GtkWidget * treeview, GdkEventButton * event, gpointer userdata)
 415 {
 416   /* single click with the right mouse button? */
 417   if (event->type == GDK_BUTTON_PRESS && event->button == 3)
 418   {
 419     /* select row if no row is selected or only one other row is selected */
 420     {
 421       GtkTreeSelection *selection;
 422
 423       selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
 424
 425       /* Note: gtk_tree_selection_count_selected_rows() does not exist in gtk+-2.0, only in gtk+ >= v2.2 ! */
 426       if (gtk_tree_selection_count_selected_rows(selection) <= 1)
 427       {
 428         GtkTreePath *path;
 429
 430         /* Get tree path for row that was clicked */
 431         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), (gint)event->x, (gint)event->y, &path, NULL, NULL, NULL))
 432         {
 433           gtk_tree_selection_unselect_all(selection);
 434           gtk_tree_selection_select_path(selection, path);
 435           gtk_tree_path_free(path);
 436         }
 437       }
 438     }
 439
 440     popup_menu(treeview, event);
 441
 442     return TRUE; /* we handled this */
 443   }
 444
 445   return FALSE; /* we did not handle this */
 446 }
 447
 448 gboolean on_popup_menu(GtkWidget * treeview, gpointer userdata)
 449 {
 450   popup_menu(treeview, NULL);
 451   return TRUE; /* we handled this */
 452 }
 453
 454 static void on_row_activated(GtkTreeView * treeview, GtkTreePath * path, GtkTreeViewColumn * col, gpointer userdata)
 455 {
 456   GtkTreeIter iter;
 457   gint type;
 458   graph_view_handle view;
 459   uint64_t id;
 460   gboolean running;
 461   ladish_app_supervisor_proxy_handle proxy;
 462
 463   if (!gtk_tree_model_get_iter(GTK_TREE_MODEL(g_treestore), &iter, path))
 464   {
 465     return;
 466   }
 467
 468   gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &iter, COL_TYPE, &type, COL_ID, &id, COL_RUNNING, &running, -1);
 469   if (type == entry_type_app)
 470   {
 471     log_info("%s app %"PRIu64, running ? "stop" : "start", id);
 472
 473     if (!get_app_view(&iter, &view))
 474     {
 475       ASSERT_NO_PASS;
 476       return;
 477     }
 478
 479     proxy = graph_view_get_app_supervisor(view);
 480     (running ? ladish_app_supervisor_proxy_stop_app : ladish_app_supervisor_proxy_start_app)(proxy, id);
 481   }
 482 }
 483
 484 void world_tree_init(void)
 485 {
 486   GtkTreeViewColumn * col;
 487   GtkCellRenderer * renderer;
 488   GtkTreeSelection * selection;
 489
 490   g_world_tree_widget = get_gtk_builder_widget("world_tree");
 491   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(g_world_tree_widget), FALSE);
 492
 493   col = gtk_tree_view_column_new();
 494   gtk_tree_view_column_set_title(col, _("Name"));
 495   gtk_tree_view_append_column(GTK_TREE_VIEW(g_world_tree_widget), col);
 496   renderer = gtk_cell_renderer_text_new();
 497   gtk_tree_view_column_pack_start(col, renderer, TRUE);
 498   gtk_tree_view_column_add_attribute(col, renderer, "text", COL_NAME);
 499
 500   g_treestore = gtk_tree_store_new(
 501     NUM_COLS,
 502     G_TYPE_INT,
 503     G_TYPE_STRING,
 504     G_TYPE_POINTER,
 505     G_TYPE_UINT64,
 506     G_TYPE_BOOLEAN,
 507     G_TYPE_BOOLEAN,
 508     G_TYPE_CHAR);
 509   gtk_tree_view_set_model(GTK_TREE_VIEW(g_world_tree_widget), GTK_TREE_MODEL(g_treestore));
 510
 511   selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_world_tree_widget));
 512   gtk_tree_selection_set_select_function(selection, on_select, NULL, NULL);
 513
 514   g_signal_connect(g_world_tree_widget, "button-press-event", (GCallback)on_button_pressed, NULL);
 515   g_signal_connect(g_world_tree_widget, "popup-menu", (GCallback)on_popup_menu, NULL);
 516   g_signal_connect(g_world_tree_widget, "row-activated", (GCallback)on_row_activated, NULL);
 517 }
 518
 519 void world_tree_add(graph_view_handle view, bool force_activate)
 520 {
 521   GtkTreeIter iter;
 522
 523   gtk_tree_store_append(g_treestore, &iter, NULL);
 524   gtk_tree_store_set(g_treestore, &iter, COL_TYPE, entry_type_view, COL_VIEW, view, COL_NAME, get_view_name(view), -1);
 525
 526   /* select the first top level item */
 527   if (force_activate || gtk_tree_model_iter_n_children(GTK_TREE_MODEL(g_treestore), NULL) == 1)
 528   {
 529     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(g_world_tree_widget)), &iter);
 530   }
 531 }
 532
 533 graph_view_handle world_tree_find_by_opath(const char * opath)
 534 {
 535   gint type;
 536   graph_view_handle view;
 537   GtkTreeIter iter;
 538
 539   if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(g_treestore), &iter))
 540   {
 541     do
 542     {
 543       gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &iter, COL_TYPE, &type, COL_VIEW, &view, -1);
 544       if (type == entry_type_view)
 545       {
 546         if (strcmp(get_view_opath(view), opath) == 0)
 547         {
 548           return view;
 549         }
 550       }
 551     }
 552     while (gtk_tree_model_iter_next(GTK_TREE_MODEL(g_treestore), &iter));
 553   }
 554
 555   return NULL;
 556 }
 557
 558 static bool find_view(graph_view_handle view, GtkTreeIter * iter_ptr)
 559 {
 560   gint type;
 561   graph_view_handle view2;
 562
 563   if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(g_treestore), iter_ptr))
 564   {
 565     do
 566     {
 567       gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), iter_ptr, COL_TYPE, &type, COL_VIEW, &view2, -1);
 568       if (type == entry_type_view && view == view2)
 569       {
 570         return true;
 571       }
 572     }
 573     while (gtk_tree_model_iter_next(GTK_TREE_MODEL(g_treestore), iter_ptr));
 574   }
 575
 576   return false;
 577 }
 578
 579 static bool find_app(graph_view_handle view, uint64_t id, GtkTreeIter * view_iter_ptr, GtkTreeIter * app_iter_ptr)
 580 {
 581   gint type;
 582   uint64_t id2;
 583
 584   if (!find_view(view, view_iter_ptr))
 585   {
 586     return false;
 587   }
 588
 589   if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(g_treestore), app_iter_ptr, view_iter_ptr))
 590   {
 591     return false;
 592   }
 593
 594   do
 595   {
 596     gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), app_iter_ptr, COL_TYPE, &type, COL_ID, &id2, -1);
 597     if (type == entry_type_app && id == id2)
 598     {
 599       return true;
 600     }
 601   }
 602   while (gtk_tree_model_iter_next(GTK_TREE_MODEL(g_treestore), app_iter_ptr));
 603
 604   return false;
 605 }
 606
 607 void world_tree_remove(graph_view_handle view)
 608 {
 609   GtkTreeIter iter;
 610
 611   if (find_view(view, &iter))
 612   {
 613     gtk_tree_store_remove(g_treestore, &iter);
 614   }
 615 }
 616
 617 void world_tree_activate(graph_view_handle view)
 618 {
 619   GtkTreeIter iter;
 620
 621   if (find_view(view, &iter))
 622   {
 623     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(g_world_tree_widget)), &iter);
 624   }
 625 }
 626
 627 void world_tree_name_changed(graph_view_handle view)
 628 {
 629   GtkTreeIter iter;
 630
 631   if (find_view(view, &iter))
 632   {
 633     gtk_tree_store_set(g_treestore, &iter, COL_NAME, get_view_name(view), -1);
 634   }
 635 }
 636
 637 static char * get_app_name_string(const char * app_name, bool running, bool terminal, uint8_t level)
 638 {
 639   char * app_name_with_status;
 640   const char * level_string;
 641
 642   switch (level)
 643   {
 644   case 0:
 645     level_string = "[L0]";
 646     break;
 647   case 1:
 648     level_string = "[L1]";
 649     break;
 650   default:
 651     level_string = "[L?]";
 652   }
 653
 654   app_name_with_status = catdup3(level_string, running ? " " : _(" (inactive) "), app_name);
 655   if (app_name_with_status == NULL)
 656   {
 657     log_error("catdup failed for app name");
 658     return NULL;
 659   }
 660
 661   return app_name_with_status;
 662 }
 663
 664 void world_tree_add_app(graph_view_handle view, uint64_t id, const char * app_name, bool running, bool terminal, uint8_t level)
 665 {
 666   GtkTreeIter iter;
 667   const char * view_name;
 668   GtkTreeIter child;
 669   GtkTreePath * path;
 670   char * app_name_with_status;
 671
 672   if (!find_view(view, &iter))
 673   {
 674     ASSERT_NO_PASS;
 675     return;
 676   }
 677
 678   path = gtk_tree_model_get_path(GTK_TREE_MODEL(g_treestore), &iter);
 679
 680   gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &iter, COL_NAME, &view_name, -1);
 681
 682   log_info("adding app '%s' to '%s'", app_name, view_name);
 683
 684   app_name_with_status = get_app_name_string(app_name, running, terminal, level);
 685   if (app_name_with_status == NULL)
 686   {
 687     goto free_path;
 688   }
 689
 690   gtk_tree_store_append(g_treestore, &child, &iter);
 691   gtk_tree_store_set(
 692     g_treestore,
 693     &child,
 694     COL_TYPE, entry_type_app,
 695     COL_NAME, app_name_with_status,
 696     COL_ID, id,
 697     COL_RUNNING, running,
 698     COL_TERMINAL, terminal,
 699     COL_LEVEL, level,
 700     -1);
 701   gtk_tree_view_expand_row(GTK_TREE_VIEW(g_world_tree_widget), path, false);
 702
 703   free(app_name_with_status);
 704 free_path:
 705   gtk_tree_path_free(path);
 706 }
 707
 708 void world_tree_app_state_changed(graph_view_handle view, uint64_t id, const char * app_name, bool running, bool terminal, uint8_t level)
 709 {
 710   GtkTreeIter view_iter;
 711   GtkTreeIter app_iter;
 712   const char * view_name;
 713   GtkTreePath * path;
 714   char * app_name_with_status;
 715
 716   if (!find_app(view, id, &view_iter, &app_iter))
 717   {
 718     log_error("removed app not found");
 719     return;
 720   }
 721
 722   path = gtk_tree_model_get_path(GTK_TREE_MODEL(g_treestore), &view_iter);
 723
 724   gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &view_iter, COL_NAME, &view_name, -1);
 725
 726   log_info("changing app state '%s':'%s'", view_name, app_name);
 727
 728   app_name_with_status = get_app_name_string(app_name, running, terminal, level);
 729   if (app_name_with_status == NULL)
 730   {
 731     goto free_path;
 732   }
 733
 734   gtk_tree_view_expand_row(GTK_TREE_VIEW(g_world_tree_widget), path, false);
 735   gtk_tree_store_set(
 736     g_treestore,
 737     &app_iter,
 738     COL_NAME, app_name_with_status,
 739     COL_RUNNING, running,
 740     COL_TERMINAL, terminal,
 741     COL_LEVEL, level,
 742     -1);
 743
 744   free(app_name_with_status);
 745 free_path:
 746   gtk_tree_path_free(path);
 747 }
 748
 749 void world_tree_remove_app(graph_view_handle view, uint64_t id)
 750 {
 751   GtkTreeIter view_iter;
 752   GtkTreeIter app_iter;
 753   const char * view_name;
 754   const char * app_name;
 755   GtkTreePath * path;
 756
 757   if (!find_app(view, id, &view_iter, &app_iter))
 758   {
 759     log_error("removed app not found");
 760     return;
 761   }
 762
 763   path = gtk_tree_model_get_path(GTK_TREE_MODEL(g_treestore), &view_iter);
 764
 765   gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &view_iter, COL_NAME, &view_name, -1);
 766   gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &app_iter, COL_NAME, &app_name, -1);
 767
 768   log_info("removing app '%s' from '%s'", app_name, view_name);
 769
 770   gtk_tree_view_expand_row(GTK_TREE_VIEW(g_world_tree_widget), path, false);
 771   gtk_tree_store_remove(g_treestore, &app_iter);
 772
 773   gtk_tree_path_free(path);
 774 }
 775
 776 void world_tree_destroy_room_views(void)
 777 {
 778   gint type;
 779   graph_view_handle view;
 780   GtkTreeIter iter;
 781   bool valid;
 782
 783   if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(g_treestore), &iter))
 784   {
 785     return;
 786   }
 787
 788 loop:
 789   gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &iter, COL_TYPE, &type, COL_VIEW, &view, -1);
 790   if (type == entry_type_view && is_room_view(view))
 791   {
 792     //log_info("removing view for room %s", get_view_opath(view));
 793     valid = gtk_tree_store_remove(g_treestore, &iter);
 794
 795     destroy_view(view);
 796
 797     if (!valid)
 798     {
 799       /* no more entries */
 800       return;
 801     }
 802
 803     goto loop;
 804   }
 805
 806   if (gtk_tree_model_iter_next(GTK_TREE_MODEL(g_treestore), &iter))
 807   {
 808     goto loop;
 809   }
 810 }