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 <gtk/gtkgl.h>
  21 #include <gdk/gdkkeysyms.h>
  22 #include <GL/gl.h>
  23 #include <GL/glu.h>
  24 #include <math.h>
  25
  26 #include "aweather-gui.h"
  27 #include "aweather-view.h"
  28 #include "aweather-plugin.h"
  29 #include "location.h"
  30
  31 /****************
  32  * GObject code *
  33  ****************/
  34 G_DEFINE_TYPE(AWeatherGui, aweather_gui, GTK_TYPE_WINDOW);
  35 static void aweather_gui_init(AWeatherGui *gui)
  36 {
  37         gui->plugins = NULL;
  38         g_debug("AWeatherGui: init");
  39 }
  40 static GObject *aweather_gui_constructor(GType gtype, guint n_properties,
  41                 GObjectConstructParam *properties)
  42 {
  43         g_debug("aweather_gui: constructor");
  44         GObjectClass *parent_class = G_OBJECT_CLASS(aweather_gui_parent_class);
  45         return  parent_class->constructor(gtype, n_properties, properties);
  46 }
  47 static void aweather_gui_dispose(GObject *gobject)
  48 {
  49         g_debug("AWeatherGui: dispose");
  50         AWeatherGui *gui = AWEATHER_GUI(gobject);
  51         if (gui->view) {
  52                 g_object_unref(gui->view);
  53                 gui->view = NULL;
  54         }
  55         if (gui->builder) {
  56                 /* Reparent to avoid double unrefs */
  57                 GtkWidget *body   = aweather_gui_get_widget(gui, "body");
  58                 GtkWidget *window = aweather_gui_get_widget(gui, "window");
  59                 gtk_widget_reparent(body, window);
  60                 g_object_unref(gui->builder);
  61                 gui->builder = NULL;
  62         }
  63         if (gui->plugins) {
  64                 g_list_foreach(gui->plugins, (GFunc)g_object_unref, NULL);
  65                 g_list_free(gui->plugins);
  66                 gui->plugins = NULL;
  67         }
  68         //for (GList *cur = gui->plugins; cur; cur = cur->next)
  69         //      g_object_unref(cur->data);
  70         G_OBJECT_CLASS(aweather_gui_parent_class)->dispose(gobject);
  71 }
  72 static void aweather_gui_finalize(GObject *gobject)
  73 {
  74         g_debug("AWeatherGui: finalize");
  75         G_OBJECT_CLASS(aweather_gui_parent_class)->finalize(gobject);
  76         gtk_main_quit();
  77
  78 }
  79 static void aweather_gui_class_init(AWeatherGuiClass *klass)
  80 {
  81         g_debug("AWeatherGui: class_init");
  82         GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
  83         gobject_class->constructor  = aweather_gui_constructor;
  84         gobject_class->dispose      = aweather_gui_dispose;
  85         gobject_class->finalize     = aweather_gui_finalize;
  86 }
  87
  88 /*************
  89  * Callbacks *
  90  *************/
  91 void on_quit(GtkMenuItem *menu, AWeatherGui *gui)
  92 {
  93         gtk_widget_destroy(GTK_WIDGET(gui));
  94 }
  95 gboolean on_drawing_button_press(GtkWidget *widget, GdkEventButton *event, AWeatherGui *gui)
  96 {
  97         g_debug("AWeatherGui: on_drawing_button_press - Grabbing focus");
  98         GtkWidget *drawing = aweather_gui_get_widget(gui, "drawing");
  99         gtk_widget_grab_focus(drawing);
 100         return TRUE;
 101 }
 102 gboolean on_drawing_key_press(GtkWidget *widget, GdkEventKey *event, AWeatherGui *gui)
 103 {
 104         g_debug("AWeatherGui: on_drawing_key_press - key=%x, state=%x",
 105                         event->keyval, event->state);
 106         AWeatherView *view = aweather_gui_get_view(gui);
 107         double x,y,z;
 108         aweather_view_get_location(view, &x, &y, &z);
 109         guint kv = event->keyval;
 110         if      (kv == GDK_Right || kv == GDK_l) aweather_view_pan(view,  z/10, 0, 0);
 111         else if (kv == GDK_Left  || kv == GDK_h) aweather_view_pan(view, -z/10, 0, 0);
 112         else if (kv == GDK_Up    || kv == GDK_k) aweather_view_pan(view, 0,  z/10, 0);
 113         else if (kv == GDK_Down  || kv == GDK_j) aweather_view_pan(view, 0, -z/10, 0);
 114         else if (kv == GDK_minus || kv == GDK_o) aweather_view_zoom(view, 10./9);
 115         else if (kv == GDK_plus  || kv == GDK_i) aweather_view_zoom(view, 9./10);
 116         return TRUE;
 117 }
 118
 119 gboolean on_gui_key_press(GtkWidget *widget, GdkEventKey *event, AWeatherGui *gui)
 120 {
 121         g_debug("AWeatherGui: on_gui_key_press - key=%x, state=%x",
 122                         event->keyval, event->state);
 123         AWeatherView *view = aweather_gui_get_view(gui);
 124         if (event->keyval == GDK_q)
 125                 gtk_widget_destroy(GTK_WIDGET(gui));
 126         else if (event->keyval == GDK_r && event->state & GDK_CONTROL_MASK)
 127                 aweather_view_refresh(view);
 128         else if (event->keyval == GDK_Tab || event->keyval == GDK_ISO_Left_Tab) {
 129                 GtkNotebook *tabs = GTK_NOTEBOOK(aweather_gui_get_widget(gui, "tabs"));
 130                 gint num_tabs = gtk_notebook_get_n_pages(tabs);
 131                 gint cur_tab  = gtk_notebook_get_current_page(tabs);
 132                 if (event->state & GDK_SHIFT_MASK)
 133                         gtk_notebook_set_current_page(tabs, (cur_tab-1)%num_tabs);
 134                 else
 135                         gtk_notebook_set_current_page(tabs, (cur_tab+1)%num_tabs);
 136         };
 137         return FALSE;
 138 }
 139
 140 void on_refresh(GtkToolButton *button, AWeatherGui *gui)
 141 {
 142         AWeatherView *view = aweather_gui_get_view(gui);
 143         aweather_view_refresh(view);
 144 }
 145
 146 void on_zoomin(GtkToolButton *button, AWeatherGui *gui)
 147 {
 148         AWeatherView *view = aweather_gui_get_view(gui);
 149         aweather_view_zoom(view, 3./4);
 150 }
 151
 152 void on_zoomout(GtkToolButton *button, AWeatherGui *gui)
 153 {
 154         AWeatherView *view = aweather_gui_get_view(gui);
 155         aweather_view_zoom(view, 4./3);
 156 }
 157
 158 void on_time_changed(GtkTreeView *view, GtkTreePath *path,
 159                 GtkTreeViewColumn *column, AWeatherGui *gui)
 160 {
 161         gchar *time;
 162         GtkTreeIter iter;
 163         GtkTreeModel *model = gtk_tree_view_get_model(view);
 164         gtk_tree_model_get_iter(model, &iter, path);
 165         gtk_tree_model_get(model, &iter, 0, &time, -1);
 166         AWeatherView *aview = aweather_gui_get_view(gui);
 167         aweather_view_set_time(aview, time);
 168         g_free(time);
 169 }
 170
 171 void on_site_changed(GtkComboBox *combo, AWeatherGui *gui)
 172 {
 173         gchar *site;
 174         GtkTreeIter iter;
 175         GtkTreeModel *model = gtk_combo_box_get_model(combo);
 176         gtk_combo_box_get_active_iter(combo, &iter);
 177         gtk_tree_model_get(model, &iter, 1, &site, -1);
 178         AWeatherView *view = aweather_gui_get_view(gui);
 179         aweather_view_set_site(view, site);
 180         g_free(site);
 181 }
 182
 183 gboolean on_map(GtkWidget *da, GdkEventConfigure *event, AWeatherGui *gui)
 184 {
 185         g_debug("AWeatherGui: on_map");
 186         AWeatherView *view = aweather_gui_get_view(gui);
 187
 188         /* Misc */
 189         glEnable(GL_BLEND);
 190         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 191         glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 192
 193         /* Tessellation, "finding intersecting triangles" */
 194         /* http://research.microsoft.com/pubs/70307/tr-2006-81.pdf */
 195         /* http://www.opengl.org/wiki/Alpha_Blending */
 196         glAlphaFunc(GL_GREATER,0.1);
 197         glEnable(GL_ALPHA_TEST);
 198
 199         /* Depth test */
 200         glClearDepth(1.0);
 201         glDepthFunc(GL_LEQUAL);
 202         glEnable(GL_DEPTH_TEST);
 203
 204         aweather_gui_gl_end(gui);
 205         return FALSE;
 206 }
 207
 208 gboolean on_configure(GtkWidget *da, GdkEventConfigure *event, AWeatherGui *gui)
 209 {
 210         g_debug("AWeatherGui: on_confiure");
 211         aweather_gui_gl_begin(gui);
 212
 213         double x, y, z;
 214         AWeatherView *view = aweather_gui_get_view(gui);
 215         aweather_view_get_location(view, &x, &y, &z);
 216
 217         /* Window is at 500 m from camera */
 218         double width  = da->allocation.width;
 219         double height = da->allocation.height;
 220
 221         glViewport(0, 0, width, height);
 222
 223         /* Perspective */
 224         glMatrixMode(GL_PROJECTION);
 225         glLoadIdentity();
 226         double rad  = atan((height/2)/500);
 227         double deg  = (rad*180)/M_PI;
 228
 229         gluPerspective(deg*2, width/height, -z-20, -z+20);
 230         //gluPerspective(deg*2, width/height, 1, 500*1000);
 231
 232         aweather_gui_gl_end(gui);
 233         return FALSE;
 234 }
 235
 236 gboolean on_expose(GtkWidget *da, GdkEventExpose *event, AWeatherGui *gui)
 237 {
 238         g_debug("AWeatherGui: on_expose - begin");
 239         aweather_gui_gl_begin(gui);
 240
 241         double x, y, z;
 242         AWeatherView *view = aweather_gui_get_view(gui);
 243         aweather_view_get_location(view, &x, &y, &z);
 244
 245         glMatrixMode(GL_MODELVIEW);
 246         glLoadIdentity();
 247         glTranslatef(x, y, z);
 248
 249         //glRotatef(-45, 1, 0, 0);
 250
 251         /* Expose plugins */
 252         for (GList *cur = gui->plugins; cur; cur = cur->next) {
 253                 AWeatherPlugin *plugin = AWEATHER_PLUGIN(cur->data);
 254                 aweather_plugin_expose(plugin);
 255         }
 256
 257         aweather_gui_gl_end(gui);
 258         aweather_gui_gl_flush(gui);
 259         g_debug("AWeatherGui: on_expose - end\n");
 260         return FALSE;
 261 }
 262
 263 void on_about(GtkMenuItem *item, AWeatherGui *gui)
 264 {
 265         // TODO: use gtk_widget_hide_on_delete()
 266         GError *error = NULL;
 267         GtkBuilder *builder = gtk_builder_new();
 268         if (!gtk_builder_add_from_file(builder, DATADIR "/aweather/about.xml", &error))
 269                 g_error("Failed to create gtk builder: %s", error->message);
 270         gtk_builder_connect_signals(builder, NULL);
 271         GtkWidget *window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
 272         gtk_window_set_transient_for(GTK_WINDOW(window),
 273                         GTK_WINDOW(aweather_gui_get_widget(gui, "window")));
 274         gtk_widget_show_all(window);
 275         g_object_unref(builder);
 276 }
 277
 278 void on_location_changed(AWeatherView *view,
 279                 gdouble x, gdouble y, gdouble z, AWeatherGui *gui)
 280 {
 281         /* Reset clipping area and redraw */
 282         GtkWidget *da = aweather_gui_get_widget(gui, "drawing");
 283         on_configure(da, NULL, gui);
 284         aweather_gui_gl_redraw(gui);
 285 }
 286
 287 /* TODO: replace the code in these with `gtk_tree_model_find' utility */
 288 static void update_time_widget(AWeatherView *view, char *time, AWeatherGui *gui)
 289 {
 290         g_debug("AWeatherGui: update_time_widget");
 291         GtkTreeView  *tview = GTK_TREE_VIEW(aweather_gui_get_widget(gui, "time"));
 292         GtkTreeModel *model = GTK_TREE_MODEL(gtk_tree_view_get_model(tview));
 293         for (int i = 0; i < gtk_tree_model_iter_n_children(model, NULL); i++) {
 294                 char *text;
 295                 GtkTreeIter iter;
 296                 gtk_tree_model_iter_nth_child(model, &iter, NULL, i);
 297                 gtk_tree_model_get(model, &iter, 0, &text, -1);
 298                 if (g_str_equal(text, time)) {
 299                         GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
 300                         g_signal_handlers_block_by_func(tview,
 301                                         G_CALLBACK(on_site_changed), gui);
 302                         gtk_tree_view_set_cursor(tview, path, NULL, FALSE);
 303                         g_signal_handlers_unblock_by_func(tview,
 304                                         G_CALLBACK(on_site_changed), gui);
 305                         gtk_tree_path_free(path);
 306                         g_free(text);
 307                         return;
 308                 }
 309                 g_free(text);
 310         }
 311 }
 312 static void update_site_widget(AWeatherView *view, char *site, AWeatherGui *gui)
 313 {
 314         g_debug("AWeatherGui: updat_site_widget - site=%s", site);
 315         GtkComboBox  *combo = GTK_COMBO_BOX(aweather_gui_get_widget(gui, "site"));
 316         GtkTreeModel *model = GTK_TREE_MODEL(gtk_combo_box_get_model(combo));
 317         for (int i = 0; i < gtk_tree_model_iter_n_children(model, NULL); i++) {
 318                 GtkTreeIter iter1;
 319                 gtk_tree_model_iter_nth_child(model, &iter1, NULL, i);
 320                 for (int i = 0; i < gtk_tree_model_iter_n_children(model, &iter1); i++) {
 321                         GtkTreeIter iter2;
 322                         gtk_tree_model_iter_nth_child(model, &iter2, &iter1, i);
 323                         char *text;
 324                         gtk_tree_model_get(model, &iter2, 1, &text, -1);
 325                         if (g_str_equal(text, site)) {
 326                                 g_signal_handlers_block_by_func(combo,
 327                                                 G_CALLBACK(on_site_changed), gui);
 328                                 gtk_combo_box_set_active_iter(combo, &iter2);
 329                                 g_signal_handlers_unblock_by_func(combo,
 330                                                 G_CALLBACK(on_site_changed), gui);
 331                                 g_free(text);
 332                                 return;
 333                         }
 334                         g_free(text);
 335                 }
 336         }
 337 }
 338
 339 /*****************
 340  * Setup helpers *
 341  *****************/
 342 static void combo_sensitive(GtkCellLayout *cell_layout, GtkCellRenderer *cell,
 343                 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
 344 {
 345         gboolean sensitive = !gtk_tree_model_iter_has_child(tree_model, iter);
 346         g_object_set(cell, "sensitive", sensitive, NULL);
 347 }
 348
 349 static void site_setup(AWeatherGui *gui)
 350 {
 351         GtkTreeIter state, city;
 352         GtkTreeStore *store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
 353         for (int i = 0; cities[i].label; i++) {
 354                 if (cities[i].type == LOCATION_STATE) {
 355                         gtk_tree_store_append(store, &state, NULL);
 356                         gtk_tree_store_set   (store, &state, 0, cities[i].label,
 357                                                              1, cities[i].code,  -1);
 358                 } else {
 359                         gtk_tree_store_append(store, &city, &state);
 360                         gtk_tree_store_set   (store, &city, 0, cities[i].label,
 361                                                             1, cities[i].code,  -1);
 362                 }
 363         }
 364
 365         GtkWidget       *combo    = aweather_gui_get_widget(gui, "site");
 366         GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
 367         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, FALSE);
 368         gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "text", 0, NULL);
 369         gtk_combo_box_set_model(GTK_COMBO_BOX(combo), GTK_TREE_MODEL(store));
 370         gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(combo), renderer,
 371                         combo_sensitive, NULL, NULL);
 372         g_object_unref(renderer);
 373         g_object_unref(store);
 374
 375         AWeatherView *aview = aweather_gui_get_view(gui);
 376         g_signal_connect(aview, "site-changed", G_CALLBACK(update_site_widget), gui);
 377 }
 378
 379 static void time_setup(AWeatherGui *gui)
 380 {
 381         GtkTreeView  *tview  = GTK_TREE_VIEW(aweather_gui_get_widget(gui, "time"));
 382         GtkTreeModel *store  = GTK_TREE_MODEL(gtk_list_store_new(1, G_TYPE_STRING));
 383         gtk_tree_view_set_model(tview, store);
 384
 385         GtkCellRenderer   *rend = gtk_cell_renderer_text_new();
 386         GtkTreeViewColumn *col  = gtk_tree_view_column_new_with_attributes(
 387                                         "Time", rend, "text", 0, NULL);
 388         gtk_tree_view_append_column(tview, col);
 389
 390         AWeatherView *aview = aweather_gui_get_view(gui);
 391         g_signal_connect(aview, "time-changed", G_CALLBACK(update_time_widget), gui);
 392 }
 393
 394 static void opengl_setup(AWeatherGui *gui)
 395 {
 396         GtkDrawingArea *drawing = GTK_DRAWING_AREA(aweather_gui_get_widget(gui, "drawing"));
 397
 398         GdkGLConfig *glconfig = gdk_gl_config_new_by_mode(
 399                         GDK_GL_MODE_RGBA   | GDK_GL_MODE_DEPTH |
 400                         GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA);
 401         if (!glconfig)
 402                 g_error("Failed to create glconfig");
 403         if (!gtk_widget_set_gl_capability(GTK_WIDGET(drawing),
 404                                 glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
 405                 g_error("GL lacks required capabilities");
 406
 407         /* Set up OpenGL Stuff, glade doesn't like doing these */
 408         g_signal_connect(drawing, "map-event",       G_CALLBACK(on_map),       gui);
 409         g_signal_connect(drawing, "configure-event", G_CALLBACK(on_configure), gui);
 410         g_signal_connect(drawing, "expose-event",    G_CALLBACK(on_expose),    gui);
 411 }
 412
 413
 414
 415 /***********
 416  * Methods *
 417  ***********/
 418 AWeatherGui *aweather_gui_new()
 419 {
 420         g_debug("AWeatherGui: new");
 421         GError *error = NULL;
 422
 423         AWeatherGui *self = g_object_new(AWEATHER_TYPE_GUI, NULL);
 424         self->view    = aweather_view_new();
 425         self->builder = gtk_builder_new();
 426
 427         if (!gtk_builder_add_from_file(self->builder, DATADIR "/aweather/main.xml", &error))
 428                 g_error("Failed to create gtk builder: %s", error->message);
 429         gtk_builder_connect_signals(self->builder, self);
 430         g_signal_connect(self, "key-press-event", G_CALLBACK(on_gui_key_press), self);
 431         gtk_widget_reparent(aweather_gui_get_widget(self, "body"), GTK_WIDGET(self));
 432
 433         /* Load components */
 434         aweather_view_set_location(self->view, 0, 0, -300*1000);
 435         g_signal_connect(self->view, "location-changed", G_CALLBACK(on_location_changed), self);
 436         site_setup(self);
 437         time_setup(self);
 438         opengl_setup(self);
 439         return self;
 440 }
 441 AWeatherView *aweather_gui_get_view(AWeatherGui *gui)
 442 {
 443         g_assert(AWEATHER_IS_GUI(gui));
 444         return gui->view;
 445 }
 446 GtkBuilder *aweather_gui_get_builder(AWeatherGui *gui)
 447 {
 448         g_debug("AWeatherGui: get_builder");
 449         g_assert(AWEATHER_IS_GUI(gui));
 450         return gui->builder;
 451 }
 452 GtkWidget *aweather_gui_get_widget(AWeatherGui *gui, const gchar *name)
 453 {
 454         g_debug("AWeatherGui: get_widget - name=%s", name);
 455         g_assert(AWEATHER_IS_GUI(gui));
 456         GObject *widget = gtk_builder_get_object(gui->builder, name);
 457         if (!GTK_IS_WIDGET(widget))
 458                 g_error("Failed to get widget `%s'", name);
 459         return GTK_WIDGET(widget);
 460 }
 461 void aweather_gui_register_plugin(AWeatherGui *gui, AWeatherPlugin *plugin)
 462 {
 463         g_debug("AWeatherGui: register_plugin");
 464         gui->plugins = g_list_append(gui->plugins, plugin);
 465 }
 466 void aweather_gui_gl_redraw(AWeatherGui *gui)
 467 {
 468         g_debug("AWeatherGui: gl_redraw");
 469         GtkWidget *drawing = aweather_gui_get_widget(gui, "drawing");
 470         gtk_widget_queue_draw(drawing);
 471 }
 472 void aweather_gui_gl_begin(AWeatherGui *gui)
 473 {
 474         g_assert(AWEATHER_IS_GUI(gui));
 475
 476         GtkDrawingArea *drawing    = GTK_DRAWING_AREA(aweather_gui_get_widget(gui, "drawing"));
 477         GdkGLContext   *glcontext  = gtk_widget_get_gl_context(GTK_WIDGET(drawing));
 478         GdkGLDrawable  *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(drawing));
 479
 480         if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
 481                 g_assert_not_reached();
 482
 483         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 484 }
 485 void aweather_gui_gl_end(AWeatherGui *gui)
 486 {
 487         g_assert(AWEATHER_IS_GUI(gui));
 488         GdkGLDrawable *gldrawable = gdk_gl_drawable_get_current();
 489         gdk_gl_drawable_gl_end(gldrawable);
 490 }
 491 void aweather_gui_gl_flush(AWeatherGui *gui)
 492 {
 493         g_assert(AWEATHER_IS_GUI(gui));
 494         GdkGLDrawable *gldrawable = gdk_gl_drawable_get_current();
 495         if (gdk_gl_drawable_is_double_buffered(gldrawable))
 496                 gdk_gl_drawable_swap_buffers(gldrawable);
 497         else
 498                 glFlush();
 499         gdk_gl_drawable_gl_end(gldrawable);
 500 }