backend/impress/impress-document.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
   2 /*
   3  * Copyright (C) 2005, Jonathan Blandford <jrb@gnome.org>
   4  * Copyright (C) 2005, Bastien Nocera <hadess@hadess.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <gtk/gtk.h>
  22 #include <string.h>
  23 #include "imposter.h"
  24 #include "impress-document.h"
  25 #include "ev-document-thumbnails.h"
  26 #include "ev-document-misc.h"
  27
  28 struct _ImpressDocumentClass
  29 {
  30   GObjectClass parent_class;
  31 };
  32
  33 struct _ImpressDocument
  34 {
  35   GObject parent_instance;
  36
  37   ImpDoc *imp;
  38   ImpRenderCtx *ctx;
  39
  40   GMutex *mutex;
  41   GdkPixmap *pixmap;
  42   GdkGC *gc;
  43   PangoContext *pango_ctx;
  44
  45   /* Only used while rendering inside the mainloop */
  46   int pagenum;
  47   GdkPixbuf *pixbuf;
  48   GCond *cond;
  49 };
  50
  51 #define PAGE_WIDTH 1024
  52 #define PAGE_HEIGHT 768
  53
  54 typedef struct _ImpressDocumentClass ImpressDocumentClass;
  55
  56 static void impress_document_document_iface_init (EvDocumentIface *iface);
  57 static void impress_document_document_thumbnails_iface_init (EvDocumentThumbnailsIface *iface);
  58
  59 G_DEFINE_TYPE_WITH_CODE (ImpressDocument, impress_document, G_TYPE_OBJECT,
  60                          { G_IMPLEMENT_INTERFACE (EV_TYPE_DOCUMENT,
  61                                                   impress_document_document_iface_init);
  62                            G_IMPLEMENT_INTERFACE (EV_TYPE_DOCUMENT_THUMBNAILS,
  63                                                   impress_document_document_thumbnails_iface_init);
  64                          });
  65
  66 /* Renderer */
  67 static void
  68 imp_render_draw_bezier_real (GdkDrawable *d, GdkGC *gc, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3)
  69 {
  70   int x, y, nx, ny;
  71   int ax, bx, cx, ay, by, cy;
  72   double t, t2, t3;
  73
  74   x = x0;
  75   y = y0;
  76
  77   cx = 3 * (x1 - x0);
  78   bx = 3 * (x2 - x1) - cx;
  79   ax = x3 - x0 - cx - bx;
  80   cy = 3 * (y1 - y0);
  81   by = 3 * (y2 - y1) - cy;
  82   ay = y3 - y0 - cy - by;
  83
  84   for (t = 0; t < 1; t += 0.01) {
  85     t2 = t * t;
  86     t3 = t2 * t;
  87     nx = ax * t3 + bx * t2 + cx * t + x0;
  88     ny = ay * t3 + by * t2 + cy * t + y0;
  89     gdk_draw_line (d, gc, x, y, nx, ny);
  90     x = nx;
  91     y = ny;
  92   }
  93 }
  94
  95 static void
  96 imp_render_get_size(void *drw_data, int *w, int *h)
  97 {
  98   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
  99
 100   gdk_drawable_get_size(impress_document->pixmap, w, h);
 101 }
 102
 103 static void
 104 imp_render_set_fg_color(void *drw_data, ImpColor *color)
 105 {
 106   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 107   GdkColor c;
 108
 109   c.red = color->red;
 110   c.green = color->green;
 111   c.blue = color->blue;
 112   gdk_gc_set_rgb_fg_color(impress_document->gc, &c);
 113 }
 114
 115 static void
 116 imp_render_draw_line(void *drw_data, int x1, int y1, int x2, int y2)
 117 {
 118   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 119
 120   gdk_draw_line(impress_document->pixmap, impress_document->gc, x1, y1, x2, y2);
 121 }
 122
 123 static void
 124 imp_render_draw_rect(void *drw_data, int fill, int x, int y, int w, int h)
 125 {
 126   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 127
 128   gdk_draw_rectangle(impress_document->pixmap, impress_document->gc, fill, x, y, w, h);
 129 }
 130
 131 static void
 132 imp_render_draw_polygon(void *drw_data, int fill, ImpPoint *pts, int nr_pts)
 133 {
 134   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 135
 136   gdk_draw_polygon(impress_document->pixmap, impress_document->gc, fill, (GdkPoint *)pts, nr_pts);
 137 }
 138
 139 static void
 140 imp_render_draw_arc(void *drw_data, int fill, int x, int y, int w, int h, int sa, int ea)
 141 {
 142   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 143
 144   gdk_draw_arc(impress_document->pixmap, impress_document->gc, fill, x, y, w, h, sa * 64, ea * 64);
 145 }
 146
 147 static void
 148 imp_render_draw_bezier(void *drw_data, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3)
 149 {
 150   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 151
 152   imp_render_draw_bezier_real (impress_document->pixmap, impress_document->gc, x0, y0, x1, y1, x2, y2, x3, y3);
 153 }
 154
 155 static void *
 156 imp_render_open_image(void *drw_data, const unsigned char *pix, size_t size)
 157 {
 158   GdkPixbufLoader *gpl;
 159   GdkPixbuf *pb;
 160
 161   gpl = gdk_pixbuf_loader_new();
 162   gdk_pixbuf_loader_write(gpl, pix, size, NULL);
 163   gdk_pixbuf_loader_close(gpl, NULL);
 164   pb = gdk_pixbuf_loader_get_pixbuf(gpl);
 165   return pb;
 166 }
 167
 168 static void
 169 imp_render_get_image_size(void *drw_data, void *img_data, int *w, int *h)
 170 {
 171   GdkPixbuf *pb = (GdkPixbuf *) img_data;
 172
 173   *w = gdk_pixbuf_get_width(pb);
 174   *h = gdk_pixbuf_get_height(pb);
 175 }
 176
 177 static void *
 178 imp_render_scale_image(void *drw_data, void *img_data, int w, int h)
 179 {
 180   GdkPixbuf *pb = (GdkPixbuf *) img_data;
 181
 182   return gdk_pixbuf_scale_simple(pb, w, h, GDK_INTERP_BILINEAR);
 183 }
 184
 185 static void
 186 imp_render_draw_image(void *drw_data, void *img_data, int x, int y, int w, int h)
 187 {
 188   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 189   GdkPixbuf *pb = (GdkPixbuf *) img_data;
 190
 191   gdk_draw_pixbuf(impress_document->pixmap, impress_document->gc, pb, 0, 0, x, y, w, h, GDK_RGB_DITHER_NONE, 0, 0);
 192 }
 193
 194 static void
 195 imp_render_close_image(void *drw_data, void *img_data)
 196 {
 197   GdkPixbuf *pb = (GdkPixbuf *) img_data;
 198
 199   g_object_unref(G_OBJECT(pb));
 200 }
 201
 202 static char *
 203 imp_render_markup(const char *text, size_t len, int styles, int size)
 204 {
 205   double scr_mm, scr_px, dpi;
 206   char *esc;
 207   char *ret;
 208   int sz;
 209
 210   scr_mm = gdk_screen_get_height_mm(gdk_screen_get_default());
 211   scr_px = gdk_screen_get_height(gdk_screen_get_default());
 212   dpi = (scr_px / scr_mm) * 25.4;
 213   sz = (int) ((double) size * 72.0 * PANGO_SCALE / dpi);
 214   esc = g_markup_escape_text(text, len);
 215   ret = g_strdup_printf("<span size ='%d'>%s</span>", sz, esc);
 216   g_free(esc);
 217   return ret;
 218 }
 219
 220 static void
 221 imp_render_get_text_size(void *drw_data, const char *text, size_t len, int size, int styles, int *w, int *h)
 222 {
 223   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 224   PangoLayout *lay;
 225   int pw, ph;
 226   char *m;
 227
 228   g_return_if_fail (impress_document->pango_ctx != NULL);
 229
 230   lay = pango_layout_new(impress_document->pango_ctx);
 231   m = imp_render_markup(text, len, styles, size);
 232   pango_layout_set_markup(lay, m, strlen(m));
 233   pango_layout_get_size(lay, &pw, &ph);
 234   g_object_unref(lay);
 235   g_free(m);
 236   *w = pw / PANGO_SCALE;
 237   *h = ph / PANGO_SCALE;
 238 }
 239
 240 static void
 241 imp_render_draw_text(void *drw_data, int x, int y, const char *text, size_t len, int size, int styles)
 242 {
 243   ImpressDocument *impress_document = IMPRESS_DOCUMENT (drw_data);
 244   PangoLayout *lay;
 245   char *m;
 246
 247   g_return_if_fail (impress_document->pango_ctx != NULL);
 248
 249   lay = pango_layout_new(impress_document->pango_ctx);
 250   m = imp_render_markup(text, len, styles, size);
 251   pango_layout_set_markup(lay, m, strlen(m));
 252   gdk_draw_layout(impress_document->pixmap, impress_document->gc, x, y, lay);
 253   g_object_unref(lay);
 254   g_free(m);
 255 }
 256
 257 static const ImpDrawer imp_render_functions = {
 258   imp_render_get_size,
 259   imp_render_set_fg_color,
 260   imp_render_draw_line,
 261   imp_render_draw_rect,
 262   imp_render_draw_polygon,
 263   imp_render_draw_arc,
 264   imp_render_draw_bezier,
 265   imp_render_open_image,
 266   imp_render_get_image_size,
 267   imp_render_scale_image,
 268   imp_render_draw_image,
 269   imp_render_close_image,
 270   imp_render_get_text_size,
 271   imp_render_draw_text
 272 };
 273
 274 /* Document interface */
 275 static gboolean
 276 impress_document_load (EvDocument  *document,
 277                     const char  *uri,
 278                     GError     **error)
 279 {
 280   ImpressDocument *impress_document = IMPRESS_DOCUMENT (document);
 281   gchar *filename;
 282   ImpDoc *imp;
 283   int err;
 284
 285   /* FIXME: Could we actually load uris ? */
 286   filename = g_filename_from_uri (uri, NULL, error);
 287   if (!filename)
 288     {
 289       //FIXME
 290       //g_error_set ();
 291       return FALSE;
 292     }
 293
 294   imp = imp_open (filename, &err);
 295
 296   if (!imp)
 297     {
 298       //FIXME translate the err, set error
 299       g_free (filename);
 300       return FALSE;
 301     }
 302   impress_document->imp = imp;
 303
 304   return TRUE;
 305 }
 306
 307 static gboolean
 308 impress_document_save (EvDocument  *document,
 309                       const char  *uri,
 310                       GError     **error)
 311 {
 312         return FALSE;
 313 }
 314
 315 static int
 316 impress_document_get_n_pages (EvDocument  *document)
 317 {
 318   ImpressDocument *impress_document = IMPRESS_DOCUMENT (document);
 319
 320   g_return_val_if_fail (IMPRESS_IS_DOCUMENT (document), 0);
 321   g_return_val_if_fail (impress_document->imp != NULL, 0);
 322
 323   return imp_nr_pages (impress_document->imp);
 324 }
 325
 326 static void
 327 impress_document_get_page_size (EvDocument   *document,
 328                              int           page,
 329                              double       *width,
 330                              double       *height)
 331 {
 332   ImpressDocument *impress_document = IMPRESS_DOCUMENT (document);
 333
 334   g_return_if_fail (IMPRESS_IS_DOCUMENT (document));
 335   g_return_if_fail (impress_document->imp != NULL);
 336
 337   //FIXME
 338   *width = PAGE_WIDTH;
 339   *height = PAGE_HEIGHT;
 340 }
 341
 342 static gboolean
 343 imp_render_get_from_drawable (ImpressDocument *impress_document)
 344 {
 345   ImpPage *page;
 346
 347   page = imp_get_page (impress_document->imp, impress_document->pagenum);
 348
 349   g_return_val_if_fail (page != NULL, FALSE);
 350
 351   imp_context_set_page (impress_document->ctx, page);
 352   imp_render (impress_document->ctx, impress_document);
 353
 354   impress_document->pixbuf = gdk_pixbuf_get_from_drawable (NULL,
 355                                          GDK_DRAWABLE (impress_document->pixmap),
 356                                          NULL,
 357                                          0, 0,
 358                                          0, 0,
 359                                          PAGE_WIDTH, PAGE_HEIGHT);
 360   g_cond_broadcast (impress_document->cond);
 361   return FALSE;
 362 }
 363
 364 static GdkPixbuf *
 365 impress_document_render_pixbuf (EvDocument  *document,
 366                                 EvRenderContext *rc)
 367 {
 368   ImpressDocument *impress_document = IMPRESS_DOCUMENT (document);
 369   GdkPixbuf *scaled_pixbuf;
 370
 371   g_return_val_if_fail (IMPRESS_IS_DOCUMENT (document), 0);
 372   g_return_val_if_fail (impress_document->imp != NULL, 0);
 373
 374   impress_document->pagenum = rc->page;
 375
 376   g_mutex_lock (impress_document->mutex);
 377   impress_document->cond = g_cond_new ();
 378
 379   g_idle_add ((GSourceFunc) imp_render_get_from_drawable, impress_document);
 380
 381   g_cond_wait (impress_document->cond, impress_document->mutex);
 382   g_cond_free (impress_document->cond);
 383   g_mutex_unlock (impress_document->mutex);
 384
 385   scaled_pixbuf = gdk_pixbuf_scale_simple (impress_document->pixbuf,
 386                                            PAGE_WIDTH * rc->scale,
 387                                            PAGE_HEIGHT * rc->scale,
 388                                            GDK_INTERP_BILINEAR);
 389   gdk_pixbuf_unref (impress_document->pixbuf);
 390   impress_document->pixbuf = NULL;
 391
 392   return scaled_pixbuf;
 393 }
 394
 395 static void
 396 impress_document_finalize (GObject *object)
 397 {
 398   ImpressDocument *impress_document = IMPRESS_DOCUMENT (object);
 399
 400   g_mutex_free (impress_document->mutex);
 401
 402   imp_close (impress_document->imp);
 403   imp_delete_context (impress_document->ctx);
 404   g_free (impress_document->pango_ctx);
 405   g_object_unref (G_OBJECT (impress_document->pixmap));
 406   g_object_unref (impress_document->gc);
 407
 408   G_OBJECT_CLASS (impress_document_parent_class)->finalize (object);
 409 }
 410
 411 static void
 412 impress_document_class_init (ImpressDocumentClass *klass)
 413 {
 414   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 415
 416   gobject_class->finalize = impress_document_finalize;
 417 }
 418
 419 static gboolean
 420 impress_document_can_get_text (EvDocument *document)
 421 {
 422   return FALSE;
 423 }
 424
 425 static EvDocumentInfo *
 426 impress_document_get_info (EvDocument *document)
 427 {
 428   EvDocumentInfo *info;
 429
 430   info = g_new0 (EvDocumentInfo, 1);
 431   info->fields_mask = 0;
 432
 433   return info;
 434 }
 435
 436 static void
 437 impress_document_document_iface_init (EvDocumentIface *iface)
 438 {
 439   iface->load = impress_document_load;
 440   iface->save = impress_document_save;
 441   iface->can_get_text = impress_document_can_get_text;
 442   iface->get_n_pages = impress_document_get_n_pages;
 443   iface->get_page_size = impress_document_get_page_size;
 444   iface->render_pixbuf = impress_document_render_pixbuf;
 445   iface->get_info = impress_document_get_info;
 446 }
 447
 448 static GdkPixbuf *
 449 impress_document_thumbnails_get_thumbnail (EvDocumentThumbnails *document,
 450                                         gint                  page,
 451                                         gint                  rotation,
 452                                         gint                  size,
 453                                         gboolean              border)
 454 {
 455   GdkPixbuf *pixbuf = NULL;
 456   gdouble w, h;
 457   EvRenderContext *rc;
 458
 459   impress_document_get_page_size (EV_DOCUMENT (document),
 460                                page,
 461                                &w, &h);
 462
 463   rc = ev_render_context_new (rotation, page, size/w);
 464   pixbuf = impress_document_render_pixbuf (EV_DOCUMENT (document), rc);
 465   g_object_unref (G_OBJECT (rc));
 466
 467   if (border)
 468     {
 469       GdkPixbuf *tmp_pixbuf = pixbuf;
 470       pixbuf = ev_document_misc_get_thumbnail_frame (-1, -1, 0, tmp_pixbuf);
 471       g_object_unref (tmp_pixbuf);
 472     }
 473
 474   return pixbuf;
 475 }
 476
 477 static void
 478 impress_document_thumbnails_get_dimensions (EvDocumentThumbnails *document,
 479                                          gint                  page,
 480                                          gint                  suggested_width,
 481                                          gint                 *width,
 482                                          gint                 *height)
 483 {
 484   gdouble page_ratio;
 485   gdouble w, h;
 486
 487   impress_document_get_page_size (EV_DOCUMENT (document),
 488                                page,
 489                                &w, &h);
 490   g_return_if_fail (w > 0);
 491   page_ratio = h/w;
 492   *width = suggested_width;
 493   *height = (gint) (suggested_width * page_ratio);
 494 }
 495
 496 static void
 497 impress_document_document_thumbnails_iface_init (EvDocumentThumbnailsIface *iface)
 498 {
 499   iface->get_thumbnail = impress_document_thumbnails_get_thumbnail;
 500   iface->get_dimensions = impress_document_thumbnails_get_dimensions;
 501 }
 502
 503 static void
 504 impress_document_init (ImpressDocument *impress_document)
 505 {
 506   GdkWindow *window;
 507
 508   impress_document->mutex = g_mutex_new ();
 509   impress_document->ctx = imp_create_context(&imp_render_functions);
 510
 511   window = gdk_screen_get_root_window (gdk_screen_get_default ());
 512
 513   impress_document->pixmap = gdk_pixmap_new (window,
 514                                              PAGE_WIDTH, PAGE_HEIGHT, -1);
 515   impress_document->gc = gdk_gc_new (impress_document->pixmap);
 516   impress_document->pango_ctx = gdk_pango_context_get ();
 517 }
 518
 519 /*
 520  * vim: sw=2 ts=8 cindent noai bs=2
 521  */