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