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(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         aweather_gui_gl_end(gui);
 222         aweather_gui_gl_flush(gui);
 223         g_message("aweather:expose - end\n");
 224         return FALSE;
 225 }
 226
 227 void on_about(GtkMenuItem *item, AWeatherGui *gui)
 228 {
 229         GError *error = NULL;
 230         GtkBuilder *builder = gtk_builder_new();
 231         if (!gtk_builder_add_from_file(builder, DATADIR "/aweather/about.xml", &error))
 232                 g_error("Failed to create gtk builder: %s", error->message);
 233         gtk_builder_connect_signals(builder, NULL);
 234         GtkWidget *window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
 235         gtk_window_set_transient_for(GTK_WINDOW(window),
 236                         GTK_WINDOW(aweather_gui_get_widget(gui, "window")));
 237         gtk_widget_show_all(window);
 238         g_object_unref(builder);
 239 }
 240
 241 void on_location_changed(AWeatherView *view,
 242                 gdouble x, gdouble y, gdouble z, AWeatherGui *gui)
 243 {
 244         /* Reset clipping area and redraw */
 245         GtkWidget *da = aweather_gui_get_widget(gui, "drawing");
 246         on_configure(da, NULL, gui);
 247         aweather_gui_gl_redraw(gui);
 248 }
 249
 250 /* TODO: replace the code in these with `gtk_tree_model_find' utility */
 251 static void update_time_widget(AWeatherView *view, char *time, AWeatherGui *gui)
 252 {
 253         g_message("updating time widget");
 254         GtkTreeView  *tview = GTK_TREE_VIEW(aweather_gui_get_widget(gui, "time"));
 255         GtkTreeModel *model = GTK_TREE_MODEL(gtk_tree_view_get_model(tview));
 256         for (int i = 0; i < gtk_tree_model_iter_n_children(model, NULL); i++) {
 257                 char *text;
 258                 GtkTreeIter iter;
 259                 gtk_tree_model_iter_nth_child(model, &iter, NULL, i);
 260                 gtk_tree_model_get(model, &iter, 0, &text, -1);
 261                 if (g_str_equal(text, time)) {
 262                         GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
 263                         g_signal_handlers_block_by_func(tview,
 264                                         G_CALLBACK(on_site_changed), gui);
 265                         gtk_tree_view_set_cursor(tview, path, NULL, FALSE);
 266                         g_signal_handlers_unblock_by_func(tview,
 267                                         G_CALLBACK(on_site_changed), gui);
 268                         gtk_tree_path_free(path);
 269                         g_free(text);
 270                         return;
 271                 }
 272                 g_free(text);
 273         }
 274 }
 275 static void update_site_widget(AWeatherView *view, char *site, AWeatherGui *gui)
 276 {
 277         g_message("updating site widget to %s", site);
 278         GtkComboBox  *combo = GTK_COMBO_BOX(aweather_gui_get_widget(gui, "site"));
 279         GtkTreeModel *model = GTK_TREE_MODEL(gtk_combo_box_get_model(combo));
 280         for (int i = 0; i < gtk_tree_model_iter_n_children(model, NULL); i++) {
 281                 GtkTreeIter iter1;
 282                 gtk_tree_model_iter_nth_child(model, &iter1, NULL, i);
 283                 for (int i = 0; i < gtk_tree_model_iter_n_children(model, &iter1); i++) {
 284                         GtkTreeIter iter2;
 285                         gtk_tree_model_iter_nth_child(model, &iter2, &iter1, i);
 286                         char *text;
 287                         gtk_tree_model_get(model, &iter2, 1, &text, -1);
 288                         if (g_str_equal(text, site)) {
 289                                 g_signal_handlers_block_by_func(combo,
 290                                                 G_CALLBACK(on_site_changed), gui);
 291                                 gtk_combo_box_set_active_iter(combo, &iter2);
 292                                 g_signal_handlers_unblock_by_func(combo,
 293                                                 G_CALLBACK(on_site_changed), gui);
 294                                 g_free(text);
 295                                 return;
 296                         }
 297                         g_free(text);
 298                 }
 299         }
 300 }
 301
 302 /*****************
 303  * Setup helpers *
 304  *****************/
 305 static void combo_sensitive(GtkCellLayout *cell_layout, GtkCellRenderer *cell,
 306                 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
 307 {
 308         gboolean sensitive = !gtk_tree_model_iter_has_child(tree_model, iter);
 309         g_object_set(cell, "sensitive", sensitive, NULL);
 310 }
 311
 312 static void site_setup(AWeatherGui *gui)
 313 {
 314         GtkTreeIter state, city;
 315         GtkTreeStore *store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
 316         for (int i = 0; cities[i].label; i++) {
 317                 if (cities[i].type == LOCATION_STATE) {
 318                         gtk_tree_store_append(store, &state, NULL);
 319                         gtk_tree_store_set   (store, &state, 0, cities[i].label,
 320                                                              1, cities[i].code,  -1);
 321                 } else {
 322                         gtk_tree_store_append(store, &city, &state);
 323                         gtk_tree_store_set   (store, &city, 0, cities[i].label,
 324                                                             1, cities[i].code,  -1);
 325                 }
 326         }
 327
 328         GtkWidget       *combo    = aweather_gui_get_widget(gui, "site");
 329         GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
 330         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, FALSE);
 331         gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "text", 0, NULL);
 332         gtk_combo_box_set_model(GTK_COMBO_BOX(combo), GTK_TREE_MODEL(store));
 333         gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(combo), renderer,
 334                         combo_sensitive, NULL, NULL);
 335         g_object_unref(renderer);
 336         g_object_unref(store);
 337
 338         AWeatherView *aview = aweather_gui_get_view(gui);
 339         g_signal_connect(aview, "site-changed", G_CALLBACK(update_site_widget), gui);
 340 }
 341
 342 static void time_setup(AWeatherGui *gui)
 343 {
 344         GtkTreeView  *tview  = GTK_TREE_VIEW(aweather_gui_get_widget(gui, "time"));
 345         GtkTreeModel *store  = GTK_TREE_MODEL(gtk_list_store_new(1, G_TYPE_STRING));
 346         gtk_tree_view_set_model(tview, store);
 347
 348         GtkCellRenderer   *rend = gtk_cell_renderer_text_new();
 349         GtkTreeViewColumn *col  = gtk_tree_view_column_new_with_attributes(
 350                                         "Time", rend, "text", 0, NULL);
 351         gtk_tree_view_append_column(tview, col);
 352
 353         AWeatherView *aview = aweather_gui_get_view(gui);
 354         g_signal_connect(aview, "time-changed", G_CALLBACK(update_time_widget), gui);
 355 }
 356
 357 static void opengl_setup(AWeatherGui *gui)
 358 {
 359         GtkDrawingArea *drawing = GTK_DRAWING_AREA(aweather_gui_get_widget(gui, "drawing"));
 360
 361         GdkGLConfig *glconfig = gdk_gl_config_new_by_mode(
 362                         GDK_GL_MODE_RGBA   | GDK_GL_MODE_DEPTH |
 363                         GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA);
 364         if (!glconfig)
 365                 g_error("Failed to create glconfig");
 366         if (!gtk_widget_set_gl_capability(GTK_WIDGET(drawing),
 367                                 glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
 368                 g_error("GL lacks required capabilities");
 369
 370         /* Set up OpenGL Stuff, glade doesn't like doing these */
 371         g_signal_connect(drawing, "map-event",       G_CALLBACK(on_map),       gui);
 372         g_signal_connect(drawing, "configure-event", G_CALLBACK(on_configure), gui);
 373         g_signal_connect(drawing, "expose-event",    G_CALLBACK(on_expose),    gui);
 374 }
 375
 376
 377
 378 /***********
 379  * Methods *
 380  ***********/
 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, -300*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_register_plugin(AWeatherGui *gui, AWeatherPlugin *plugin)
 425 {
 426         g_message("registering plugin");
 427         gui->plugins = g_list_append(gui->plugins, plugin);
 428 }
 429 void aweather_gui_gl_redraw(AWeatherGui *gui)
 430 {
 431         g_message("redraw");
 432         GtkWidget *drawing = aweather_gui_get_widget(gui, "drawing");
 433         gtk_widget_queue_draw(drawing);
 434 }
 435 void aweather_gui_gl_begin(AWeatherGui *gui)
 436 {
 437         g_assert(AWEATHER_IS_GUI(gui));
 438
 439         GtkDrawingArea *drawing    = GTK_DRAWING_AREA(aweather_gui_get_widget(gui, "drawing"));
 440         GdkGLContext   *glcontext  = gtk_widget_get_gl_context(GTK_WIDGET(drawing));
 441         GdkGLDrawable  *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(drawing));
 442
 443         if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
 444                 g_assert_not_reached();
 445
 446         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 447 }
 448 void aweather_gui_gl_end(AWeatherGui *gui)
 449 {
 450         g_assert(AWEATHER_IS_GUI(gui));
 451         GdkGLDrawable *gldrawable = gdk_gl_drawable_get_current();
 452         gdk_gl_drawable_gl_end(gldrawable);
 453 }
 454 void aweather_gui_gl_flush(AWeatherGui *gui)
 455 {
 456         g_assert(AWEATHER_IS_GUI(gui));
 457         GdkGLDrawable *gldrawable = gdk_gl_drawable_get_current();
 458         if (gdk_gl_drawable_is_double_buffered(gldrawable))
 459                 gdk_gl_drawable_swap_buffers(gldrawable);
 460         else
 461                 glFlush();
 462         gdk_gl_drawable_gl_end(gldrawable);
 463 }