Pileus Git - aweather/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
  29 /*************
  30  * Callbacks *
  31  *************/
  32 gboolean on_gui_key_press(GtkWidget *widget, GdkEventKey *event, AWeatherGui *self)
  33 {
  34         g_debug("AWeatherGui: on_gui_key_press - key=%x, state=%x",
  35                         event->keyval, event->state);
  36         if (event->keyval == GDK_q)
  37                 gtk_widget_destroy(GTK_WIDGET(self));
  38         else if (event->keyval == GDK_r && event->state & GDK_CONTROL_MASK)
  39                 gis_viewer_refresh(self->viewer);
  40         else if (event->keyval == GDK_Tab || event->keyval == GDK_ISO_Left_Tab) {
  41                 GtkNotebook *tabs = GTK_NOTEBOOK(aweather_gui_get_widget(self, "main_tabs"));
  42                 gint num_tabs = gtk_notebook_get_n_pages(tabs);
  43                 gint cur_tab  = gtk_notebook_get_current_page(tabs);
  44                 if (event->state & GDK_SHIFT_MASK)
  45                         gtk_notebook_set_current_page(tabs, (cur_tab-1)%num_tabs);
  46                 else
  47                         gtk_notebook_set_current_page(tabs, (cur_tab+1)%num_tabs);
  48         };
  49         return FALSE;
  50 }
  51
  52 void on_quit(GtkMenuItem *menu, AWeatherGui *self)
  53 {
  54         gtk_widget_destroy(GTK_WIDGET(self));
  55 }
  56
  57 void on_zoomin(GtkAction *action, AWeatherGui *self)
  58 {
  59         gis_viewer_zoom(self->viewer, 3./4);
  60 }
  61
  62 void on_zoomout(GtkAction *action, AWeatherGui *self)
  63 {
  64         gis_viewer_zoom(self->viewer, 4./3);
  65 }
  66
  67 void on_refresh(GtkAction *action, AWeatherGui *self)
  68 {
  69         gis_viewer_refresh(self->viewer);
  70 }
  71
  72 void on_plugin_toggled(GtkCellRendererToggle *cell, gchar *path_str, AWeatherGui *self)
  73 {
  74         GtkWidget    *tview = aweather_gui_get_widget(self, "prefs_plugins_view");
  75         GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(tview));
  76         gboolean state;
  77         gchar *name;
  78         GtkTreeIter iter;
  79         gtk_tree_model_get_iter_from_string(model, &iter, path_str);
  80         gtk_tree_model_get(model, &iter, 0, &name, 1, &state, -1);
  81         state = !state;
  82         gtk_list_store_set(GTK_LIST_STORE(model), &iter, 1, state, -1);
  83         if (state)
  84                 aweather_gui_attach_plugin(self, name);
  85         else
  86                 aweather_gui_deattach_plugin(self, name);
  87         gis_prefs_set_boolean_v(self->prefs, name, "enabled", state);
  88         g_free(name);
  89 }
  90
  91 void on_time_changed(GtkTreeView *view, GtkTreePath *path,
  92                 GtkTreeViewColumn *column, AWeatherGui *self)
  93 {
  94         gchar *time;
  95         GtkTreeIter iter;
  96         GtkTreeModel *model = gtk_tree_view_get_model(view);
  97         gtk_tree_model_get_iter(model, &iter, path);
  98         gtk_tree_model_get(model, &iter, 0, &time, -1);
  99         gis_viewer_set_time(self->viewer, time);
 100         g_free(time);
 101 }
 102
 103 void on_site_changed(GtkComboBox *combo, AWeatherGui *self)
 104 {
 105         gchar *site;
 106         GtkTreeIter iter;
 107         GtkTreeModel *model = gtk_combo_box_get_model(combo);
 108         gtk_combo_box_get_active_iter(combo, &iter);
 109         gtk_tree_model_get(model, &iter, 1, &site, -1);
 110         city_t *city;
 111         for (city = cities; city->type; city++)
 112                 if (city->code && g_str_equal(city->code, site)) {
 113                         gis_viewer_set_location(self->viewer,
 114                                         city->lat, city->lon, EARTH_R/20);
 115                         gis_viewer_set_rotation(self->viewer, 0, 0, 0);
 116                         break;
 117                 }
 118         g_free(site);
 119 }
 120
 121 static gboolean gtk_tree_model_find_string(GtkTreeModel *model,
 122                 GtkTreeIter *rval, GtkTreeIter *parent, gint field, const gchar *key)
 123 {
 124         g_debug("AWeatherGui: gtk_tree_model_find - field=%d key=%s", field, key);
 125         char *text;
 126         GtkTreeIter cur;
 127         gint num_children = gtk_tree_model_iter_n_children(model, parent);
 128         for (int i = 0; i < num_children; i++) {
 129                 gtk_tree_model_iter_nth_child(model, &cur, parent, i);
 130                 gtk_tree_model_get(model, &cur, field, &text, -1);
 131                 if (text != NULL && g_str_equal(text, key)) {
 132                         *rval = cur;
 133                         g_free(text);
 134                         return TRUE;
 135                 }
 136                 g_free(text);
 137                 if (gtk_tree_model_iter_has_child(model, &cur))
 138                         if (gtk_tree_model_find_string(model, rval, &cur, field, key))
 139                                 return TRUE;
 140         }
 141         return FALSE;
 142 }
 143
 144 static void update_time_widget(GisViewer *viewer, const char *time, AWeatherGui *self)
 145 {
 146         g_debug("AWeatherGui: update_time_widget - time=%s", time);
 147         GtkTreeView  *tview = GTK_TREE_VIEW(aweather_gui_get_widget(self, "main_time"));
 148         GtkTreeModel *model = GTK_TREE_MODEL(gtk_tree_view_get_model(tview));
 149         GtkTreeIter iter;
 150         if (gtk_tree_model_find_string(model, &iter, NULL, 0, time)) {
 151                 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
 152                 g_signal_handlers_block_by_func(tview,
 153                                 G_CALLBACK(on_site_changed), self);
 154                 gtk_tree_view_set_cursor(tview, path, NULL, FALSE);
 155                 g_signal_handlers_unblock_by_func(tview,
 156                                 G_CALLBACK(on_site_changed), self);
 157                 gtk_tree_path_free(path);
 158         }
 159 }
 160
 161 static void update_site_widget(GisViewer *viewer, char *site, AWeatherGui *self)
 162 {
 163         g_debug("AWeatherGui: update_site_widget - site=%s", site);
 164         GtkComboBox  *combo = GTK_COMBO_BOX(aweather_gui_get_widget(self, "main_site"));
 165         GtkTreeModel *model = GTK_TREE_MODEL(gtk_combo_box_get_model(combo));
 166         GtkTreeIter iter;
 167         if (gtk_tree_model_find_string(model, &iter, NULL, 1, site)) {
 168                 g_signal_handlers_block_by_func(combo,
 169                                 G_CALLBACK(on_site_changed), self);
 170                 gtk_combo_box_set_active_iter(combo, &iter);
 171                 g_signal_handlers_unblock_by_func(combo,
 172                                 G_CALLBACK(on_site_changed), self);
 173         }
 174 }
 175
 176 /* Prefs callbacks */
 177 void on_offline(GtkToggleAction *action, AWeatherGui *self)
 178 {
 179         gboolean value = gtk_toggle_action_get_active(action);
 180         g_debug("AWeatherGui: on_offline - offline=%d", value);
 181         gis_prefs_set_boolean(self->prefs, "gis/offline", value);
 182         gis_viewer_set_offline(self->viewer, value);
 183 }
 184
 185 void on_initial_site_changed(GtkComboBox *combo, AWeatherGui *self)
 186 {
 187         gchar *site;
 188         GtkTreeIter iter;
 189         GtkTreeModel *model = gtk_combo_box_get_model(combo);
 190         gtk_combo_box_get_active_iter(combo, &iter);
 191         gtk_tree_model_get(model, &iter, 1, &site, -1);
 192         g_debug("AWeatherGui: on_initial_site_changed - site=%s", site);
 193         gis_prefs_set_string(self->prefs, "aweather/initial_site", site);
 194         g_free(site);
 195 }
 196
 197 void on_nexrad_url_changed(GtkEntry *entry, AWeatherGui *self)
 198 {
 199         const gchar *text = gtk_entry_get_text(entry);
 200         g_debug("AWeatherGui: on_nexrad_url_changed - url=%s", text);
 201         gis_prefs_set_string(self->prefs, "aweather/nexrad_url", text);
 202 }
 203
 204 int on_log_level_changed(GtkSpinButton *spinner, AWeatherGui *self)
 205 {
 206         gint value = gtk_spin_button_get_value_as_int(spinner);
 207         g_debug("AWeatherGui: on_log_level_changed - %p, level=%d", self, value);
 208         gis_prefs_set_integer(self->prefs, "aweather/log_level", value);
 209         return TRUE;
 210 }
 211
 212
 213 /*****************
 214  * Setup helpers *
 215  *****************/
 216 static void prefs_setup(AWeatherGui *self)
 217 {
 218         /* Set values */
 219         gchar *nu = gis_prefs_get_string (self->prefs, "aweather/nexrad_url",   NULL);
 220         gint   ll = gis_prefs_get_integer(self->prefs, "aweather/log_level",    NULL);
 221         gchar *is = gis_prefs_get_string (self->prefs, "aweather/initial_site", NULL);
 222         GtkWidget *nuw = aweather_gui_get_widget(self, "prefs_general_url");
 223         GtkWidget *llw = aweather_gui_get_widget(self, "prefs_general_log");
 224         GtkWidget *isw = aweather_gui_get_widget(self, "prefs_general_site");
 225         if (nu) gtk_entry_set_text(GTK_ENTRY(nuw), nu), g_free(nu);
 226         if (ll) gtk_spin_button_set_value(GTK_SPIN_BUTTON(llw), ll);
 227         if (is) {
 228                 GtkTreeModel *model = gtk_combo_box_get_model(GTK_COMBO_BOX(isw));
 229                 GtkTreeIter iter;
 230                 if (gtk_tree_model_find_string(model, &iter, NULL, 1, is))
 231                         gtk_combo_box_set_active_iter(GTK_COMBO_BOX(isw), &iter);
 232         }
 233
 234         /* Load Plugins */
 235         GtkTreeView       *tview = GTK_TREE_VIEW(aweather_gui_get_widget(self, "prefs_plugins_view"));
 236         GtkCellRenderer   *rend1 = gtk_cell_renderer_text_new();
 237         GtkCellRenderer   *rend2 = gtk_cell_renderer_toggle_new();
 238         GtkTreeViewColumn *col1  = gtk_tree_view_column_new_with_attributes(
 239                         "Plugin",  rend1, "text",   0, NULL);
 240         GtkTreeViewColumn *col2  = gtk_tree_view_column_new_with_attributes(
 241                         "Enabled", rend2, "active", 1, NULL);
 242         gtk_tree_view_append_column(tview, col1);
 243         gtk_tree_view_append_column(tview, col2);
 244         g_signal_connect(rend2, "toggled", G_CALLBACK(on_plugin_toggled), self);
 245         gtk_tree_view_set_model(GTK_TREE_VIEW(tview), GTK_TREE_MODEL(self->gtk_plugins));
 246 }
 247
 248 static void combo_sensitive(GtkCellLayout *cell_layout, GtkCellRenderer *cell,
 249                 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
 250 {
 251         gboolean sensitive = !gtk_tree_model_iter_has_child(tree_model, iter);
 252         g_object_set(cell, "sensitive", sensitive, NULL);
 253 }
 254
 255 static void site_setup(AWeatherGui *self)
 256 {
 257         GtkTreeIter state, city;
 258         GtkTreeStore *store = GTK_TREE_STORE(aweather_gui_get_object(self, "sites"));
 259         for (int i = 0; cities[i].label; i++) {
 260                 if (cities[i].type == LOCATION_STATE) {
 261                         gtk_tree_store_append(store, &state, NULL);
 262                         gtk_tree_store_set   (store, &state, 0, cities[i].label,
 263                                                              1, cities[i].code,  -1);
 264                 } else {
 265                         gtk_tree_store_append(store, &city, &state);
 266                         gtk_tree_store_set   (store, &city, 0, cities[i].label,
 267                                                             1, cities[i].code,  -1);
 268                 }
 269         }
 270
 271         GtkWidget *combo    = aweather_gui_get_widget(self, "main_site");
 272         GObject   *renderer = aweather_gui_get_object(self, "main_site_rend");
 273         gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(combo),
 274                         GTK_CELL_RENDERER(renderer), combo_sensitive, NULL, NULL);
 275 }
 276
 277 static void time_setup(AWeatherGui *self)
 278 {
 279         GtkTreeView       *tview = GTK_TREE_VIEW(aweather_gui_get_widget(self, "main_time"));
 280         GtkCellRenderer   *rend  = gtk_cell_renderer_text_new();
 281         GtkTreeViewColumn *col   = gtk_tree_view_column_new_with_attributes(
 282                                         "Time", rend, "text", 0, NULL);
 283
 284         gtk_tree_view_append_column(tview, col);
 285         g_object_set(rend, "size-points", 8.0, NULL);
 286
 287         g_signal_connect(self->viewer, "time-changed",
 288                         G_CALLBACK(update_time_widget), self);
 289 }
 290
 291
 292 /*************************
 293  * Deprecated site stuff *
 294  *************************/
 295 /* TODO: These update times functions are getting ugly... */
 296 static void update_times_gtk(AWeatherGui *self, GList *times)
 297 {
 298         gchar *last_time = NULL;
 299         GRegex *regex = g_regex_new("^[A-Z]{4}_([0-9]{8}_[0-9]{4})$", 0, 0, NULL); // KLSX_20090622_2113
 300         GMatchInfo *info;
 301
 302         GtkTreeView  *tview  = GTK_TREE_VIEW(aweather_gui_get_widget(self, "main_time"));
 303         GtkListStore *lstore = GTK_LIST_STORE(gtk_tree_view_get_model(tview));
 304         gtk_list_store_clear(lstore);
 305         GtkTreeIter iter;
 306         times = g_list_reverse(times);
 307         for (GList *cur = times; cur; cur = cur->next) {
 308                 if (g_regex_match(regex, cur->data, 0, &info)) {
 309                         gchar *time = g_match_info_fetch(info, 1);
 310                         gtk_list_store_insert(lstore, &iter, 0);
 311                         gtk_list_store_set(lstore, &iter, 0, time, -1);
 312                         last_time = time;
 313                 }
 314         }
 315
 316         gis_viewer_set_time(self->viewer, last_time);
 317
 318         g_regex_unref(regex);
 319         g_list_foreach(times, (GFunc)g_free, NULL);
 320         g_list_free(times);
 321 }
 322 static void update_times_online_cb(char *path, gboolean updated, gpointer _self)
 323 {
 324         GList *times = NULL;
 325         gchar *data;
 326         gsize length;
 327         g_file_get_contents(path, &data, &length, NULL);
 328         gchar **lines = g_strsplit(data, "\n", -1);
 329         for (int i = 0; lines[i] && lines[i][0]; i++) {
 330                 char **parts = g_strsplit(lines[i], " ", 2);
 331                 times = g_list_prepend(times, g_strdup(parts[1]));
 332                 g_strfreev(parts);
 333         }
 334         g_strfreev(lines);
 335         g_free(data);
 336
 337         update_times_gtk(_self, times);
 338 }
 339 static void update_times(AWeatherGui *self, GisViewer *viewer, char *site)
 340 {
 341         g_debug("AWeatherGui: update_times - site=%s", site);
 342         if (gis_viewer_get_offline(self->viewer)) {
 343                 GList *times = NULL;
 344                 gchar *path = g_build_filename(g_get_user_cache_dir(),
 345                                 "libgis", "nexrd2", "raw", site, NULL);
 346                 GDir *dir = g_dir_open(path, 0, NULL);
 347                 if (dir) {
 348                         const gchar *name;
 349                         while ((name = g_dir_read_name(dir))) {
 350                                 times = g_list_prepend(times, g_strdup(name));
 351                         }
 352                         g_dir_close(dir);
 353                 }
 354                 g_free(path);
 355                 update_times_gtk(self, times);
 356         } else {
 357                 gchar *path = g_strdup_printf("nexrd2/raw/%s/dir.list", site);
 358                 char *base = gis_prefs_get_string(self->prefs, "aweather/nexrad_url", NULL);
 359                 cache_file(base, path, GIS_REFRESH, NULL, update_times_online_cb, self);
 360                 /* update_times_gtk from update_times_online_cb */
 361         }
 362 }
 363 /* FIXME: This is redundent with the radar plugin
 364  *        Make a shared wsr88d file? */
 365 static void on_gis_location_changed(GisViewer *viewer,
 366                 gdouble lat, gdouble lon, gdouble elev,
 367                 gpointer _self)
 368 {
 369         AWeatherGui *self = AWEATHER_GUI(_self);
 370         gdouble min_dist = EARTH_R / 5;
 371         city_t *city, *min_city = NULL;
 372         for (city = cities; city->type; city++) {
 373                 if (city->type != LOCATION_CITY)
 374                         continue;
 375                 gdouble city_loc[3] = {};
 376                 gdouble eye_loc[3]  = {lat, lon, elev};
 377                 lle2xyz(city->lat, city->lon, city->elev,
 378                                 &city_loc[0], &city_loc[1], &city_loc[2]);
 379                 lle2xyz(lat, lon, elev,
 380                                 &eye_loc[0], &eye_loc[1], &eye_loc[2]);
 381                 gdouble dist = distd(city_loc, eye_loc);
 382                 if (dist < min_dist) {
 383                         min_dist = dist;
 384                         min_city = city;
 385                 }
 386         }
 387         static city_t *last_city = NULL;
 388         if (min_city && min_city != last_city) {
 389                 update_site_widget(self->viewer, min_city->code, self);
 390                 update_times(self, viewer, min_city->code);
 391         }
 392         last_city = min_city;
 393 }
 394 static void on_gis_refresh(GisViewer *viewer, gpointer _self)
 395 {
 396         AWeatherGui *self = AWEATHER_GUI(_self);
 397         gdouble lat, lon, elev;
 398         gis_viewer_get_location(self->viewer, &lat, &lon, &elev);
 399         /* Hack to update times */
 400         on_gis_location_changed(self->viewer, lat, lon, elev, self);
 401 }
 402
 403
 404 /***********
 405  * Methods *
 406  ***********/
 407 AWeatherGui *aweather_gui_new()
 408 {
 409         g_debug("AWeatherGui: new");
 410         return g_object_new(AWEATHER_TYPE_GUI, NULL);
 411 }
 412 GisViewer *aweather_gui_get_viewer(AWeatherGui *self)
 413 {
 414         g_assert(AWEATHER_IS_GUI(self));
 415         return self->viewer;
 416 }
 417 GtkBuilder *aweather_gui_get_builder(AWeatherGui *self)
 418 {
 419         g_debug("AWeatherGui: get_builder");
 420         g_assert(AWEATHER_IS_GUI(self));
 421         return self->builder;
 422 }
 423 GtkWidget *aweather_gui_get_widget(AWeatherGui *self, const gchar *name)
 424 {
 425         g_debug("AWeatherGui: get_widget - name=%s", name);
 426         g_assert(AWEATHER_IS_GUI(self));
 427         GObject *widget = gtk_builder_get_object(self->builder, name);
 428         if (!GTK_IS_WIDGET(widget))
 429                 g_error("Failed to get widget `%s'", name);
 430         return GTK_WIDGET(widget);
 431 }
 432 GObject *aweather_gui_get_object(AWeatherGui *self, const gchar *name)
 433 {
 434         g_debug("AWeatherGui: get_widget - name=%s", name);
 435         g_assert(AWEATHER_IS_GUI(self));
 436         return gtk_builder_get_object(self->builder, name);
 437 }
 438 void aweather_gui_attach_plugin(AWeatherGui *self, const gchar *name)
 439 {
 440         GisPlugin *plugin = gis_plugins_load(self->plugins, name,
 441                         self->viewer, self->prefs);
 442         GtkWidget *body = gis_plugin_get_config(plugin);
 443         if (body) {
 444                 GtkWidget *config = aweather_gui_get_widget(self, "main_tabs");
 445                 GtkWidget *tab    = gtk_label_new(name);
 446                 gtk_notebook_append_page(GTK_NOTEBOOK(config), body, tab);
 447                 gtk_widget_show_all(config);
 448         }
 449         gtk_widget_queue_draw(GTK_WIDGET(self->viewer));
 450 }
 451 void aweather_gui_deattach_plugin(AWeatherGui *self, const gchar *name)
 452 {
 453         GtkWidget *config = aweather_gui_get_widget(self, "main_tabs");
 454         guint n_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(config));
 455         for (int i = 0; i < n_pages; i++) {
 456                 g_debug("testing tab %d", i);
 457                 GtkWidget *body = gtk_notebook_get_nth_page(GTK_NOTEBOOK(config), i);
 458                 if (!body) continue;
 459                 GtkWidget *tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(config), body);
 460                 if (!tab) continue;
 461                 const gchar *tab_name = gtk_label_get_text(GTK_LABEL(tab));
 462                 if (tab_name && g_str_equal(name, tab_name))
 463                         gtk_notebook_remove_page(GTK_NOTEBOOK(config), i);
 464         }
 465         gis_plugins_unload(self->plugins, name);
 466         gtk_widget_queue_draw(GTK_WIDGET(self->viewer));
 467 }
 468
 469
 470 /****************
 471  * GObject code *
 472  ****************/
 473 G_DEFINE_TYPE(AWeatherGui, aweather_gui, GTK_TYPE_WINDOW);
 474 static void aweather_gui_init(AWeatherGui *self)
 475 {
 476         g_debug("AWeatherGui: init");
 477
 478         /* Simple things */
 479         gchar *config   = g_build_filename(g_get_user_config_dir(), PACKAGE, "config.ini", NULL);
 480         gchar *defaults = g_build_filename(PKGDATADIR, "defaults.ini", NULL);
 481         self->prefs   = gis_prefs_new(config, defaults);
 482         self->plugins = gis_plugins_new(PLUGINSDIR);
 483         self->viewer  = gis_opengl_new(self->plugins);
 484         g_free(config);
 485         g_free(defaults);
 486
 487         /* Setup window */
 488         self->builder = gtk_builder_new();
 489         GError *error = NULL;
 490         if (!gtk_builder_add_from_file(self->builder, PKGDATADIR "/main.ui", &error))
 491                 g_error("Failed to create gtk builder: %s", error->message);
 492         gtk_widget_reparent(aweather_gui_get_widget(self, "main_body"), GTK_WIDGET(self));
 493         GtkWidget *paned = aweather_gui_get_widget(self, "main_paned");
 494         gtk_widget_destroy(gtk_paned_get_child1(GTK_PANED(paned)));
 495         gtk_paned_pack1(GTK_PANED(paned), GTK_WIDGET(self->viewer), TRUE, FALSE);
 496
 497         /* Plugins */
 498         GtkTreeIter iter;
 499         self->gtk_plugins = GTK_LIST_STORE(aweather_gui_get_object(self, "plugins"));
 500         for (GList *cur = gis_plugins_available(self->plugins); cur; cur = cur->next) {
 501                 gchar *name = cur->data;
 502                 GError *error = NULL;
 503                 gboolean enabled = gis_prefs_get_boolean_v(self->prefs, cur->data, "enabled", &error);
 504                 if (error && error->code == G_KEY_FILE_ERROR_GROUP_NOT_FOUND)
 505                         enabled = TRUE;
 506                 gtk_list_store_append(self->gtk_plugins, &iter);
 507                 gtk_list_store_set(self->gtk_plugins, &iter, 0, name, 1, enabled, -1);
 508                 if (enabled)
 509                         aweather_gui_attach_plugin(self, name);
 510         }
 511
 512         /* Misc, helpers */
 513         site_setup(self);
 514         time_setup(self);
 515         prefs_setup(self);
 516
 517         /* Connect signals */
 518         gtk_builder_connect_signals(self->builder, self);
 519         g_signal_connect(self, "key-press-event",
 520                         G_CALLBACK(on_gui_key_press), self);
 521         g_signal_connect_swapped(self->viewer, "offline",
 522                         G_CALLBACK(gtk_toggle_action_set_active),
 523                         aweather_gui_get_object(self, "offline"));
 524
 525         /* deprecated site stuff */
 526         g_signal_connect(self->viewer, "location-changed",
 527                         G_CALLBACK(on_gis_location_changed), self);
 528         g_signal_connect(self->viewer, "refresh",
 529                         G_CALLBACK(on_gis_refresh), self);
 530 }
 531 static GObject *aweather_gui_constructor(GType gtype, guint n_properties,
 532                 GObjectConstructParam *properties)
 533 {
 534         g_debug("aweather_gui: constructor");
 535         GObjectClass *parent_class = G_OBJECT_CLASS(aweather_gui_parent_class);
 536         return parent_class->constructor(gtype, n_properties, properties);
 537 }
 538 static void aweather_gui_dispose(GObject *_self)
 539 {
 540         g_debug("AWeatherGui: dispose");
 541         AWeatherGui *self = AWEATHER_GUI(_self);
 542         if (self->builder) {
 543                 /* Reparent to avoid double unrefs */
 544                 GtkWidget *body   = aweather_gui_get_widget(self, "main_body");
 545                 GtkWidget *window = aweather_gui_get_widget(self, "main_window");
 546                 gtk_widget_reparent(body, window);
 547                 g_object_unref(self->builder);
 548                 self->builder = NULL;
 549         }
 550         if (self->viewer) {
 551                 g_object_unref(self->viewer);
 552                 self->viewer = NULL;
 553         }
 554         if (self->plugins) {
 555                 gis_plugins_free(self->plugins);
 556                 self->plugins = NULL;
 557         }
 558         if (self->prefs) {
 559                 g_object_unref(self->prefs);
 560                 self->prefs = NULL;
 561         }
 562         G_OBJECT_CLASS(aweather_gui_parent_class)->dispose(_self);
 563 }
 564 static void aweather_gui_finalize(GObject *_self)
 565 {
 566         g_debug("AWeatherGui: finalize");
 567         G_OBJECT_CLASS(aweather_gui_parent_class)->finalize(_self);
 568         gtk_main_quit();
 569
 570 }
 571 static void aweather_gui_class_init(AWeatherGuiClass *klass)
 572 {
 573         g_debug("AWeatherGui: class_init");
 574         GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 575         gobject_class->constructor  = aweather_gui_constructor;
 576         gobject_class->dispose      = aweather_gui_dispose;
 577         gobject_class->finalize     = aweather_gui_finalize;
 578 }