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