pdf/xpdf/bonobo-image-x-pdf.cc

   1 /*
   2  * image/x-pdf BonoboObject.
   3  *
   4  * Author:
   5  *   Michael Meeks <michael@imaginator.com>
   6  *
   7  */
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <stddef.h>
  11 #include <string.h>
  12 #include <config.h>
  13 extern "C" {
  14 #define GString G_String
  15 #include <gnome.h>
  16 #include <libgnorba/gnorba.h>
  17 #include <bonobo/gnome-bonobo.h>
  18 #undef  GString
  19 }
  20 #include "gtypes.h"
  21 #include "GString.h"
  22 #include "parseargs.h"
  23 #include "gfile.h"
  24 #include "gmem.h"
  25 #include "Object.h"
  26 #include "Stream.h"
  27 #include "Array.h"
  28 #include "Dict.h"
  29 #include "XRef.h"
  30 #include "Catalog.h"
  31 #include "Page.h"
  32 #include "Link.h"
  33 #include "PDFDoc.h"
  34 #include "GOutputDev.h"
  35 #include "PSOutputDev.h"
  36 #include "TextOutputDev.h"
  37 #include "Params.h"
  38 #include "Error.h"
  39 #include "config.h"
  40 #include "BonoboStream.h"
  41
  42 #define PDF_DEBUG 0
  43 #define UNTESTED 0
  44
  45 GBool printCommands = gFalse;
  46
  47 CORBA_Environment ev;
  48 CORBA_ORB orb;
  49
  50 /*
  51  * Number of servers running on the system
  52  * when the count reaches zero, we unregister from the
  53  * Name Server and we shut down.
  54  */
  55 static int embeddable_servers = 0;
  56
  57 /*
  58  * Our embeddable factory
  59  */
  60 static GnomeEmbeddableFactory *factory;
  61
  62
  63 /*
  64  * BonoboObject data
  65  */
  66 typedef struct {
  67   GnomeEmbeddable *embeddable;
  68
  69   PDFDoc       *pdf;
  70   GNOME_Stream  stream; /* To free it later */
  71
  72   GList *views;
  73 } bed_t;
  74
  75 /*
  76  * View data
  77  */
  78 typedef struct {
  79   GnomeView            *view;
  80   bed_t *bed;
  81
  82   double                scale;
  83   GtkWidget            *drawing_area;
  84   GdkPixmap            *pixmap;
  85   GdkWindow            *win;
  86   GOutputDev           *out;
  87   GdkColor              paper;
  88   gint                  w, h;
  89   gdouble               zoom;
  90   gint                  page;
  91 } view_data_t;
  92
  93 extern "C" {
  94   static void realize_drawing_areas (bed_t *bed);
  95   static void setup_pixmap (bed_t *doc, view_data_t *view, GdkWindow *window);
  96 }
  97
  98 static void
  99 redraw_view (view_data_t *view_data, GdkRectangle *rect)
 100 {
 101   gint width, height;
 102   bed_t *bed = view_data->bed;
 103
 104   g_return_if_fail (view_data->pixmap != NULL);
 105
 106   /*
 107    * Do not draw outside the region that we know how to display
 108    */
 109   if (rect->x > view_data->w)
 110     return;
 111
 112   if (rect->y > view_data->h)
 113     return;
 114
 115   /*
 116    * Clip the draw region
 117    */
 118   if (rect->x + rect->width > view_data->w)
 119     rect->width = view_data->w - rect->x;
 120
 121   if (rect->y + rect->height > view_data->h)
 122     rect->height = view_data->h - rect->y;
 123
 124   /*
 125    * Draw the exposed region.
 126    */
 127   gdk_draw_pixmap (view_data->drawing_area->window,
 128                    view_data->drawing_area->style->white_gc,
 129                    view_data->pixmap,
 130                    rect->x, rect->y,
 131                    rect->x, rect->y,
 132                    rect->width,
 133                    rect->height);
 134 }
 135
 136 static void
 137 render_page (view_data_t *view_data)
 138 {
 139   setup_pixmap (view_data->bed, view_data,
 140                 view_data->win);
 141   view_data->bed->pdf->displayPage(view_data->out,
 142                                    view_data->page, view_data->zoom,
 143                                    0, gTrue);
 144 }
 145
 146 static void
 147 redraw_view_all (view_data_t *view_data)
 148 {
 149   GdkRectangle rect;
 150   g_return_if_fail (view_data != NULL);
 151
 152 #if PDF_DEBUG > 0
 153   printf ("Redraw view of page %d\n", view_data->page);
 154 #endif
 155   render_page (view_data);
 156   rect.x = 0;
 157   rect.y = 0;
 158   rect.width  = view_data->w;
 159   rect.height = view_data->h;
 160   redraw_view (view_data, &rect);
 161   gtk_widget_queue_draw (GTK_WIDGET (view_data->drawing_area));
 162 }
 163
 164 static void
 165 configure_size (view_data_t *view_data)
 166 {
 167   gtk_widget_set_usize (
 168     view_data->drawing_area,
 169     view_data->w,
 170     view_data->h);
 171 }
 172
 173 static void
 174 redraw_all (bed_t *bed)
 175 {
 176         GList *l;
 177
 178         for (l = bed->views; l; l = l->next) {
 179           GdkRectangle rect;
 180           view_data_t *view_data = (view_data_t *)l->data;
 181           configure_size (view_data);
 182           redraw_view_all (view_data);
 183         }
 184 }
 185
 186 static int
 187 save_image (GnomePersistStream *ps, GNOME_Stream stream, void *data)
 188 {
 189   g_warning ("Unimplemented");
 190   return -1;
 191 }
 192
 193 /*
 194  * different size ?
 195  */
 196 static gboolean
 197 setup_size (bed_t *doc, view_data_t *view)
 198 {
 199   int      w, h;
 200   gboolean same;
 201
 202   if (!doc || !view || !doc->pdf) {
 203     view->w = 320;
 204     view->h = 200;
 205     return FALSE;
 206   }
 207   w = (int)((doc->pdf->getPageWidth  (view->page) * view->zoom) / 72.0);
 208   h = (int)((doc->pdf->getPageHeight (view->page) * view->zoom) / 72.0);
 209   if (view->w == w && view->h == h)
 210     same = TRUE;
 211   else
 212     same = FALSE;
 213   view->w = w;
 214   view->h = h;
 215
 216   return same;
 217 }
 218
 219 /*
 220  * Loads a PDF from a GNOME_Stream
 221  */
 222 static int
 223 load_image_from_stream (GnomePersistStream *ps, GNOME_Stream stream, void *data)
 224 {
 225         bed_t *bed = (bed_t *)data;
 226         CORBA_long length;
 227         GNOME_Stream_iobuf *buffer;
 228         guint lp;
 229         #define CHUNK 512
 230         FILE *hack;
 231         char *name;
 232
 233         if (bed->pdf ||
 234             bed->stream) {
 235           g_warning ("Won't overwrite pre-existing stream: you wierdo");
 236           return 0;
 237         }
 238
 239         /* We need this for later */
 240         CORBA_Object_duplicate (stream, &ev);
 241         g_return_val_if_fail (ev._major == CORBA_NO_EXCEPTION, 0);
 242
 243 #if PDF_DEBUG > 0
 244         printf ("Loading PDF from persiststream\n");
 245 #endif
 246         bed->stream = stream;
 247         BonoboStream *bs = new BonoboStream (stream);
 248         GString *st = new GString ("Bonobo.pdf");
 249         bed->pdf = new PDFDoc (bs, st);
 250
 251 #if PDF_DEBUG > 0
 252         printf ("Done load\n");
 253 #endif
 254         if (!(bed->pdf->isOk())) {
 255           g_warning ("Duff pdf data\n");
 256           delete bed->pdf;
 257           bed->pdf = NULL;
 258         }
 259         if (!bed->pdf->getCatalog()) {
 260           g_warning ("Duff pdf catalog\n");
 261           delete bed->pdf;
 262           bed->pdf = NULL;
 263         }
 264
 265         realize_drawing_areas (bed);
 266         redraw_all (bed);
 267         return 0;
 268 }
 269
 270 extern "C" {
 271
 272   static void
 273   destroy_view (GnomeView *view, view_data_t *view_data)
 274   {
 275     view_data->bed->views = g_list_remove (view_data->bed->views, view_data);
 276     gtk_object_unref (GTK_OBJECT (view_data->drawing_area));
 277
 278     g_free (view_data);
 279   }
 280
 281   static void
 282   destroy_embed (GnomeView *view, bed_t *bed)
 283   {
 284     while (bed->views)
 285       destroy_view (NULL, (view_data_t *)bed->views->data);
 286
 287     delete bed->pdf;
 288     bed->pdf = NULL;
 289     gtk_object_unref (GTK_OBJECT (bed->stream));
 290     bed->stream = NULL;
 291     g_free (bed);
 292
 293     embeddable_servers--;
 294
 295     if (embeddable_servers == 0){
 296       gnome_object_unref (GNOME_OBJECT (factory));
 297       gtk_main_quit ();
 298     }
 299   }
 300
 301   static void
 302   setup_pixmap (bed_t *doc, view_data_t *view_data, GdkWindow *window)
 303   {
 304     GdkGCValues  gcValues;
 305     GdkGC       *strokeGC;
 306     PDFDoc      *pdf;
 307     int          w, h;
 308     GdkPixmap   *pixmap = NULL;
 309
 310     g_return_if_fail (doc != NULL);
 311     g_return_if_fail (doc->pdf != NULL);
 312     g_return_if_fail (view_data != NULL);
 313
 314     pdf = doc->pdf;
 315
 316     if (setup_size (doc, view_data) &&
 317         view_data->pixmap) {
 318 #if PDF_DEBUG > 0
 319       printf ("No need to re-init output device\n");
 320 #endif
 321       return;
 322     }
 323
 324     w = view_data->w;
 325     h = view_data->h;
 326
 327     pixmap = gdk_pixmap_new (window, w, h, -1);
 328
 329     gdk_color_white (gtk_widget_get_default_colormap(), &view_data->paper);
 330     view_data->out = new GOutputDev (pixmap, view_data->paper, window);
 331
 332     gdk_color_white (gtk_widget_get_default_colormap (), &gcValues.foreground);
 333     gdk_color_black (gtk_widget_get_default_colormap (), &gcValues.background);
 334     gcValues.line_width = 1;
 335     gcValues.line_style = GDK_LINE_SOLID;
 336     strokeGC = gdk_gc_new_with_values (
 337       pixmap, &gcValues,
 338       (enum GdkGCValuesMask)(GDK_GC_FOREGROUND | GDK_GC_BACKGROUND | GDK_GC_LINE_WIDTH | GDK_GC_LINE_STYLE));
 339
 340     gdk_draw_rectangle (pixmap, strokeGC,
 341                         TRUE, 0, 0,
 342                         w, h);
 343
 344     view_data->pixmap = pixmap;
 345   }
 346
 347   static gboolean
 348   view_is_good (view_data_t *view_data)
 349   {
 350     if (!view_data ||
 351         !view_data->bed ||
 352         !view_data->bed->pdf)
 353       return FALSE;
 354
 355     return TRUE;
 356   }
 357
 358   static gboolean
 359   first_page (view_data_t *view_data)
 360   {
 361     g_return_val_if_fail (view_is_good (view_data), FALSE);
 362     if (view_data->page != 1) {
 363       view_data->page = 1;
 364       return TRUE;
 365     } else
 366       return FALSE;
 367   }
 368
 369   static gboolean
 370   last_page (view_data_t *view_data)
 371   {
 372     g_return_val_if_fail (view_is_good (view_data), FALSE);
 373     if (view_data->page < view_data->bed->pdf->getNumPages()) {
 374       view_data->page = view_data->bed->pdf->getNumPages();
 375       return TRUE;
 376     } else
 377       return FALSE;
 378   }
 379
 380   static gboolean
 381   next_page (view_data_t *view_data)
 382   {
 383     g_return_val_if_fail (view_is_good (view_data), FALSE);
 384     if (view_data->page < view_data->bed->pdf->getNumPages()) {
 385       view_data->page++;
 386       return TRUE;
 387     } else
 388       return FALSE;
 389   }
 390
 391   static gboolean
 392   prev_page (view_data_t *view_data)
 393   {
 394     g_return_val_if_fail (view_is_good (view_data), FALSE);
 395     if (view_data->page > 1) {
 396       view_data->page--;
 397       return TRUE;
 398     } else
 399       return FALSE;
 400   }
 401
 402   static void
 403   page_first_cb (GnomeUIHandler *uih, void *data, char *path)
 404   {
 405     first_page ((view_data_t *)data);
 406     redraw_view_all ((view_data_t *)data);
 407   }
 408
 409   static void
 410   page_next_cb  (GnomeUIHandler *uih, void *data, char *path)
 411   {
 412     next_page ((view_data_t *)data);
 413     redraw_view_all ((view_data_t *)data);
 414   }
 415
 416   static void
 417   page_prev_cb  (GnomeUIHandler *uih, void *data, char *path)
 418   {
 419     prev_page ((view_data_t *)data);
 420     redraw_view_all ((view_data_t *)data);
 421   }
 422
 423   static void
 424   page_last_cb  (GnomeUIHandler *uih, void *data, char *path)
 425   {
 426     last_page ((view_data_t *)data);
 427     redraw_view_all ((view_data_t *)data);
 428   }
 429 }
 430
 431 static void
 432 view_create_menus (view_data_t *view_data)
 433 {
 434   GNOME_UIHandler remote_uih;
 435   GnomeView *view = view_data->view;
 436   GnomeUIHandler *uih;
 437
 438   uih = gnome_view_get_ui_handler (view);
 439   remote_uih = gnome_view_get_remote_ui_handler (view);
 440
 441   if (remote_uih == CORBA_OBJECT_NIL) {
 442     g_warning ("server has no UI hander");
 443     return;
 444   }
 445
 446   gnome_ui_handler_set_container (uih, remote_uih);
 447
 448   gnome_ui_handler_menu_new_subtree (uih, "/Page",
 449                                      N_("Page..."),
 450                                      N_("Set the currently displayed page"),
 451                                      1,
 452                                      GNOME_UI_HANDLER_PIXMAP_NONE, NULL,
 453                                      0, (GdkModifierType)0);
 454
 455   gnome_ui_handler_menu_new_item (uih, "/Page/First",
 456                                   N_("First"), N_("View the first page"), -1,
 457                                   GNOME_UI_HANDLER_PIXMAP_NONE, NULL, 0,
 458                                   (GdkModifierType)0, page_first_cb, (gpointer)view_data);
 459
 460   gnome_ui_handler_menu_new_item (uih, "/Page/Prev",
 461                                   N_("Previous"), N_("View the previous page"), -1,
 462                                   GNOME_UI_HANDLER_PIXMAP_NONE, NULL, 0,
 463                                   (GdkModifierType)0, page_prev_cb, (gpointer)view_data);
 464
 465   gnome_ui_handler_menu_new_item (uih, "/Page/Next",
 466                                   N_("Next"), N_("View the next page"), -1,
 467                                   GNOME_UI_HANDLER_PIXMAP_NONE, NULL, 0,
 468                                   (GdkModifierType)0, page_next_cb, (gpointer)view_data);
 469
 470   gnome_ui_handler_menu_new_item (uih, "/Page/Last",
 471                                   N_("Last"), N_("View the last page"), -1,
 472                                   GNOME_UI_HANDLER_PIXMAP_NONE, NULL, 0,
 473                                   (GdkModifierType)0, page_last_cb, (gpointer)view_data);
 474 #if UNTESTED > 0
 475   gnome_ui_handler_toolbar_new_item (uih, "/First", GNOME_UI_HANDLER_MENU_ITEM,
 476                                      N_("First"), N_("View the first page"), -1,
 477                                      GNOME_UI_HANDLER_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_FIRST,
 478                                      0, (GdkModifierType)0, page_first_cb, (gpointer)view_data);
 479   gnome_ui_handler_toolbar_new_item (uih, "/Prev", GNOME_UI_HANDLER_MENU_ITEM,
 480                                      N_("Previous"), N_("View the previous page"), -1,
 481                                      GNOME_UI_HANDLER_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_FIRST,
 482                                      0, (GdkModifierType)0, page_prev_cb, (gpointer)view_data);
 483   gnome_ui_handler_toolbar_new_item (uih, "/Next", GNOME_UI_HANDLER_MENU_ITEM,
 484                                      N_("Next"), N_("View the next page"), -1,
 485                                      GNOME_UI_HANDLER_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_FIRST,
 486                                      0, (GdkModifierType)0, page_next_cb, (gpointer)view_data);
 487   gnome_ui_handler_toolbar_new_item (uih, "/Last", GNOME_UI_HANDLER_MENU_ITEM,
 488                                      N_("Last"), N_("View the last page"), -1,
 489                                      GNOME_UI_HANDLER_PIXMAP_STOCK, GNOME_STOCK_PIXMAP_FIRST,
 490                                      0, (GdkModifierType)0, page_last_cb, (gpointer)view_data);
 491 #endif
 492
 493 }
 494
 495 /*
 496  * When this view is deactivated, we must remove our menu items.
 497  */
 498 static void
 499 view_remove_menus (view_data_t *view_data)
 500 {
 501         GnomeView *view = view_data->view;
 502         GnomeUIHandler *uih;
 503
 504         uih = gnome_view_get_ui_handler (view);
 505
 506         gnome_ui_handler_unset_container (uih);
 507 }
 508
 509 extern "C" {
 510
 511   static void
 512   drawing_area_realize (GtkWidget *drawing_area, view_data_t *view_data)
 513   {
 514     g_return_if_fail (view_data != NULL);
 515     g_return_if_fail (drawing_area != NULL);
 516
 517     view_data->win = gtk_widget_get_parent_window (drawing_area);
 518   }
 519
 520   static int
 521   drawing_area_exposed (GtkWidget *widget, GdkEventExpose *event, view_data_t *view_data)
 522   {
 523     if (!view_data ||
 524         !view_data->bed->pdf)
 525       return TRUE;
 526
 527     redraw_view (view_data, &event->area);
 528
 529     return TRUE;
 530   }
 531
 532   static void
 533   view_activate (GnomeView *view, gboolean activate, gpointer data)
 534   {
 535     view_data_t *view_data = (view_data_t *) data;
 536     g_return_if_fail (view != NULL);
 537     g_return_if_fail (view_data != NULL);
 538
 539     gnome_view_activate_notify (view, activate);
 540
 541 #if PDF_DEBUG > 0
 542     printf ("View change activation to %d\n", activate);
 543 #endif
 544     /*
 545      * If we were just activated, we merge in our menu entries.
 546      * If we were just deactivated, we remove them.
 547      */
 548     if (activate)
 549       view_create_menus (view_data);
 550     else
 551       view_remove_menus (view_data);
 552   }
 553
 554   static void
 555   view_size_query (GnomeView *view, int *desired_width, int *desired_height,
 556                    gpointer data)
 557   {
 558     view_data_t *view_data = (view_data_t *) data;
 559
 560     g_return_if_fail (view_data != NULL);
 561
 562     *desired_width  = view_data->w;
 563     *desired_height = view_data->h;
 564   }
 565
 566   static void
 567   view_zoom_query (GnomeView *view, gdouble new_zoom, gpointer data)
 568   {
 569     view_data_t *view_data = (view_data_t *) data;
 570
 571     g_return_if_fail (view_data != NULL);
 572
 573     view_data->zoom = new_zoom;
 574
 575     redraw_view_all (view_data);
 576   }
 577
 578   static void
 579   realize_drawing_areas (bed_t *bed)
 580   {
 581     GList *l;
 582
 583     for (l = bed->views; l; l = l->next) {
 584       view_data_t *view_data = (view_data_t *)l->data;
 585       g_return_if_fail (view_data->win);
 586       render_page (view_data);
 587       configure_size (view_data);
 588     }
 589   }
 590
 591   static void
 592   view_switch_page (GnomeView *view, const char *verb_name, void *user_data)
 593   {
 594     view_data_t  *view_data = (view_data_t *) user_data;
 595     GdkRectangle  rect;
 596     gboolean      changed = FALSE;
 597
 598     if (!g_strcasecmp (verb_name, "firstpage")) {
 599       changed = first_page (view_data);
 600     } else if (!g_strcasecmp (verb_name, "prevpage")) {
 601       changed = prev_page (view_data);
 602     } else if (!g_strcasecmp (verb_name, "nextpage")) {
 603       changed = next_page (view_data);
 604     } else if (!g_strcasecmp (verb_name, "lastpage")) {
 605       changed = last_page (view_data);
 606     } else
 607       g_warning ("Unknown verb");
 608
 609     if (changed) {
 610       render_page (view_data);
 611       redraw_view (view_data, &rect);
 612       gtk_widget_queue_draw (GTK_WIDGET (view_data->drawing_area));
 613     }
 614   }
 615 }
 616
 617 static GnomeView *
 618 view_factory (GnomeEmbeddable *embeddable,
 619               const GNOME_ViewFrame view_frame,
 620               void *data)
 621 {
 622         GnomeView *view;
 623         GnomeUIHandler *uih;
 624         bed_t *bed = (bed_t *)data;
 625         view_data_t *view_data = g_new (view_data_t, 1);
 626
 627 #if PDF_DEBUG > 0
 628         printf ("Created new bonobo object view %p\n", view_data);
 629 #endif
 630
 631         view_data->scale  = 1.0;
 632         view_data->bed    = bed;
 633         view_data->drawing_area = gtk_drawing_area_new ();
 634         view_data->pixmap = NULL;
 635         view_data->win    = NULL;
 636         view_data->out    = NULL;
 637         view_data->w      = 320;
 638         view_data->h      = 320;
 639         view_data->zoom   = 43.0; /* 86.0; Must be small for demos :-) */
 640         view_data->page   = 1;
 641
 642         gtk_signal_connect (
 643                 GTK_OBJECT (view_data->drawing_area),
 644                 "realize",
 645                 GTK_SIGNAL_FUNC (drawing_area_realize), view_data);
 646
 647         gtk_signal_connect (
 648                 GTK_OBJECT (view_data->drawing_area),
 649                 "expose_event",
 650                 GTK_SIGNAL_FUNC (drawing_area_exposed), view_data);
 651
 652         gtk_widget_show (view_data->drawing_area);
 653
 654         setup_size (bed, view_data);
 655
 656         view = gnome_view_new (view_data->drawing_area);
 657         view_data->view = view;
 658
 659         gtk_signal_connect (
 660                 GTK_OBJECT (view), "destroy",
 661                 GTK_SIGNAL_FUNC (destroy_view), view_data);
 662
 663         /* UI handling */
 664         uih = gnome_ui_handler_new ();
 665         gnome_view_set_ui_handler (view, uih);
 666
 667         gtk_signal_connect (GTK_OBJECT (view), "view_activate",
 668                             GTK_SIGNAL_FUNC (view_activate), view_data);
 669
 670         gtk_signal_connect (GTK_OBJECT (view), "size_query",
 671                             GTK_SIGNAL_FUNC (view_size_query), view_data);
 672
 673         gtk_signal_connect (GTK_OBJECT (view), "set_zoom_factor",
 674                             GTK_SIGNAL_FUNC (view_zoom_query), view_data);
 675
 676         bed->views = g_list_prepend (bed->views, view_data);
 677
 678         /* Verb handling */
 679         gnome_view_register_verb (view, "FirstPage",
 680                                   view_switch_page, view_data);
 681         gnome_view_register_verb (view, "PrevPage",
 682                                   view_switch_page, view_data);
 683         gnome_view_register_verb (view, "NextPage",
 684                                   view_switch_page, view_data);
 685         gnome_view_register_verb (view, "LastPage",
 686                                   view_switch_page, view_data);
 687
 688         return view;
 689 }
 690
 691 static GnomeObject *
 692 embeddable_factory (GnomeEmbeddableFactory *This, void *data)
 693 {
 694         GnomeEmbeddable *embeddable;
 695         GnomePersistStream *stream;
 696         bed_t *bed = (bed_t *)data;
 697
 698         bed = g_new0 (bed_t, 1);
 699         if (!bed)
 700                 return NULL;
 701
 702 #if PDF_DEBUG > 0
 703         printf ("Created new bonobo object %p\n", bed);
 704 #endif
 705         /*
 706          * Creates the BonoboObject server
 707          */
 708         embeddable = gnome_embeddable_new (view_factory, bed);
 709         if (embeddable == NULL){
 710                 g_free (bed);
 711                 return NULL;
 712         }
 713
 714         bed->pdf = NULL;
 715
 716         /*
 717          * Interface GNOME::PersistStream
 718          */
 719         stream = gnome_persist_stream_new ("bonobo-object:image-x-pdf",
 720                                            load_image_from_stream,
 721                                            save_image,
 722                                            bed);
 723         if (stream == NULL) {
 724                 gtk_object_unref (GTK_OBJECT (embeddable));
 725                 g_free (bed);
 726                 return NULL;
 727         }
 728
 729         bed->embeddable = embeddable;
 730
 731         /*
 732          * Bind the interfaces
 733          */
 734         gnome_object_add_interface (GNOME_OBJECT (embeddable),
 735                                     GNOME_OBJECT (stream));
 736         gtk_signal_connect (
 737           GTK_OBJECT (embeddable), "destroy",
 738           GTK_SIGNAL_FUNC (destroy_embed), bed);
 739
 740         embeddable_servers++;
 741
 742         /* Setup some verbs */
 743         gnome_embeddable_add_verb (embeddable,
 744                                    "FirstPage",
 745                                    _("_First page"),
 746                                    _("goto the first page"));
 747         gnome_embeddable_add_verb (embeddable,
 748                                    "PrevPage",
 749                                    _("_Previous page"),
 750                                    _("goto the previous page"));
 751         gnome_embeddable_add_verb (embeddable,
 752                                    "NextPage",
 753                                    _("_Next page"),
 754                                    _("goto the next page"));
 755         gnome_embeddable_add_verb (embeddable,
 756                                    "LastPage",
 757                                    _("_Last page"),
 758                                    _("goto the last page"));
 759
 760         return (GnomeObject *) embeddable;
 761 }
 762
 763 static gboolean
 764 init_bonobo_image_x_pdf_factory (void)
 765 {
 766         factory = gnome_embeddable_factory_new (
 767                 "bonobo-object-factory:image-x-pdf",
 768                 embeddable_factory, NULL);
 769
 770         if (factory == NULL)
 771                 return FALSE;
 772         else
 773                 return TRUE;
 774 }
 775
 776 static void
 777 init_server_factory (int argc, char **argv)
 778 {
 779         gnome_CORBA_init_with_popt_table (
 780                 "bonobo-image-x-pdf", "1.0",
 781                 &argc, argv, NULL, 0, NULL, GNORBA_INIT_SERVER_FUNC, &ev);
 782
 783         if (bonobo_init (CORBA_OBJECT_NIL, CORBA_OBJECT_NIL, CORBA_OBJECT_NIL) == FALSE)
 784                 g_error (_("I could not initialize Bonobo"));
 785 }
 786
 787 int
 788 main (int argc, char *argv [])
 789 {
 790   CORBA_exception_init (&ev);
 791
 792   init_server_factory (argc, argv);
 793   if (!init_bonobo_image_x_pdf_factory ()){
 794     fprintf (stderr, "Could not initialize the Bonobo PDF factory\n"
 795                      "probably a server is already running?");
 796     exit (1);
 797   }
 798
 799   errorInit();
 800
 801   initParams (xpdfConfigFile); /* Init font path */
 802
 803   gtk_widget_set_default_colormap (gdk_rgb_get_cmap ());
 804   gtk_widget_set_default_visual (gdk_rgb_get_visual ());
 805
 806   bonobo_main ();
 807
 808   CORBA_exception_free (&ev);
 809
 810   return 0;
 811 }