src/gl_widget.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  15  *
  16  * See the COPYING file for license information.
  17  *
  18  * Guillaume Chazarain <guichaz@gmail.com>
  19  */
  20
  21 /***********************************************
  22  * Creation and callbacks of the OpenGL widget *
  23  ***********************************************/
  24
  25 #include <GL/glu.h>
  26 #include "opengl.h"
  27
  28 #include "gliv.h"
  29 #include "gl_widget.h"
  30 #include "options.h"
  31 #include "rendering.h"
  32 #include "messages.h"
  33 #include "windows.h"
  34 #include "matrix.h"
  35 #include "files_list.h"
  36 #include "main.h"
  37 #include "next_image.h"
  38 #include "images_menus.h"
  39 #include "cursors.h"
  40
  41 extern GtkWidget *gl_widget;
  42 extern rt_struct *rt;
  43 extern options_struct *options;
  44
  45 static gint old_width, old_height;
  46
  47 enum {
  48     TARGET_URI_LIST,
  49     TARGET_STRING
  50 };
  51
  52 void update_bg_color()
  53 {
  54     glClearColor(options->bg_col.red / 65535.0, options->bg_col.green / 65535.0,
  55                  options->bg_col.blue / 65535.0, 1.0);
  56 }
  57
  58 static gboolean expose_event(GtkWidget * unused, GdkEventExpose * event)
  59 {
  60     if (event->count == 0)
  61         refresh(REFRESH_IMAGE);
  62
  63     return FALSE;
  64 }
  65
  66 static void resize_widget(gint width, gint height)
  67 {
  68     gfloat w2, h2;
  69
  70     width += width % 2;
  71     height += height % 2;
  72
  73     w2 = width / 2.0;
  74     h2 = height / 2.0;
  75
  76     gdk_gl_drawable_wait_gdk(gtk_widget_get_gl_drawable(gl_widget));
  77
  78     glViewport(0, 0, width, height);
  79     glMatrixMode(GL_PROJECTION);
  80     glLoadIdentity();
  81
  82     /* Vertical flip to have coordinates like X but centered like OpenGL. */
  83     glOrtho(-w2, w2, h2, -h2, -1.0, 1.0);
  84
  85     glMatrixMode(GL_MODELVIEW);
  86 }
  87
  88 static gboolean configure_event(GtkWidget * unused, GdkEventConfigure * event)
  89 {
  90     gint what = REFRESH_IMAGE;
  91
  92     resize_widget(event->width, event->height);
  93
  94     if ((options->maximize || options->scaledown) &&
  95         matrix_set_max_zoom(old_width, old_height, FALSE) == FALSE) {
  96         /*
  97          * When options->maximize or options->scaledown is set we zoom only
  98          * if a matrix_set_max_zoom() with previous dimensions would have been
  99          * ignored.  It happens if the image properties didn't change after the
 100          * previous matrix_set_max_zoom().
 101          * This is achieved by the test of matrix_set_max_zoom().
 102          */
 103         matrix_set_max_zoom(event->width, event->height, TRUE);
 104         what |= REFRESH_STATUS;
 105     }
 106
 107     refresh(what);
 108
 109     old_width = event->width;
 110     old_height = event->height;
 111
 112     return FALSE;
 113 }
 114
 115 static gboolean drag_data_received(GtkWidget * unused1,
 116                                    GdkDragContext * context,
 117                                    gint unused2, gint unused3,
 118                                    GtkSelectionData * data, guint info,
 119                                    guint time)
 120 {
 121     gchar *uri_list;
 122     gchar **uris;
 123     gint i, nb_inserted;
 124     gboolean ok = FALSE;
 125     GError *err = NULL;
 126
 127     /* Based on code from gnome-terminal. */
 128
 129     if (data->format != 8) {
 130         DIALOG_MSG(_("Wrong URI format: %d (instead of 8)"), data->format);
 131         goto out;
 132     }
 133
 134     if (data->length <= 0) {
 135         DIALOG_MSG(_("Wrong URI length: %d"), data->length);
 136         goto out;
 137     }
 138
 139     uri_list = g_strndup((gchar*) data->data, data->length);
 140     if (info == TARGET_URI_LIST)
 141         uris = g_strsplit(uri_list, "\r\n", -1);
 142     else
 143         uris = g_strsplit(uri_list, "\n", -1);
 144
 145     if (uris == NULL)
 146         goto out_free;
 147
 148     for (i = 0; uris[i] != NULL && uris[i][0] != '\0'; i++) {
 149         gchar *uri = uris[i];
 150
 151         if (info == TARGET_URI_LIST) {
 152             uri = g_filename_from_uri(uris[i], NULL, &err);
 153             if (err != NULL) {
 154                 DIALOG_MSG("%s", err->message);
 155                 g_error_free(err);
 156                 goto out_strfreev;
 157             }
 158             g_free(uris[i]);
 159             uris[i] = uri;
 160         }
 161     }
 162
 163     ok = TRUE;
 164     nb_inserted = insert_after_current(uris, i, FALSE, TRUE);
 165     new_images(nb_inserted);
 166
 167   out_strfreev:
 168     g_strfreev(uris);
 169
 170   out_free:
 171     g_free(uri_list);
 172
 173   out:
 174     gtk_drag_finish(context, ok, FALSE, time);
 175     return FALSE;
 176 }
 177
 178 static void dnd_init(void)
 179 {
 180     GtkTargetEntry targets[] = {
 181 /* *INDENT-OFF* */
 182         {"text/uri-list", 0, TARGET_URI_LIST},
 183         {"UTF8_STRING",   0, TARGET_STRING},
 184         {"COMPOUND_TEXT", 0, TARGET_STRING},
 185         {"TEXT",          0, TARGET_STRING},
 186         {"STRING",        0, TARGET_STRING}
 187 /* *INDENT-ON* */
 188     };
 189
 190     gtk_drag_dest_set(gl_widget, GTK_DEST_DEFAULT_ALL, targets,
 191                       G_N_ELEMENTS(targets), GDK_ACTION_COPY);
 192
 193     g_signal_connect(gl_widget, "drag-data-received",
 194                      G_CALLBACK(drag_data_received), NULL);
 195 }
 196
 197 /*
 198  * Probe the max_texture_size with a GL_PROXY_TEXTURE_2D.
 199  * Used only when initializing the widget.
 200  */
 201 static gboolean check_texture_size(void)
 202 {
 203     gint width;
 204
 205     glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGB,
 206                  rt->max_texture_size, rt->max_texture_size, 0, GL_RGBA,
 207                  GL_UNSIGNED_BYTE, NULL);
 208
 209     glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
 210
 211     return width == rt->max_texture_size;
 212 }
 213
 214 static void get_max_texture_size(void)
 215 {
 216 #if NO_OPENGL
 217     rt->max_texture_size = 128;
 218 #else
 219     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &rt->max_texture_size);
 220
 221     while (rt->max_texture_size > 0 && check_texture_size() == FALSE)
 222         rt->max_texture_size >>= 1;
 223
 224     if (rt->max_texture_size < 64) {
 225         gchar *message, *texture;
 226
 227         texture = g_strdup_printf(_("Fatal error: GL_MAX_TEXTURE_SIZE = %d\n"),
 228                                   rt->max_texture_size);
 229
 230         message = g_strconcat(texture,
 231                               _("GL_MAX_TEXTURE_SIZE must be >= 64"), NULL);
 232         DIALOG_MSG("%s", message);
 233
 234         g_free(texture);
 235         g_free(message);
 236         quit(1);
 237     }
 238 #endif
 239 }
 240
 241 /* Direct all OpenGL calls to the created widget. */
 242 static gboolean make_current(void)
 243 {
 244     GdkGLContext *glcontext = gtk_widget_get_gl_context(gl_widget);
 245     GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(gl_widget);
 246
 247     return gdk_gl_drawable_make_current(gldrawable, glcontext);
 248 }
 249
 250 static gboolean first_expose(void)
 251 {
 252     /* We only handle the first one. */
 253     g_signal_handlers_disconnect_by_func(gl_widget, G_CALLBACK(first_expose),
 254                                          NULL);
 255
 256     if (make_current() == FALSE) {
 257         DIALOG_MSG(_("glXMakeCurrent() failed"));
 258         quit(1);
 259     }
 260
 261     glDisable(GL_DEPTH_TEST);
 262
 263     glEnable(GL_TEXTURE_2D);
 264     glDisable(GL_BLEND);
 265     glShadeModel(GL_FLAT);
 266     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 267     glPixelStorei(GL_PACK_ALIGNMENT, 1);
 268     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 269
 270     update_bg_color();
 271
 272     get_max_texture_size();
 273
 274     rt->wid_size = &gl_widget->allocation;
 275
 276     g_signal_connect(gl_widget, "configure-event",
 277                      G_CALLBACK(configure_event), NULL);
 278
 279     g_signal_connect(gl_widget, "expose-event", G_CALLBACK(expose_event), NULL);
 280
 281     g_signal_connect_after(gl_widget, "focus-in-event",
 282                            G_CALLBACK(set_correct_cursor), NULL);
 283
 284     schedule_hide_cursor();
 285
 286     old_width = rt->wid_size->width;
 287     old_height = rt->wid_size->height;
 288
 289     if (options->fullscreen)
 290         toggle_fullscreen(TRUE);
 291
 292     resize_widget(rt->wid_size->width, rt->wid_size->height);
 293
 294     dnd_init();
 295
 296     gtk_widget_queue_draw(GTK_WIDGET(get_current_window()));
 297     do_later(G_PRIORITY_LOW, load_first_image);
 298
 299     return FALSE;
 300 }
 301
 302 void create_gl_widget(void)
 303 {
 304     GdkGLConfigMode mode = GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH |
 305         GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA;
 306
 307     GdkGLConfig *glconfig;
 308
 309     if (gdk_gl_query_extension() == FALSE) {
 310         DIALOG_MSG(_("OpenGL not supported"));
 311         quit(1);
 312     }
 313
 314     glconfig = gdk_gl_config_new_by_mode(mode);
 315
 316     if (glconfig == NULL)
 317         /* Try without the alpha channel. */
 318         glconfig = gdk_gl_config_new_by_mode(mode & ~GDK_GL_MODE_ALPHA);
 319
 320     if (glconfig == NULL) {
 321         DIALOG_MSG(_("Cannot find an appropriate visual, try glxinfo(1)"));
 322         quit(1);
 323     }
 324
 325     gl_widget = gtk_drawing_area_new();
 326     if (gtk_widget_set_gl_capability(gl_widget, glconfig, NULL, TRUE,
 327                                      GDK_GL_RGBA_TYPE) == FALSE) {
 328         DIALOG_MSG(_("Cannot set the OpenGL capability"));
 329         quit(1);
 330     }
 331
 332     gtk_widget_add_events(gl_widget,
 333                           GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK |
 334                           GDK_BUTTON_RELEASE_MASK);
 335
 336     if (options->delay != 0)
 337         gtk_widget_add_events(gl_widget, GDK_POINTER_MOTION_MASK);
 338
 339     /* The real initialization is done on the first expose. */
 340     g_signal_connect_after(gl_widget, "expose-event", G_CALLBACK(first_expose),
 341                            NULL);
 342 }
 343
 344 gint report_opengl_errors(const gchar * function_name,
 345                           const gchar * source_name, gint line,
 346                           gint glBegin_inc)
 347 {
 348     static gint glBegin_counter = 0;
 349     gint nb_errors = 0;
 350     gchar *errors = NULL;
 351     GLenum error;
 352
 353     /* We cannot call glGetError() between a glBegin()/glEnd() pair. */
 354     glBegin_counter += glBegin_inc;
 355     if (glBegin_counter != 0)
 356         return 0;
 357
 358     /* Get all errors. */
 359     while ((error = glGetError()) != GL_NO_ERROR) {
 360         gchar *error_msg;
 361         gboolean unknown_error = FALSE;
 362
 363         error_msg = (gchar *) gluErrorString(error);
 364         if (error_msg == NULL) {
 365             unknown_error = TRUE;
 366             error_msg = g_strdup_printf(_("Unknown OpenGL error (%d)"), error);
 367         }
 368
 369         if (errors == NULL)
 370             errors = g_strdup_printf(_("OpenGL error in %s() at %s:%d:\n%s"),
 371                                      function_name, source_name, line,
 372                                      error_msg);
 373         else {
 374             gchar *old_msg = errors;
 375             errors = g_strconcat(errors, "\n", error_msg, NULL);
 376             g_free(old_msg);
 377         }
 378
 379         if (unknown_error)
 380             g_free(error_msg);
 381
 382         nb_errors++;
 383     }
 384
 385     if (errors != NULL) {
 386         g_printerr("%s\n", errors);
 387         g_free(errors);
 388     }
 389
 390     return nb_errors;
 391 }