src/plugins/image_viewer/viewer.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include <glib.h>
  25 #include <gtk/gtkscrolledwindow.h>
  26 #include <gtk/gtkpixmap.h>
  27
  28 #if HAVE_GDK_PIXBUF
  29 #  include <gdk-pixbuf/gdk-pixbuf.h>
  30 #else
  31 #if HAVE_GDK_IMLIB
  32 #  include <gdk_imlib.h>
  33 #endif
  34 #endif /* HAVE_GDK_PIXBUF */
  35
  36 #include "intl.h"
  37 #include "procmime.h"
  38 #include "utils.h"
  39 #include "mimeview.h"
  40
  41 #include "viewerprefs.h"
  42
  43 typedef struct _ImageViewer ImageViewer;
  44
  45 MimeViewerFactory image_viewer_factory;
  46 static void image_viewer_get_resized_size(gint w, gint h, gint aw, gint ah,
  47                                           gint * sw, gint * sh);
  48 static void image_viewer_clear_viewer(MimeViewer *imageviewer);
  49
  50 struct _ImageViewer
  51 {
  52         MimeViewer mimeviewer;
  53
  54         gchar     *file;
  55         MimeInfo  *mimeinfo;
  56         gboolean   resize_img;
  57
  58         GtkWidget *scrolledwin;
  59         GtkWidget *image;
  60         GtkWidget *notebook;
  61         GtkWidget *filename;
  62         GtkWidget *filesize;
  63         GtkWidget *content_type;
  64 };
  65
  66 static GtkWidget *image_viewer_get_widget(MimeViewer *_mimeviewer)
  67 {
  68         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
  69
  70         debug_print("image_viewer_get_widget\n");
  71
  72         return imageviewer->notebook;
  73 }
  74
  75 #if HAVE_GDK_PIXBUF
  76 static void image_viewer_load_file(ImageViewer *imageviewer, const gchar *imgfile)
  77 {
  78         GdkPixbuf *pixbuf;
  79         GdkPixbuf *pixbuf_scaled;
  80         GdkPixmap *pixmap;
  81         GdkBitmap *mask;
  82         gint avail_width;
  83         gint avail_height;
  84         gint new_width;
  85         gint new_height;
  86
  87         debug_print("image_viewer_show_mimepart\n");
  88
  89         pixbuf = gdk_pixbuf_new_from_file(imgfile);
  90         if (!pixbuf) {
  91                 g_warning("Can't load the image.");
  92                 return;
  93         }
  94
  95         if (imageviewer->resize_img) {
  96                 avail_width = imageviewer->notebook->parent->allocation.width;
  97                 avail_height = imageviewer->notebook->parent->allocation.height;
  98                 if (avail_width > 8) avail_width -= 8;
  99                 if (avail_height > 8) avail_height -= 8;
 100
 101                 image_viewer_get_resized_size(gdk_pixbuf_get_width(pixbuf),
 102                                  gdk_pixbuf_get_height(pixbuf),
 103                                  avail_width, avail_height,
 104                                  &new_width, &new_height);
 105
 106                 pixbuf_scaled = gdk_pixbuf_scale_simple
 107                         (pixbuf, new_width, new_height, GDK_INTERP_BILINEAR);
 108                 gdk_pixbuf_unref(pixbuf);
 109                 pixbuf = pixbuf_scaled;
 110         }
 111
 112         gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, &mask, 0);
 113
 114         if (!imageviewer->image) {
 115                 imageviewer->image = gtk_pixmap_new(pixmap, mask);
 116
 117                 gtk_scrolled_window_add_with_viewport
 118                         (GTK_SCROLLED_WINDOW(imageviewer->scrolledwin),
 119                          imageviewer->image);
 120         } else
 121                 gtk_pixmap_set(GTK_PIXMAP(imageviewer->image), pixmap, mask);
 122
 123         gtk_widget_show(imageviewer->image);
 124
 125         gdk_pixbuf_unref(pixbuf);
 126 }
 127 #else
 128 #if HAVE_GDK_IMLIB
 129 static void image_viewer_load_file(ImageViewer *imageviewer, const gchar *imgfile)
 130 {
 131         GdkImlibImage *im;
 132         gint avail_width;
 133         gint avail_height;
 134         gint new_width;
 135         gint new_height;
 136
 137         debug_print("image_viewer_show_mimepart\n");
 138
 139         im = gdk_imlib_load_image(imgfile);
 140         if (!im) {
 141                 g_warning("Can't load the image.");
 142                 return;
 143         }
 144
 145         if (imageviewer->resize_img) {
 146                 avail_width = imageviewer->notebook->parent->allocation.width;
 147                 avail_height = imageviewer->notebook->parent->allocation.height;
 148                 if (avail_width > 8) avail_width -= 8;
 149                 if (avail_height > 8) avail_height -= 8;
 150
 151                 image_viewer_get_resized_size(im->rgb_width, im->rgb_height,
 152                                  avail_width, avail_height,
 153                                  &new_width, &new_height);
 154         } else {
 155                 new_width = im->rgb_width;
 156                 new_height = im->rgb_height;
 157         }
 158
 159         gdk_imlib_render(im, new_width, new_height);
 160
 161         if (!imageviewer->image) {
 162                 imageviewer->image = gtk_pixmap_new(gdk_imlib_move_image(im),
 163                                                     gdk_imlib_move_mask(im));
 164
 165                 gtk_scrolled_window_add_with_viewport
 166                         (GTK_SCROLLED_WINDOW(imageviewer->scrolledwin),
 167                          imageviewer->image);
 168         } else
 169                 gtk_pixmap_set(GTK_PIXMAP(imageviewer->image),
 170                                gdk_imlib_move_image(im),
 171                                gdk_imlib_move_mask(im));
 172
 173         gtk_widget_show(imageviewer->image);
 174
 175         gdk_imlib_destroy_image(im);
 176 }
 177 #endif /* HAVE_GDK_IMLIB */
 178 #endif /* HAVE_GDK_PIXBUF */
 179
 180 static void image_viewer_set_notebook_page(MimeViewer *_mimeviewer)
 181 {
 182         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
 183
 184         if (!imageviewerprefs.display_img)
 185                 gtk_notebook_set_page(GTK_NOTEBOOK(imageviewer->notebook), 0);
 186         else
 187                 gtk_notebook_set_page(GTK_NOTEBOOK(imageviewer->notebook), 1);
 188 }
 189
 190 static void image_viewer_load_image(ImageViewer *imageviewer)
 191 {
 192         gchar *imgfile;
 193
 194         if (imageviewer->mimeinfo == NULL)
 195                 return;
 196
 197         imgfile = procmime_get_tmp_file_name(imageviewer->mimeinfo);
 198         if (procmime_get_part(imgfile, imageviewer->mimeinfo) < 0) {
 199                 g_warning("Can't get mimepart file");
 200                 g_free(imgfile);
 201                 return;
 202         }
 203         image_viewer_load_file(imageviewer, imgfile);
 204         unlink(imgfile);
 205         g_free(imgfile);
 206 }
 207
 208 static void image_viewer_show_mimepart(MimeViewer *_mimeviewer, const gchar *file, MimeInfo *mimeinfo)
 209 {
 210         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
 211
 212         image_viewer_clear_viewer(_mimeviewer);
 213         g_free(imageviewer->file);
 214         imageviewer->file = g_strdup(file);
 215         imageviewer->mimeinfo = mimeinfo;
 216
 217         if (imageviewerprefs.display_img)
 218                 image_viewer_load_image(imageviewer);
 219         else {
 220                 gtk_label_set_text(GTK_LABEL(imageviewer->filename),
 221                                    procmime_mimeinfo_get_parameter(mimeinfo, "name"));
 222                 gtk_label_set_text(GTK_LABEL(imageviewer->filesize), to_human_readable(mimeinfo->length));
 223                 gtk_label_set_text(GTK_LABEL(imageviewer->content_type), mimeinfo->subtype);
 224         }
 225 }
 226
 227 static void image_viewer_clear_viewer(MimeViewer *_mimeviewer)
 228 {
 229         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
 230         GtkAdjustment *hadj, *vadj;
 231
 232         debug_print("image_viewer_clear_viewer\n");
 233
 234         image_viewer_set_notebook_page(_mimeviewer);
 235
 236         if (imageviewer->image != NULL)
 237                 gtk_pixmap_set(GTK_PIXMAP(imageviewer->image), NULL, NULL);
 238         hadj = gtk_scrolled_window_get_hadjustment
 239                 (GTK_SCROLLED_WINDOW(imageviewer->scrolledwin));
 240         gtk_adjustment_set_value(hadj, 0.0);
 241         vadj = gtk_scrolled_window_get_vadjustment
 242                 (GTK_SCROLLED_WINDOW(imageviewer->scrolledwin));
 243         gtk_adjustment_set_value(vadj, 0.0);
 244
 245         g_free(imageviewer->file);
 246         imageviewer->file = NULL;
 247         imageviewer->mimeinfo = NULL;
 248         imageviewer->resize_img = imageviewerprefs.resize_img;
 249 }
 250
 251 static void image_viewer_destroy_viewer(MimeViewer *_mimeviewer)
 252 {
 253         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
 254
 255         debug_print("image_viewer_destroy_viewer\n");
 256
 257         image_viewer_clear_viewer(_mimeviewer);
 258         gtk_widget_unref(imageviewer->notebook);
 259         g_free(imageviewer);
 260 }
 261
 262 static void image_viewer_get_resized_size(gint w, gint h, gint aw, gint ah,
 263                              gint *sw, gint *sh)
 264 {
 265         gfloat wratio = 1.0;
 266         gfloat hratio = 1.0;
 267         gfloat ratio  = 1.0;
 268
 269         if (w > aw)
 270                 wratio = (gfloat)aw / (gfloat)w;
 271         if (h > ah)
 272                 hratio = (gfloat)ah / (gfloat)h;
 273
 274         ratio = (wratio > hratio) ? hratio : wratio;
 275
 276         *sw = (gint)(w * ratio);
 277         *sh = (gint)(h * ratio);
 278
 279         /* be paranoid */
 280         if (*sw <= 0 || *sh <= 0) {
 281                 *sw = w;
 282                 *sh = h;
 283         }
 284 }
 285
 286 static void load_cb(GtkButton *button, ImageViewer *imageviewer)
 287 {
 288         gtk_notebook_set_page(GTK_NOTEBOOK(imageviewer->notebook), 1);
 289         image_viewer_load_image(imageviewer);
 290 }
 291
 292 static gboolean scrolledwin_button_cb(GtkWidget *scrolledwin, GdkEventButton *event,
 293                                       ImageViewer *imageviewer)
 294 {
 295         if (event->button == 1 && imageviewer->image) {
 296                 imageviewer->resize_img = !imageviewer->resize_img;
 297                 image_viewer_load_image(imageviewer);
 298                 return TRUE;
 299         }
 300         return FALSE;
 301 }
 302
 303 static void scrolledwin_resize_cb(GtkWidget *scrolledwin, GtkAllocation *alloc,
 304                                   ImageViewer *imageviewer)
 305 {
 306         if (imageviewer->resize_img)
 307                 image_viewer_load_image(imageviewer);
 308 }
 309
 310 MimeViewer *image_viewer_create(void)
 311 {
 312         ImageViewer *imageviewer;
 313         /*
 314          *  glade generated code (do not touch)
 315          */
 316         GtkWidget *notebook;
 317         GtkWidget *table1;
 318         GtkWidget *label3;
 319         GtkWidget *label4;
 320         GtkWidget *filename;
 321         GtkWidget *filesize;
 322         GtkWidget *load_button;
 323         GtkWidget *label5;
 324         GtkWidget *content_type;
 325         GtkWidget *scrolledwin;
 326
 327         notebook = gtk_notebook_new();
 328         gtk_widget_show(notebook);
 329         GTK_WIDGET_UNSET_FLAGS(notebook, GTK_CAN_FOCUS);
 330         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
 331         gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
 332
 333         table1 = gtk_table_new(4, 3, FALSE);
 334         gtk_widget_show(table1);
 335         gtk_container_add(GTK_CONTAINER(notebook), table1);
 336         gtk_container_set_border_width(GTK_CONTAINER(table1), 8);
 337         gtk_table_set_row_spacings(GTK_TABLE(table1), 4);
 338         gtk_table_set_col_spacings(GTK_TABLE(table1), 4);
 339
 340         label3 = gtk_label_new(_("Filename:"));
 341         gtk_widget_show(label3);
 342         gtk_table_attach(GTK_TABLE(table1), label3, 0, 1, 0, 1,
 343                          (GtkAttachOptions) (GTK_FILL),
 344                          (GtkAttachOptions) (0), 0, 0);
 345         gtk_misc_set_alignment(GTK_MISC(label3), 0, 0.5);
 346
 347         label4 = gtk_label_new(_("Filesize:"));
 348         gtk_widget_show(label4);
 349         gtk_table_attach(GTK_TABLE(table1), label4, 0, 1, 1, 2,
 350                          (GtkAttachOptions) (GTK_FILL),
 351                          (GtkAttachOptions) (0), 0, 0);
 352         gtk_misc_set_alignment(GTK_MISC(label4), 0, 0.5);
 353
 354         filename = gtk_label_new("");
 355         gtk_widget_show(filename);
 356         gtk_table_attach(GTK_TABLE(table1), filename, 1, 3, 0, 1,
 357                          (GtkAttachOptions) (GTK_FILL),
 358                          (GtkAttachOptions) (0), 0, 0);
 359         gtk_misc_set_alignment(GTK_MISC(filename), 0, 0.5);
 360
 361         filesize = gtk_label_new("");
 362         gtk_widget_show(filesize);
 363         gtk_table_attach(GTK_TABLE(table1), filesize, 1, 3, 1, 2,
 364                          (GtkAttachOptions) (GTK_FILL),
 365                          (GtkAttachOptions) (0), 0, 0);
 366         gtk_misc_set_alignment(GTK_MISC(filesize), 0, 0.5);
 367
 368         load_button = gtk_button_new_with_label(_("Load Image"));
 369         gtk_widget_show(load_button);
 370         gtk_table_attach(GTK_TABLE(table1), load_button, 1, 2, 3, 4,
 371                          (GtkAttachOptions) (GTK_FILL),
 372                          (GtkAttachOptions) (0), 0, 0);
 373
 374         label5 = gtk_label_new(_("Content-Type:"));
 375         gtk_widget_show(label5);
 376         gtk_table_attach(GTK_TABLE(table1), label5, 0, 1, 2, 3,
 377                          (GtkAttachOptions) (GTK_FILL),
 378                          (GtkAttachOptions) (0), 0, 0);
 379         gtk_misc_set_alignment(GTK_MISC(label5), 0, 0.5);
 380
 381         content_type = gtk_label_new("");
 382         gtk_widget_show(content_type);
 383         gtk_table_attach(GTK_TABLE(table1), content_type, 1, 3, 2, 3,
 384                          (GtkAttachOptions) (GTK_FILL),
 385                          (GtkAttachOptions) (0), 0, 0);
 386         gtk_misc_set_alignment(GTK_MISC(content_type), 0, 0.5);
 387
 388         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 389         gtk_widget_show(scrolledwin);
 390         gtk_container_add(GTK_CONTAINER(notebook), scrolledwin);
 391         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 392                                        GTK_POLICY_AUTOMATIC,
 393                                        GTK_POLICY_AUTOMATIC);
 394         /*
 395          *  end of glade code
 396          */
 397
 398         debug_print("Creating image view...\n");
 399         imageviewer = g_new0(ImageViewer, 1);
 400         imageviewer->mimeviewer.factory = &image_viewer_factory;
 401
 402         imageviewer->mimeviewer.get_widget = image_viewer_get_widget;
 403         imageviewer->mimeviewer.show_mimepart = image_viewer_show_mimepart;
 404         imageviewer->mimeviewer.clear_viewer = image_viewer_clear_viewer;
 405         imageviewer->mimeviewer.destroy_viewer = image_viewer_destroy_viewer;
 406
 407         imageviewer->resize_img   = imageviewerprefs.resize_img;
 408
 409         imageviewer->scrolledwin  = scrolledwin;
 410         imageviewer->image        = NULL;
 411         imageviewer->notebook     = notebook;
 412         imageviewer->filename     = filename;
 413         imageviewer->filesize     = filesize;
 414         imageviewer->content_type = content_type;
 415
 416         gtk_widget_ref(notebook);
 417
 418         gtk_signal_connect(GTK_OBJECT(load_button), "released",
 419                            GTK_SIGNAL_FUNC(load_cb), imageviewer);
 420         gtk_signal_connect(GTK_OBJECT(scrolledwin), "button-press-event",
 421                            GTK_SIGNAL_FUNC(scrolledwin_button_cb), imageviewer);
 422         gtk_signal_connect(GTK_OBJECT(scrolledwin), "size-allocate",
 423                            GTK_SIGNAL_FUNC(scrolledwin_resize_cb), imageviewer);
 424
 425         image_viewer_set_notebook_page((MimeViewer *)imageviewer);
 426
 427         return (MimeViewer *) imageviewer;
 428 }
 429
 430 static gchar *content_types[] =
 431         {"image/*", NULL};
 432
 433 MimeViewerFactory image_viewer_factory =
 434 {
 435         content_types,
 436         0,
 437
 438         image_viewer_create,
 439 };
 440
 441 void image_viewer_init(void)
 442 {
 443 #if HAVE_GDK_IMLIB
 444         gdk_imlib_init();
 445         gtk_widget_push_visual(gdk_imlib_get_visual());
 446         gtk_widget_push_colormap(gdk_imlib_get_colormap());
 447 #endif
 448
 449         mimeview_register_viewer_factory(&image_viewer_factory);
 450 }
 451
 452 void image_viewer_done(void)
 453 {
 454         mimeview_unregister_viewer_factory(&image_viewer_factory);
 455 }