Pileus Git - grits/blob - src/aweather-gui.c

   1 /*
   2  * Copyright (C) 2009 Andy Spencer <spenceal@rose-hulman.edu>
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <config.h>
  19 #include <gtk/gtk.h>
  20 #include <gdk/gdkkeysyms.h>
  21 #include <math.h>
  22
  23 #include <gis/gis.h>
  24
  25 #include "aweather-gui.h"
  26 #include "aweather-location.h"
  27
  28 /* Needed prototpes */
  29 gboolean on_gui_key_press(GtkWidget *widget, GdkEventKey *event, AWeatherGui *self);
  30 static void on_gis_refresh(GisWorld *world, gpointer _self);
  31 static void on_gis_site_changed(GisView *view, char *site, gpointer _self);
  32 static void site_setup(AWeatherGui *self);
  33 static void time_setup(AWeatherGui *self);
  34
  35 /****************
  36  * GObject code *
  37  ****************/
  38 G_DEFINE_TYPE(AWeatherGui, aweather_gui, GTK_TYPE_WINDOW);
  39 static void aweather_gui_init(AWeatherGui *self)
  40 {
  41         g_debug("AWeatherGui: init");
  42
  43         /* Simple things */
  44         self->prefs   = gis_prefs_new("aweather");
  45         self->plugins = gis_plugins_new();
  46         self->world   = gis_world_new();
  47         self->view    = gis_view_new();
  48
  49         /* Setup window */
  50         self->builder = gtk_builder_new();
  51         GError *error = NULL;
  52         if (!gtk_builder_add_from_file(self->builder, DATADIR "/aweather/main.ui", &error))
  53                 g_error("Failed to create gtk builder: %s", error->message);
  54         gtk_widget_reparent(aweather_gui_get_widget(self, "body"), GTK_WIDGET(self));
  55
  56         /* GIS things */
  57         GtkWidget *drawing = aweather_gui_get_widget(self, "drawing");
  58         self->opengl = gis_opengl_new(self->world, self->view, GTK_DRAWING_AREA(drawing));
  59         self->opengl->plugins = self->plugins;
  60         //gtk_widget_show_all(GTK_WIDGET(self));
  61
  62         /* Misc, helpers */
  63         site_setup(self);
  64         time_setup(self);
  65
  66         /* Plugins */
  67         GtkTreeIter iter;
  68         self->gtk_plugins = GTK_LIST_STORE(aweather_gui_get_object(self, "plugins"));
  69         for (GList *cur = gis_plugins_available(); cur; cur = cur->next) {
  70                 gchar *name = cur->data;
  71                 gboolean enabled = gis_prefs_get_boolean_v(self->prefs, cur->data, "enabled");
  72                 gtk_list_store_append(self->gtk_plugins, &iter);
  73                 gtk_list_store_set(self->gtk_plugins, &iter, 0, name, 1, enabled, -1);
  74                 if (enabled)
  75                         aweather_gui_attach_plugin(self, name);
  76         }
  77
  78         /* Connect signals */
  79         gtk_builder_connect_signals(self->builder, self);
  80         g_signal_connect(self, "key-press-event",
  81                         G_CALLBACK(on_gui_key_press), self);
  82         g_signal_connect_swapped(self->world, "offline",
  83                         G_CALLBACK(gtk_toggle_action_set_active),
  84                         aweather_gui_get_object(self, "offline"));
  85
  86         /* deprecated site stuff */
  87         g_signal_connect(self->view,  "site-changed", G_CALLBACK(on_gis_site_changed), self);
  88         g_signal_connect(self->world, "refresh",      G_CALLBACK(on_gis_refresh),      self);
  89 }
  90 static GObject *aweather_gui_constructor(GType gtype, guint n_properties,
  91                 GObjectConstructParam *properties)
  92 {
  93         g_debug("aweather_gui: constructor");
  94         GObjectClass *parent_class = G_OBJECT_CLASS(aweather_gui_parent_class);
  95         return  parent_class->constructor(gtype, n_properties, properties);
  96 }
  97 static void aweather_gui_dispose(GObject *_self)
  98 {
  99         g_debug("AWeatherGui: dispose");
 100         AWeatherGui *self = AWEATHER_GUI(_self);
 101         if (self->builder) {
 102                 /* Reparent to avoid double unrefs */
 103                 GtkWidget *body   = aweather_gui_get_widget(self, "body");
 104                 GtkWidget *window = aweather_gui_get_widget(self, "main_window");
 105                 gtk_widget_reparent(body, window);
 106                 g_object_unref(self->builder);
 107                 self->builder = NULL;
 108         }
 109         if (self->world) {
 110                 g_object_unref(self->world);
 111                 self->world = NULL;
 112         }
 113         if (self->view) {
 114                 g_object_unref(self->view);
 115                 self->view = NULL;
 116         }
 117         if (self->opengl) {
 118                 g_object_unref(self->opengl);
 119                 self->opengl = NULL;
 120         }
 121         if (self->plugins) {
 122                 gis_plugins_free(self->plugins);
 123                 self->plugins = NULL;
 124         }
 125         if (self->prefs) {
 126                 g_object_unref(self->prefs);
 127                 self->prefs = NULL;
 128         }
 129         G_OBJECT_CLASS(aweather_gui_parent_class)->dispose(_self);
 130 }
 131 static void aweather_gui_finalize(GObject *_self)
 132 {
 133         g_debug("AWeatherGui: finalize");
 134         G_OBJECT_CLASS(aweather_gui_parent_class)->finalize(_self);
 135         gtk_main_quit();
 136
 137 }
 138 static void aweather_gui_class_init(AWeatherGuiClass *klass)
 139 {
 140         g_debug("AWeatherGui: class_init");
 141         GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 142         gobject_class->constructor  = aweather_gui_constructor;
 143         gobject_class->dispose      = aweather_gui_dispose;
 144         gobject_class->finalize     = aweather_gui_finalize;
 145 }
 146
 147 /*************
 148  * Callbacks *
 149  *************/
 150 gboolean on_gui_key_press(GtkWidget *widget, GdkEventKey *event, AWeatherGui *self)
 151 {
 152         g_debug("AWeatherGui: on_gui_key_press - key=%x, state=%x",
 153                         event->keyval, event->state);
 154         if (event->keyval == GDK_q)
 155                 gtk_widget_destroy(GTK_WIDGET(self));
 156         else if (event->keyval == GDK_r && event->state & GDK_CONTROL_MASK)
 157                 gis_world_refresh(self->world);
 158         else if (event->keyval == GDK_Tab || event->keyval == GDK_ISO_Left_Tab) {
 159                 GtkNotebook *tabs = GTK_NOTEBOOK(aweather_gui_get_widget(self, "tabs"));
 160                 gint num_tabs = gtk_notebook_get_n_pages(tabs);
 161                 gint cur_tab  = gtk_notebook_get_current_page(tabs);
 162                 if (event->state & GDK_SHIFT_MASK)
 163                         gtk_notebook_set_current_page(tabs, (cur_tab-1)%num_tabs);
 164                 else
 165                         gtk_notebook_set_current_page(tabs, (cur_tab+1)%num_tabs);
 166         };
 167         return FALSE;
 168 }
 169
 170 void on_quit(GtkMenuItem *menu, AWeatherGui *self)
 171 {
 172         gtk_widget_destroy(GTK_WIDGET(self));
 173 }
 174
 175 void on_zoomin(GtkAction *action, AWeatherGui *self)
 176 {
 177         gis_view_zoom(self->view, 3./4);
 178 }
 179
 180 void on_zoomout(GtkAction *action, AWeatherGui *self)
 181 {
 182         gis_view_zoom(self->view, 4./3);
 183 }
 184
 185 void on_refresh(GtkAction *action, AWeatherGui *self)
 186 {
 187         gis_world_refresh(self->world);
 188 }
 189
 190 void load_window(gchar *name, AWeatherGui *self)
 191 {
 192         // TODO: use gtk_widget_hide_on_delete()
 193         char *objects[2] = {name, NULL};
 194         gtk_builder_add_objects_from_file(self->builder,
 195                         DATADIR "/aweather/main.ui", objects, NULL);
 196         gtk_builder_connect_signals(self->builder, self);
 197         GtkWidget *main_win = aweather_gui_get_widget(self, "main_window");
 198         GtkWidget *this_win = aweather_gui_get_widget(self, name);
 199         gtk_window_set_transient_for(GTK_WINDOW(this_win), GTK_WINDOW(main_win));
 200         gtk_widget_show_all(this_win);
 201 }
 202
 203 void on_about(GtkAction *action, AWeatherGui *self)
 204 {
 205         load_window("about_window", self);
 206 }
 207
 208 void on_plugin_toggled(GtkCellRendererToggle *cell, gchar *path_str, AWeatherGui *self)
 209 {
 210         GtkWidget    *tview = aweather_gui_get_widget(self, "plugins_view");
 211         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(tview));
 212         g_message("model=%p", model);
 213         gboolean state;
 214         gchar *name;
 215         GtkTreeIter iter;
 216         gtk_tree_model_get_iter_from_string(model, &iter, path_str);
 217         gtk_tree_model_get(model, &iter, 0, &name, 1, &state, -1);
 218         state = !state;
 219         gtk_list_store_set(GTK_LIST_STORE(model), &iter, 1, state, -1);
 220         if (state)
 221                 aweather_gui_attach_plugin(self, name);
 222         else
 223                 aweather_gui_deattach_plugin(self, name);
 224         gis_prefs_set_boolean_v(self->prefs, name, "enabled", state);
 225         g_free(name);
 226 }
 227 void on_prefs(GtkAction *action, AWeatherGui *self)
 228 {
 229         /* get prefs */
 230         gchar *is = gis_prefs_get_string (self->prefs, "aweather/initial_site");
 231         gchar *nu = gis_prefs_get_string (self->prefs, "aweather/nexrad_url");
 232         gint   ll = gis_prefs_get_integer(self->prefs, "aweather/log_level");
 233         load_window("prefs_window", self);
 234         /* set prefs */
 235         GtkWidget *isw = aweather_gui_get_widget(self, "initial_site");
 236         GtkWidget *nuw = aweather_gui_get_widget(self, "nexrad_url");
 237         GtkWidget *llw = aweather_gui_get_widget(self, "log_level");
 238         if (is) gtk_entry_set_text(GTK_ENTRY(isw), is), g_free(is);
 239         if (nu) gtk_entry_set_text(GTK_ENTRY(nuw), nu), g_free(nu);
 240         if (ll) gtk_spin_button_set_value(GTK_SPIN_BUTTON(llw), ll);
 241
 242         /* Plugins */
 243         GtkTreeView       *tview = GTK_TREE_VIEW(aweather_gui_get_widget(self, "plugins_view"));
 244         GtkCellRenderer   *rend1 = gtk_cell_renderer_text_new();
 245         GtkCellRenderer   *rend2 = gtk_cell_renderer_toggle_new();
 246         GtkTreeViewColumn *col1  = gtk_tree_view_column_new_with_attributes(
 247                         "Plugin",  rend1, "text",   0, NULL);
 248         GtkTreeViewColumn *col2  = gtk_tree_view_column_new_with_attributes(
 249                         "Enabled", rend2, "active", 1, NULL);
 250         gtk_tree_view_append_column(tview, col1);
 251         gtk_tree_view_append_column(tview, col2);
 252         g_signal_connect(rend2, "toggled", G_CALLBACK(on_plugin_toggled), self);
 253         gtk_tree_view_set_model(GTK_TREE_VIEW(tview), GTK_TREE_MODEL(self->gtk_plugins));
 254 }
 255
 256 void on_time_changed(GtkTreeView *view, GtkTreePath *path,
 257                 GtkTreeViewColumn *column, AWeatherGui *self)
 258 {
 259         gchar *time;
 260         GtkTreeIter iter;
 261         GtkTreeModel *model = gtk_tree_view_get_model(view);
 262         gtk_tree_model_get_iter(model, &iter, path);
 263         gtk_tree_model_get(model, &iter, 0, &time, -1);
 264         gis_view_set_time(self->view, time);
 265         g_free(time);
 266 }
 267
 268 void on_site_changed(GtkComboBox *combo, AWeatherGui *self)
 269 {
 270         gchar *site;
 271         GtkTreeIter iter;
 272         GtkTreeModel *model = gtk_combo_box_get_model(combo);
 273         gtk_combo_box_get_active_iter(combo, &iter);
 274         gtk_tree_model_get(model, &iter, 1, &site, -1);
 275         gis_view_set_site(self->view, site);
 276         g_free(site);
 277 }
 278
 279 /* TODO: replace the code in these with `gtk_tree_model_find' utility */
 280 static void update_time_widget(GisView *view, const char *time, AWeatherGui *self)
 281 {
 282         g_debug("AWeatherGui: update_time_widget - time=%s", time);
 283         GtkTreeView  *tview = GTK_TREE_VIEW(aweather_gui_get_widget(self, "time"));
 284         GtkTreeModel *model = GTK_TREE_MODEL(gtk_tree_view_get_model(tview));
 285         for (int i = 0; i < gtk_tree_model_iter_n_children(model, NULL); i++) {
 286                 char *text;
 287                 GtkTreeIter iter;
 288                 gtk_tree_model_iter_nth_child(model, &iter, NULL, i);
 289                 gtk_tree_model_get(model, &iter, 0, &text, -1);
 290                 if (g_str_equal(text, time)) {
 291                         GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
 292                         g_signal_handlers_block_by_func(tview,
 293                                         G_CALLBACK(on_site_changed), self);
 294                         gtk_tree_view_set_cursor(tview, path, NULL, FALSE);
 295                         g_signal_handlers_unblock_by_func(tview,
 296                                         G_CALLBACK(on_site_changed), self);
 297                         gtk_tree_path_free(path);
 298                         g_free(text);
 299                         return;
 300                 }
 301                 g_free(text);
 302         }
 303 }
 304 static void update_site_widget(GisView *view, char *site, AWeatherGui *self)
 305 {
 306         g_debug("AWeatherGui: update_site_widget - site=%s", site);
 307         GtkComboBox  *combo = GTK_COMBO_BOX(aweather_gui_get_widget(self, "site"));
 308         GtkTreeModel *model = GTK_TREE_MODEL(gtk_combo_box_get_model(combo));
 309         for (int i = 0; i < gtk_tree_model_iter_n_children(model, NULL); i++) {
 310                 GtkTreeIter iter1;
 311                 gtk_tree_model_iter_nth_child(model, &iter1, NULL, i);
 312                 for (int i = 0; i < gtk_tree_model_iter_n_children(model, &iter1); i++) {
 313                         GtkTreeIter iter2;
 314                         gtk_tree_model_iter_nth_child(model, &iter2, &iter1, i);
 315                         char *text;
 316                         gtk_tree_model_get(model, &iter2, 1, &text, -1);
 317                         if (text == NULL)
 318                                 continue;
 319                         if (g_str_equal(text, site)) {
 320                                 g_signal_handlers_block_by_func(combo,
 321                                                 G_CALLBACK(on_site_changed), self);
 322                                 gtk_combo_box_set_active_iter(combo, &iter2);
 323                                 g_signal_handlers_unblock_by_func(combo,
 324                                                 G_CALLBACK(on_site_changed), self);
 325                                 g_free(text);
 326                                 return;
 327                         }
 328                         g_free(text);
 329                 }
 330         }
 331 }
 332 /* Prefs callbacks */
 333 void on_offline(GtkToggleAction *action, AWeatherGui *self)
 334 {
 335         gboolean value = gtk_toggle_action_get_active(action);
 336         g_debug("AWeatherGui: on_offline - offline=%d", value);
 337         gis_prefs_set_boolean(self->prefs, "gis/offline", value);
 338         gis_world_set_offline(self->world, value);
 339 }
 340 void on_initial_site_changed(GtkEntry *entry, AWeatherGui *self)
 341 {
 342         const gchar *text = gtk_entry_get_text(entry);
 343         g_debug("AWeatherGui: on_initial_site_changed - site=%s", text);
 344         gis_prefs_set_string(self->prefs, "aweather/initial_site", text);
 345 }
 346 void on_nexrad_url_changed(GtkEntry *entry, AWeatherGui *self)
 347 {
 348         const gchar *text = gtk_entry_get_text(entry);
 349         g_debug("AWeatherGui: on_nexrad_url_changed - url=%s", text);
 350         gis_prefs_set_string(self->prefs, "aweather/nexrad_url", text);
 351 }
 352 int on_log_level_changed(GtkSpinButton *spinner, AWeatherGui *self)
 353 {
 354         gint value = gtk_spin_button_get_value_as_int(spinner);
 355         g_debug("AWeatherGui: on_log_level_changed - %p, level=%d", self, value);
 356         gis_prefs_set_integer(self->prefs, "aweather/log_level", value);
 357         return TRUE;
 358 }
 359 // plugins
 360
 361 /*****************
 362  * Setup helpers *
 363  *****************/
 364 static void combo_sensitive(GtkCellLayout *cell_layout, GtkCellRenderer *cell,
 365                 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
 366 {
 367         gboolean sensitive = !gtk_tree_model_iter_has_child(tree_model, iter);
 368         g_object_set(cell, "sensitive", sensitive, NULL);
 369 }
 370
 371 static void site_setup(AWeatherGui *self)
 372 {
 373         GtkTreeIter state, city;
 374         GtkTreeStore *store = GTK_TREE_STORE(aweather_gui_get_object(self, "sites"));
 375         for (int i = 0; cities[i].label; i++) {
 376                 if (cities[i].type == LOCATION_STATE) {
 377                         gtk_tree_store_append(store, &state, NULL);
 378                         gtk_tree_store_set   (store, &state, 0, cities[i].label,
 379                                                              1, cities[i].code,  -1);
 380                 } else {
 381                         gtk_tree_store_append(store, &city, &state);
 382                         gtk_tree_store_set   (store, &city, 0, cities[i].label,
 383                                                             1, cities[i].code,  -1);
 384                 }
 385         }
 386
 387         GtkWidget *combo    = aweather_gui_get_widget(self, "site");
 388         GObject   *renderer = aweather_gui_get_object(self, "site_rend");
 389         gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(combo),
 390                         GTK_CELL_RENDERER(renderer), combo_sensitive, NULL, NULL);
 391
 392         g_signal_connect(self->view, "site-changed",
 393                         G_CALLBACK(update_site_widget), self);
 394 }
 395
 396 static void time_setup(AWeatherGui *self)
 397 {
 398         GtkTreeView       *tview = GTK_TREE_VIEW(aweather_gui_get_widget(self, "time"));
 399         GtkCellRenderer   *rend  = gtk_cell_renderer_text_new();
 400         GtkTreeViewColumn *col   = gtk_tree_view_column_new_with_attributes(
 401                                         "Time", rend, "text", 0, NULL);
 402
 403         gtk_tree_view_append_column(tview, col);
 404         g_object_set(rend, "size-points", 8.0, NULL);
 405
 406         g_signal_connect(self->view, "time-changed",
 407                         G_CALLBACK(update_time_widget), self);
 408 }
 409
 410
 411 /*************************
 412  * Deprecated site stuff *
 413  *************************/
 414 /* TODO: These update times functions are getting ugly... */
 415 static void update_times_gtk(AWeatherGui *self, GList *times)
 416 {
 417         gchar *last_time = NULL;
 418         GRegex *regex = g_regex_new("^[A-Z]{4}_([0-9]{8}_[0-9]{4})$", 0, 0, NULL); // KLSX_20090622_2113
 419         GMatchInfo *info;
 420
 421         GtkTreeView  *tview  = GTK_TREE_VIEW(aweather_gui_get_widget(self, "time"));
 422         GtkListStore *lstore = GTK_LIST_STORE(gtk_tree_view_get_model(tview));
 423         gtk_list_store_clear(lstore);
 424         GtkTreeIter iter;
 425         times = g_list_reverse(times);
 426         for (GList *cur = times; cur; cur = cur->next) {
 427                 if (g_regex_match(regex, cur->data, 0, &info)) {
 428                         gchar *time = g_match_info_fetch(info, 1);
 429                         gtk_list_store_insert(lstore, &iter, 0);
 430                         gtk_list_store_set(lstore, &iter, 0, time, -1);
 431                         last_time = time;
 432                 }
 433         }
 434
 435         gis_view_set_time(self->view, last_time);
 436
 437         g_regex_unref(regex);
 438         g_list_foreach(times, (GFunc)g_free, NULL);
 439         g_list_free(times);
 440 }
 441 static void update_times_online_cb(char *path, gboolean updated, gpointer _self)
 442 {
 443         GList *times = NULL;
 444         gchar *data;
 445         gsize length;
 446         g_file_get_contents(path, &data, &length, NULL);
 447         gchar **lines = g_strsplit(data, "\n", -1);
 448         for (int i = 0; lines[i] && lines[i][0]; i++) {
 449                 char **parts = g_strsplit(lines[i], " ", 2);
 450                 times = g_list_prepend(times, g_strdup(parts[1]));
 451                 g_strfreev(parts);
 452         }
 453         g_strfreev(lines);
 454         g_free(data);
 455
 456         update_times_gtk(_self, times);
 457 }
 458 static void update_times(AWeatherGui *self, GisView *view, char *site)
 459 {
 460         g_debug("AWeatherGui: update_times - site=%s", site);
 461         if (gis_world_get_offline(self->world)) {
 462                 GList *times = NULL;
 463                 gchar *path = g_build_filename(g_get_user_cache_dir(), PACKAGE, "nexrd2", "raw", site, NULL);
 464                 GDir *dir = g_dir_open(path, 0, NULL);
 465                 if (dir) {
 466                         const gchar *name;
 467                         while ((name = g_dir_read_name(dir))) {
 468                                 times = g_list_prepend(times, g_strdup(name));
 469                         }
 470                         g_dir_close(dir);
 471                 }
 472                 g_free(path);
 473                 update_times_gtk(self, times);
 474         } else {
 475                 gchar *path = g_strdup_printf("nexrd2/raw/%s/dir.list", site);
 476                 char *base = gis_prefs_get_string(self->prefs, "aweather/nexrad_url");
 477                 cache_file(base, path, GIS_REFRESH, NULL, update_times_online_cb, self);
 478                 /* update_times_gtk from update_times_online_cb */
 479         }
 480 }
 481 static void on_gis_site_changed(GisView *view, char *site, gpointer _self)
 482 {
 483         AWeatherGui *self = AWEATHER_GUI(_self);
 484         g_debug("AWeatherGui: on_site_changed - Loading wsr88d list for %s", site);
 485         update_times(self, view, site);
 486 }
 487 static void on_gis_refresh(GisWorld *world, gpointer _self)
 488 {
 489         AWeatherGui *self = AWEATHER_GUI(_self);
 490         char *site = gis_view_get_site(self->view);
 491         update_times(self, self->view, site);
 492 }
 493
 494 /***********
 495  * Methods *
 496  ***********/
 497 AWeatherGui *aweather_gui_new()
 498 {
 499         g_debug("AWeatherGui: new");
 500         return g_object_new(AWEATHER_TYPE_GUI, NULL);
 501 }
 502 GisWorld *aweather_gui_get_world(AWeatherGui *self)
 503 {
 504         g_assert(AWEATHER_IS_GUI(self));
 505         return self->world;
 506 }
 507 GisView *aweather_gui_get_view(AWeatherGui *self)
 508 {
 509         g_assert(AWEATHER_IS_GUI(self));
 510         return self->view;
 511 }
 512 GisOpenGL *aweather_gui_get_opengl(AWeatherGui *self)
 513 {
 514         g_assert(AWEATHER_IS_GUI(self));
 515         return self->opengl;
 516 }
 517 GtkBuilder *aweather_gui_get_builder(AWeatherGui *self)
 518 {
 519         g_debug("AWeatherGui: get_builder");
 520         g_assert(AWEATHER_IS_GUI(self));
 521         return self->builder;
 522 }
 523 GtkWidget *aweather_gui_get_widget(AWeatherGui *self, const gchar *name)
 524 {
 525         g_debug("AWeatherGui: get_widget - name=%s", name);
 526         g_assert(AWEATHER_IS_GUI(self));
 527         GObject *widget = gtk_builder_get_object(self->builder, name);
 528         if (!GTK_IS_WIDGET(widget))
 529                 g_error("Failed to get widget `%s'", name);
 530         return GTK_WIDGET(widget);
 531 }
 532 GObject *aweather_gui_get_object(AWeatherGui *self, const gchar *name)
 533 {
 534         g_debug("AWeatherGui: get_widget - name=%s", name);
 535         g_assert(AWEATHER_IS_GUI(self));
 536         return gtk_builder_get_object(self->builder, name);
 537 }
 538 void aweather_gui_attach_plugin(AWeatherGui *self, const gchar *name)
 539 {
 540         GisPlugin *plugin = gis_plugins_load(self->plugins, name,
 541                         self->world, self->view, self->opengl, self->prefs);
 542         GtkWidget *config = aweather_gui_get_widget(self, "tabs");
 543         GtkWidget *tab    = gtk_label_new(name);
 544         GtkWidget *body   = gis_plugin_get_config(plugin);
 545         gtk_notebook_append_page(GTK_NOTEBOOK(config), body, tab);
 546         gtk_widget_show_all(config);
 547 }
 548 void aweather_gui_deattach_plugin(AWeatherGui *self, const gchar *name)
 549 {
 550         GtkWidget *config = aweather_gui_get_widget(self, "tabs");
 551         guint n_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(config));
 552         for (int i = 0; i < n_pages; i++) {
 553                 GtkWidget *body = gtk_notebook_get_nth_page(GTK_NOTEBOOK(config), i);
 554                 GtkWidget *tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(config), body);
 555                 const gchar *tab_name = gtk_label_get_text(GTK_LABEL(tab));
 556                 if (tab_name && g_str_equal(name, tab_name))
 557                         gtk_notebook_remove_page(GTK_NOTEBOOK(config), i);
 558         }
 559         gis_plugins_unload(self->plugins, name);
 560 }