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