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