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