src/image_viewer.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail team
   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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include <glib.h>
  25 #include <glib/gi18n.h>
  26 #include <gtk/gtkscrolledwindow.h>
  27 #include <gtk/gtkpixmap.h>
  28
  29 #include "procmime.h"
  30 #include "utils.h"
  31 #include "mimeview.h"
  32
  33 #include "prefs_common.h"
  34
  35 typedef struct _ImageViewer ImageViewer;
  36
  37 MimeViewerFactory image_viewer_factory;
  38 void image_viewer_get_resized_size(gint w, gint h, gint aw, gint ah,
  39                                           gint * sw, gint * sh);
  40 static void image_viewer_clear_viewer(MimeViewer *imageviewer);
  41
  42 struct _ImageViewer
  43 {
  44         MimeViewer mimeviewer;
  45
  46         gchar     *file;
  47         MimeInfo  *mimeinfo;
  48         gboolean   resize_img;
  49
  50         GtkWidget *scrolledwin;
  51         GtkWidget *image;
  52         GtkWidget *notebook;
  53         GtkWidget *filename;
  54         GtkWidget *filesize;
  55         GtkWidget *content_type;
  56 };
  57
  58 static GtkWidget *image_viewer_get_widget(MimeViewer *_mimeviewer)
  59 {
  60         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
  61
  62         debug_print("image_viewer_get_widget\n");
  63
  64         return imageviewer->notebook;
  65 }
  66
  67 static void image_viewer_load_file(ImageViewer *imageviewer, const gchar *imgfile)
  68 {
  69         GdkPixbuf *pixbuf;
  70         GdkPixmap *pixmap;
  71         GdkBitmap *mask;
  72         gint avail_width;
  73         gint avail_height;
  74         GError *error = NULL;
  75
  76         debug_print("image_viewer_show_mimepart\n");
  77
  78         if (!imageviewer->resize_img) {
  79                 pixbuf = gdk_pixbuf_new_from_file(imgfile, &error);
  80         } else {
  81                 gint w, h;
  82                 gdk_pixbuf_get_file_info(imgfile, &w, &h);
  83                 avail_width = imageviewer->notebook->parent->allocation.width;
  84                 avail_height = imageviewer->notebook->parent->allocation.height;
  85                 if (avail_width > 8) avail_width -= 8;
  86                 if (avail_height > 8) avail_height -= 8;
  87                 if (avail_width - 100 > 0 &&
  88                     (w > avail_width || h > avail_height))
  89                         pixbuf = gdk_pixbuf_new_from_file_at_scale(imgfile, avail_width,
  90                                 avail_height, TRUE, &error);
  91                 else
  92                         pixbuf = gdk_pixbuf_new_from_file(imgfile, &error);
  93         }
  94
  95         if (error) {
  96                 g_warning(error->message);
  97                 g_error_free(error);
  98         }
  99         if (!pixbuf) {
 100                 g_warning("Can't load the image.");
 101                 return;
 102         }
 103
 104         gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, &mask, 0);
 105
 106         if (!imageviewer->image) {
 107                 imageviewer->image = gtk_pixmap_new(pixmap, mask);
 108
 109                 gtk_scrolled_window_add_with_viewport
 110                         (GTK_SCROLLED_WINDOW(imageviewer->scrolledwin),
 111                          imageviewer->image);
 112         } else
 113                 gtk_pixmap_set(GTK_PIXMAP(imageviewer->image), pixmap, mask);
 114
 115         gtk_widget_show(imageviewer->image);
 116
 117         g_object_unref(pixbuf);
 118 }
 119
 120 static void image_viewer_set_notebook_page(MimeViewer *_mimeviewer)
 121 {
 122         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
 123
 124         if (!prefs_common.display_img)
 125                 gtk_notebook_set_current_page(GTK_NOTEBOOK(imageviewer->notebook), 0);
 126         else
 127                 gtk_notebook_set_current_page(GTK_NOTEBOOK(imageviewer->notebook), 1);
 128 }
 129
 130 static void image_viewer_load_image(ImageViewer *imageviewer)
 131 {
 132         gchar *imgfile;
 133
 134         if (imageviewer->mimeinfo == NULL)
 135                 return;
 136
 137         imgfile = procmime_get_tmp_file_name(imageviewer->mimeinfo);
 138         if (procmime_get_part(imgfile, imageviewer->mimeinfo) < 0) {
 139                 g_warning("Can't get mimepart file");
 140                 g_free(imgfile);
 141                 return;
 142         }
 143         image_viewer_load_file(imageviewer, imgfile);
 144         g_unlink(imgfile);
 145         g_free(imgfile);
 146 }
 147
 148 static void image_viewer_show_mimepart(MimeViewer *_mimeviewer, const gchar *file, MimeInfo *mimeinfo)
 149 {
 150         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
 151
 152         image_viewer_clear_viewer(_mimeviewer);
 153         g_free(imageviewer->file);
 154         imageviewer->file = g_strdup(file);
 155         imageviewer->mimeinfo = mimeinfo;
 156
 157         if (prefs_common.display_img)
 158                 image_viewer_load_image(imageviewer);
 159         else {
 160                 gtk_label_set_text(GTK_LABEL(imageviewer->filename),
 161                                    procmime_mimeinfo_get_parameter(mimeinfo, "name"));
 162                 gtk_label_set_text(GTK_LABEL(imageviewer->filesize), to_human_readable(mimeinfo->length));
 163                 gtk_label_set_text(GTK_LABEL(imageviewer->content_type), mimeinfo->subtype);
 164         }
 165 }
 166
 167 static void image_viewer_clear_viewer(MimeViewer *_mimeviewer)
 168 {
 169         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
 170         GtkAdjustment *hadj, *vadj;
 171
 172         debug_print("image_viewer_clear_viewer\n");
 173
 174         image_viewer_set_notebook_page(_mimeviewer);
 175
 176         if (imageviewer->image != NULL)
 177                 gtk_pixmap_set(GTK_PIXMAP(imageviewer->image), NULL, NULL);
 178
 179         if (imageviewer->scrolledwin) {
 180                 hadj = gtk_scrolled_window_get_hadjustment
 181                         (GTK_SCROLLED_WINDOW(imageviewer->scrolledwin));
 182                 if (hadj)
 183                         gtk_adjustment_set_value(hadj, 0.0);
 184                 vadj = gtk_scrolled_window_get_vadjustment
 185                         (GTK_SCROLLED_WINDOW(imageviewer->scrolledwin));
 186                 if (vadj)
 187                         gtk_adjustment_set_value(vadj, 0.0);
 188         }
 189         g_free(imageviewer->file);
 190         imageviewer->file = NULL;
 191         imageviewer->mimeinfo = NULL;
 192         imageviewer->resize_img = prefs_common.resize_img;
 193 }
 194
 195 static void image_viewer_destroy_viewer(MimeViewer *_mimeviewer)
 196 {
 197         ImageViewer *imageviewer = (ImageViewer *) _mimeviewer;
 198
 199         debug_print("image_viewer_destroy_viewer\n");
 200
 201         image_viewer_clear_viewer(_mimeviewer);
 202         g_object_unref(imageviewer->notebook);
 203         g_free(imageviewer);
 204 }
 205
 206 void image_viewer_get_resized_size(gint w, gint h, gint aw, gint ah,
 207                              gint *sw, gint *sh)
 208 {
 209         gfloat wratio = 1.0;
 210         gfloat hratio = 1.0;
 211         gfloat ratio  = 1.0;
 212
 213         if (w > aw)
 214                 wratio = (gfloat)aw / (gfloat)w;
 215         if (h > ah)
 216                 hratio = (gfloat)ah / (gfloat)h;
 217
 218         ratio = (wratio > hratio) ? hratio : wratio;
 219
 220         *sw = (gint)(w * ratio);
 221         *sh = (gint)(h * ratio);
 222
 223         /* be paranoid */
 224         if (*sw <= 0 || *sh <= 0) {
 225                 *sw = w;
 226                 *sh = h;
 227         }
 228 }
 229
 230 static void load_cb(GtkButton *button, ImageViewer *imageviewer)
 231 {
 232         gtk_notebook_set_current_page(GTK_NOTEBOOK(imageviewer->notebook), 1);
 233         image_viewer_load_image(imageviewer);
 234 }
 235
 236 static gboolean scrolledwin_button_cb(GtkWidget *scrolledwin, GdkEventButton *event,
 237                                       ImageViewer *imageviewer)
 238 {
 239         if (event->button == 1 && imageviewer->image) {
 240                 imageviewer->resize_img = !imageviewer->resize_img;
 241                 image_viewer_load_image(imageviewer);
 242                 return TRUE;
 243         }
 244         return FALSE;
 245 }
 246
 247 static void scrolledwin_resize_cb(GtkWidget *scrolledwin, GtkAllocation *alloc,
 248                                   ImageViewer *imageviewer)
 249 {
 250         if (imageviewer->resize_img)
 251                 image_viewer_load_image(imageviewer);
 252 }
 253
 254 static MimeViewer *image_viewer_create(void)
 255 {
 256         ImageViewer *imageviewer;
 257         /*
 258          *  glade generated code (do not touch)
 259          */
 260         GtkWidget *notebook;
 261         GtkWidget *table1;
 262         GtkWidget *label3;
 263         GtkWidget *label4;
 264         GtkWidget *filename;
 265         GtkWidget *filesize;
 266         GtkWidget *load_button;
 267         GtkWidget *label5;
 268         GtkWidget *content_type;
 269         GtkWidget *scrolledwin;
 270
 271         notebook = gtk_notebook_new();
 272         gtk_widget_show(notebook);
 273         GTK_WIDGET_UNSET_FLAGS(notebook, GTK_CAN_FOCUS);
 274         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
 275         gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
 276
 277         table1 = gtk_table_new(4, 3, FALSE);
 278         gtk_widget_show(table1);
 279         gtk_container_add(GTK_CONTAINER(notebook), table1);
 280         gtk_container_set_border_width(GTK_CONTAINER(table1), 8);
 281         gtk_table_set_row_spacings(GTK_TABLE(table1), 4);
 282         gtk_table_set_col_spacings(GTK_TABLE(table1), 4);
 283
 284         label3 = gtk_label_new(_("Filename:"));
 285         gtk_widget_show(label3);
 286         gtk_table_attach(GTK_TABLE(table1), label3, 0, 1, 0, 1,
 287                          (GtkAttachOptions) (GTK_FILL),
 288                          (GtkAttachOptions) (0), 0, 0);
 289         gtk_misc_set_alignment(GTK_MISC(label3), 0, 0.5);
 290
 291         label4 = gtk_label_new(_("Filesize:"));
 292         gtk_widget_show(label4);
 293         gtk_table_attach(GTK_TABLE(table1), label4, 0, 1, 1, 2,
 294                          (GtkAttachOptions) (GTK_FILL),
 295                          (GtkAttachOptions) (0), 0, 0);
 296         gtk_misc_set_alignment(GTK_MISC(label4), 0, 0.5);
 297
 298         filename = gtk_label_new("");
 299         gtk_widget_show(filename);
 300         gtk_table_attach(GTK_TABLE(table1), filename, 1, 3, 0, 1,
 301                          (GtkAttachOptions) (GTK_FILL),
 302                          (GtkAttachOptions) (0), 0, 0);
 303         gtk_misc_set_alignment(GTK_MISC(filename), 0, 0.5);
 304
 305         filesize = gtk_label_new("");
 306         gtk_widget_show(filesize);
 307         gtk_table_attach(GTK_TABLE(table1), filesize, 1, 3, 1, 2,
 308                          (GtkAttachOptions) (GTK_FILL),
 309                          (GtkAttachOptions) (0), 0, 0);
 310         gtk_misc_set_alignment(GTK_MISC(filesize), 0, 0.5);
 311
 312         load_button = gtk_button_new_with_label(_("Load Image"));
 313         gtk_widget_show(load_button);
 314         gtk_table_attach(GTK_TABLE(table1), load_button, 1, 2, 3, 4,
 315                          (GtkAttachOptions) (GTK_FILL),
 316                          (GtkAttachOptions) (0), 0, 0);
 317
 318         label5 = gtk_label_new(_("Content-Type:"));
 319         gtk_widget_show(label5);
 320         gtk_table_attach(GTK_TABLE(table1), label5, 0, 1, 2, 3,
 321                          (GtkAttachOptions) (GTK_FILL),
 322                          (GtkAttachOptions) (0), 0, 0);
 323         gtk_misc_set_alignment(GTK_MISC(label5), 0, 0.5);
 324
 325         content_type = gtk_label_new("");
 326         gtk_widget_show(content_type);
 327         gtk_table_attach(GTK_TABLE(table1), content_type, 1, 3, 2, 3,
 328                          (GtkAttachOptions) (GTK_FILL),
 329                          (GtkAttachOptions) (0), 0, 0);
 330         gtk_misc_set_alignment(GTK_MISC(content_type), 0, 0.5);
 331
 332         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 333         gtk_widget_show(scrolledwin);
 334         gtk_container_add(GTK_CONTAINER(notebook), scrolledwin);
 335         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 336                                        GTK_POLICY_AUTOMATIC,
 337                                        GTK_POLICY_AUTOMATIC);
 338         /*
 339          *  end of glade code
 340          */
 341
 342         debug_print("Creating image view...\n");
 343         imageviewer = g_new0(ImageViewer, 1);
 344         imageviewer->mimeviewer.factory = &image_viewer_factory;
 345
 346         imageviewer->mimeviewer.get_widget = image_viewer_get_widget;
 347         imageviewer->mimeviewer.show_mimepart = image_viewer_show_mimepart;
 348         imageviewer->mimeviewer.clear_viewer = image_viewer_clear_viewer;
 349         imageviewer->mimeviewer.destroy_viewer = image_viewer_destroy_viewer;
 350         imageviewer->mimeviewer.get_selection = NULL;
 351
 352         imageviewer->resize_img   = prefs_common.resize_img;
 353
 354         imageviewer->scrolledwin  = scrolledwin;
 355         imageviewer->image        = NULL;
 356         imageviewer->notebook     = notebook;
 357         imageviewer->filename     = filename;
 358         imageviewer->filesize     = filesize;
 359         imageviewer->content_type = content_type;
 360
 361         gtk_widget_ref(notebook);
 362
 363         g_signal_connect(G_OBJECT(load_button), "clicked",
 364                          G_CALLBACK(load_cb), imageviewer);
 365         g_signal_connect(G_OBJECT(scrolledwin), "button-press-event",
 366                          G_CALLBACK(scrolledwin_button_cb), imageviewer);
 367         g_signal_connect(G_OBJECT(scrolledwin), "size-allocate",
 368                          G_CALLBACK(scrolledwin_resize_cb), imageviewer);
 369
 370         image_viewer_set_notebook_page((MimeViewer *)imageviewer);
 371
 372         return (MimeViewer *) imageviewer;
 373 }
 374
 375 static gchar *content_types[] =
 376         {"image/*", NULL};
 377
 378 MimeViewerFactory image_viewer_factory =
 379 {
 380         content_types,
 381         0,
 382
 383         image_viewer_create,
 384 };
 385
 386 void image_viewer_init(void)
 387 {
 388         mimeview_register_viewer_factory(&image_viewer_factory);
 389 }
 390
 391 void image_viewer_done(void)
 392 {
 393         mimeview_unregister_viewer_factory(&image_viewer_factory);
 394 }