src/extension/internal/pdfinput/pdf-input.cpp

   1  /** \file
   2  * Native PDF import using libpoppler.
   3  *
   4  * Authors:
   5  *   miklos erdelyi
   6  *
   7  * Copyright (C) 2007 Authors
   8  *
   9  * Released under GNU GPL, read the file 'COPYING' for more information
  10  *
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include <config.h>
  15 #endif
  16
  17 #ifdef HAVE_POPPLER
  18
  19 #include "goo/GooString.h"
  20 #include "ErrorCodes.h"
  21 #include "GlobalParams.h"
  22 #include "PDFDoc.h"
  23 #include "Page.h"
  24 #include "Catalog.h"
  25
  26 #include "pdf-input.h"
  27 #include "extension/system.h"
  28 #include "extension/input.h"
  29 #include "svg-builder.h"
  30 #include "pdf-parser.h"
  31
  32 #include "document-private.h"
  33
  34 #include <gtk/gtkdialog.h>
  35
  36 namespace Inkscape {
  37 namespace Extension {
  38 namespace Internal {
  39
  40 /**
  41  * \brief The PDF import dialog
  42  * FIXME: Probably this should be placed into src/ui/dialog
  43  */
  44
  45 static Glib::ustring crop_setting_choices[] = {
  46     Glib::ustring(_("media box")),
  47     Glib::ustring(_("crop box")),
  48     Glib::ustring(_("trim box")),
  49     Glib::ustring(_("bleed box")),
  50     Glib::ustring(_("art box"))
  51 };
  52
  53 PdfImportDialog::PdfImportDialog(PDFDoc *doc)
  54 {
  55
  56     _pdf_doc = doc;
  57
  58     cancelbutton = Gtk::manage(new class Gtk::Button(Gtk::StockID("gtk-cancel")));
  59     okbutton = Gtk::manage(new class Gtk::Button(Gtk::StockID("gtk-ok")));
  60     _labelSelect = Gtk::manage(new class Gtk::Label(_("Select page:")));
  61
  62     // Page number
  63     Gtk::Adjustment *_pageNumberSpin_adj = Gtk::manage(
  64             new class Gtk::Adjustment(1, 1, _pdf_doc->getNumPages(), 1, 10, 0));
  65     _pageNumberSpin = Gtk::manage(new class Gtk::SpinButton(*_pageNumberSpin_adj, 1, 1));
  66     hbox2 = Gtk::manage(new class Gtk::HBox(false, 0));
  67
  68     // Crop settings
  69     _cropCheck = Gtk::manage(new class Gtk::CheckButton(_("Crop to:")));
  70     _cropTypeCombo = Gtk::manage(new class Gtk::ComboBoxText());
  71     int num_crop_choices = sizeof(crop_setting_choices) / sizeof(crop_setting_choices[0]);
  72     for ( int i = 0 ; i < num_crop_choices ; i++ ) {
  73         _cropTypeCombo->append_text(crop_setting_choices[i]);
  74     }
  75     _cropTypeCombo->set_active_text(crop_setting_choices[0]);
  76     _cropTypeCombo->set_sensitive(false);
  77
  78     hbox3 = Gtk::manage(new class Gtk::HBox(false, 0));
  79     vbox2 = Gtk::manage(new class Gtk::VBox(false, 0));
  80     alignment3 = Gtk::manage(new class Gtk::Alignment(0.5, 0.5, 1, 1));
  81     _labelPageSettings = Gtk::manage(new class Gtk::Label(_("Page Settings")));
  82     _pageSettingsFrame = Gtk::manage(new class Gtk::Frame());
  83     _labelPrecision = Gtk::manage(new class Gtk::Label(_("Precision of approximation for gradient meshes:")));
  84
  85     _fallbackPrecisionSlider_adj = Gtk::manage(new class Gtk::Adjustment(2, 1, 256, 1, 10, 10));
  86     _fallbackPrecisionSlider = Gtk::manage(new class Gtk::HScale(*_fallbackPrecisionSlider_adj));
  87     _fallbackPrecisionSlider->set_value(2.0);
  88     _labelPrecisionComment = Gtk::manage(new class Gtk::Label(_("rough")));
  89     hbox6 = Gtk::manage(new class Gtk::HBox(false, 0));
  90
  91     // Text options
  92     _labelText = Gtk::manage(new class Gtk::Label(_("Text handling:")));
  93     _textHandlingCombo = Gtk::manage(new class Gtk::ComboBoxText());
  94     _textHandlingCombo->append_text(_("import text as text"));
  95     _textHandlingCombo->set_active_text(_("import text as text"));
  96
  97     hbox5 = Gtk::manage(new class Gtk::HBox(false, 0));
  98     _embedImagesCheck = Gtk::manage(new class Gtk::CheckButton(_("Embed images")));
  99     vbox3 = Gtk::manage(new class Gtk::VBox(false, 0));
 100     alignment4 = Gtk::manage(new class Gtk::Alignment(0.5, 0.5, 1, 1));
 101     _labelImportSettings = Gtk::manage(new class Gtk::Label(_("Import Settings")));
 102     _importSettingsFrame = Gtk::manage(new class Gtk::Frame());
 103     vbox1 = Gtk::manage(new class Gtk::VBox(false, 0));
 104     _previewArea = Gtk::manage(new class Gtk::DrawingArea());
 105     hbox1 = Gtk::manage(new class Gtk::HBox(false, 0));
 106     cancelbutton->set_flags(Gtk::CAN_FOCUS);
 107     cancelbutton->set_flags(Gtk::CAN_DEFAULT);
 108     cancelbutton->set_relief(Gtk::RELIEF_NORMAL);
 109     okbutton->set_flags(Gtk::CAN_FOCUS);
 110     okbutton->set_flags(Gtk::CAN_DEFAULT);
 111     okbutton->set_relief(Gtk::RELIEF_NORMAL);
 112     this->get_action_area()->property_layout_style().set_value(Gtk::BUTTONBOX_END);
 113     _labelSelect->set_alignment(0.5,0.5);
 114     _labelSelect->set_padding(0,0);
 115     _labelSelect->set_justify(Gtk::JUSTIFY_LEFT);
 116     _labelSelect->set_line_wrap(false);
 117     _labelSelect->set_use_markup(false);
 118     _labelSelect->set_selectable(false);
 119     _pageNumberSpin->set_flags(Gtk::CAN_FOCUS);
 120     _pageNumberSpin->set_update_policy(Gtk::UPDATE_ALWAYS);
 121     _pageNumberSpin->set_numeric(true);
 122     _pageNumberSpin->set_digits(0);
 123     _pageNumberSpin->set_wrap(false);
 124     hbox2->pack_start(*_labelSelect, Gtk::PACK_SHRINK, 0);
 125     hbox2->pack_start(*_pageNumberSpin, Gtk::PACK_SHRINK, 4);
 126     _cropCheck->set_flags(Gtk::CAN_FOCUS);
 127     _cropCheck->set_relief(Gtk::RELIEF_NORMAL);
 128     _cropCheck->set_mode(true);
 129     _cropCheck->set_active(false);
 130     _cropTypeCombo->set_border_width(1);
 131     hbox3->pack_start(*_cropCheck, Gtk::PACK_SHRINK, 0);
 132     hbox3->pack_start(*_cropTypeCombo, Gtk::PACK_SHRINK, 4);
 133     vbox2->pack_start(*hbox2);
 134     vbox2->pack_start(*hbox3);
 135     alignment3->add(*vbox2);
 136     _labelPageSettings->set_alignment(0.5,0.5);
 137     _labelPageSettings->set_padding(0,0);
 138     _labelPageSettings->set_justify(Gtk::JUSTIFY_LEFT);
 139     _labelPageSettings->set_line_wrap(false);
 140     _labelPageSettings->set_use_markup(true);
 141     _labelPageSettings->set_selectable(false);
 142     _pageSettingsFrame->set_border_width(4);
 143     _pageSettingsFrame->set_shadow_type(Gtk::SHADOW_ETCHED_IN);
 144     _pageSettingsFrame->set_label_align(0,0.5);
 145     _pageSettingsFrame->add(*alignment3);
 146     _pageSettingsFrame->set_label_widget(*_labelPageSettings);
 147     _labelPrecision->set_alignment(0.5,0.5);
 148     _labelPrecision->set_padding(0,0);
 149     _labelPrecision->set_justify(Gtk::JUSTIFY_LEFT);
 150     _labelPrecision->set_line_wrap(false);
 151     _labelPrecision->set_use_markup(false);
 152     _labelPrecision->set_selectable(false);
 153     _fallbackPrecisionSlider->set_size_request(180,-1);
 154     _fallbackPrecisionSlider->set_flags(Gtk::CAN_FOCUS);
 155     _fallbackPrecisionSlider->set_update_policy(Gtk::UPDATE_CONTINUOUS);
 156     _fallbackPrecisionSlider->set_inverted(false);
 157     _fallbackPrecisionSlider->set_digits(1);
 158     _fallbackPrecisionSlider->set_draw_value(true);
 159     _fallbackPrecisionSlider->set_value_pos(Gtk::POS_TOP);
 160     _labelPrecisionComment->set_size_request(90,-1);
 161     _labelPrecisionComment->set_alignment(0.5,0.5);
 162     _labelPrecisionComment->set_padding(0,0);
 163     _labelPrecisionComment->set_justify(Gtk::JUSTIFY_LEFT);
 164     _labelPrecisionComment->set_line_wrap(false);
 165     _labelPrecisionComment->set_use_markup(false);
 166     _labelPrecisionComment->set_selectable(false);
 167     hbox6->pack_start(*_fallbackPrecisionSlider, Gtk::PACK_SHRINK, 4);
 168     hbox6->pack_start(*_labelPrecisionComment, Gtk::PACK_SHRINK, 4);
 169     _labelText->set_alignment(0.5,0.5);
 170     _labelText->set_padding(0,0);
 171     _labelText->set_justify(Gtk::JUSTIFY_LEFT);
 172     _labelText->set_line_wrap(false);
 173     _labelText->set_use_markup(false);
 174     _labelText->set_selectable(false);
 175     hbox5->pack_start(*_labelText, Gtk::PACK_SHRINK, 0);
 176     hbox5->pack_start(*_textHandlingCombo, Gtk::PACK_SHRINK, 0);
 177     _embedImagesCheck->set_flags(Gtk::CAN_FOCUS);
 178     _embedImagesCheck->set_relief(Gtk::RELIEF_NORMAL);
 179     _embedImagesCheck->set_mode(true);
 180     _embedImagesCheck->set_active(true);
 181     vbox3->pack_start(*_labelPrecision, Gtk::PACK_SHRINK, 4);
 182     vbox3->pack_start(*hbox6, Gtk::PACK_SHRINK, 0);
 183     vbox3->pack_start(*hbox5);
 184     vbox3->pack_start(*_embedImagesCheck, Gtk::PACK_SHRINK, 0);
 185     alignment4->add(*vbox3);
 186     _labelImportSettings->set_alignment(0.5,0.5);
 187     _labelImportSettings->set_padding(0,0);
 188     _labelImportSettings->set_justify(Gtk::JUSTIFY_LEFT);
 189     _labelImportSettings->set_line_wrap(false);
 190     _labelImportSettings->set_use_markup(true);
 191     _labelImportSettings->set_selectable(false);
 192     _importSettingsFrame->set_border_width(4);
 193     _importSettingsFrame->set_shadow_type(Gtk::SHADOW_ETCHED_IN);
 194     _importSettingsFrame->set_label_align(0,0.5);
 195     _importSettingsFrame->add(*alignment4);
 196     _importSettingsFrame->set_label_widget(*_labelImportSettings);
 197     vbox1->pack_start(*_pageSettingsFrame, Gtk::PACK_EXPAND_PADDING, 0);
 198     vbox1->pack_start(*_importSettingsFrame, Gtk::PACK_EXPAND_PADDING, 0);
 199     hbox1->pack_start(*vbox1);
 200     hbox1->pack_start(*_previewArea, Gtk::PACK_EXPAND_WIDGET, 4);
 201     this->get_vbox()->set_homogeneous(false);
 202     this->get_vbox()->set_spacing(0);
 203     this->get_vbox()->pack_start(*hbox1);
 204     this->set_title(_("PDF Import Settings"));
 205     this->set_modal(true);
 206     this->property_window_position().set_value(Gtk::WIN_POS_NONE);
 207     this->set_resizable(true);
 208     this->property_destroy_with_parent().set_value(false);
 209     this->set_has_separator(true);
 210     this->add_action_widget(*cancelbutton, -6);
 211     this->add_action_widget(*okbutton, -5);
 212     cancelbutton->show();
 213     okbutton->show();
 214     _labelSelect->show();
 215     _pageNumberSpin->show();
 216     hbox2->show();
 217     _cropCheck->show();
 218     _cropTypeCombo->show();
 219     hbox3->show();
 220     vbox2->show();
 221     alignment3->show();
 222     _labelPageSettings->show();
 223     _pageSettingsFrame->show();
 224     _labelPrecision->show();
 225     _fallbackPrecisionSlider->show();
 226     _labelPrecisionComment->show();
 227     hbox6->show();
 228     _labelText->show();
 229     _textHandlingCombo->show();
 230     hbox5->show();
 231     _embedImagesCheck->show();
 232     vbox3->show();
 233     alignment4->show();
 234     _labelImportSettings->show();
 235     _importSettingsFrame->show();
 236     vbox1->show();
 237     _previewArea->show();
 238     hbox1->show();
 239
 240     // Connect signals
 241     _previewArea->signal_expose_event().connect(sigc::mem_fun(*this, &PdfImportDialog::_onExposePreview));
 242     _pageNumberSpin_adj->signal_value_changed().connect(sigc::mem_fun(*this, &PdfImportDialog::_onPageNumberChanged));
 243     _cropCheck->signal_toggled().connect(sigc::mem_fun(*this, &PdfImportDialog::_onToggleCropping));
 244     _fallbackPrecisionSlider_adj->signal_value_changed().connect(sigc::mem_fun(*this, &PdfImportDialog::_onPrecisionChanged));
 245
 246 #ifdef HAVE_POPPLER_CAIRO
 247     // Create an OutputDev
 248     _preview_output_dev = new CairoOutputDev();
 249     _preview_output_dev->startDoc(_pdf_doc->getXRef());
 250     _cairo_surface = NULL;
 251 #endif
 252
 253     // Set default preview size
 254     _preview_width = 200;
 255     _preview_height = 300;
 256
 257     // Init preview
 258     _thumb_data = NULL;
 259     _pageNumberSpin_adj->set_value(1.0);
 260 }
 261
 262 PdfImportDialog::~PdfImportDialog() {
 263 #ifdef HAVE_POPPLER_CAIRO
 264     if (_preview_output_dev) {
 265         delete _preview_output_dev;
 266     }
 267     if (_cairo_surface) {
 268         cairo_surface_destroy(_cairo_surface);
 269     }
 270 #endif
 271     if (_thumb_data) {
 272         delete _thumb_data;
 273     }
 274 }
 275
 276 bool PdfImportDialog::showDialog() {
 277     show();
 278     gint b = run();
 279     hide();
 280     if ( b == Gtk::RESPONSE_OK ) {
 281         return TRUE;
 282     } else {
 283         return FALSE;
 284     }
 285 }
 286
 287 int PdfImportDialog::getSelectedPage() {
 288     return _current_page;
 289 }
 290
 291 /**
 292  * \brief Retrieves the current settings into a repr which SvgBuilder will use
 293  *        for determining the behaviour desired by the user
 294  */
 295 void PdfImportDialog::getImportSettings(Inkscape::XML::Node *prefs) {
 296     sp_repr_set_svg_double(prefs, "selectedPage", (double)_current_page);
 297     if (_cropCheck->get_active()) {
 298         Glib::ustring current_choice = _cropTypeCombo->get_active_text();
 299         int num_crop_choices = sizeof(crop_setting_choices) / sizeof(crop_setting_choices[0]);
 300         int i = 0;
 301         for ( ; i < num_crop_choices ; i++ ) {
 302             if ( current_choice == crop_setting_choices[i] ) {
 303                 break;
 304             }
 305         }
 306         sp_repr_set_svg_double(prefs, "cropTo", (double)i);
 307     } else {
 308         sp_repr_set_svg_double(prefs, "cropTo", -1.0);
 309     }
 310     sp_repr_set_svg_double(prefs, "approximationPrecision",
 311                            _fallbackPrecisionSlider->get_value());
 312     if (_embedImagesCheck->get_active()) {
 313         prefs->setAttribute("embedImages", "1");
 314     } else {
 315         prefs->setAttribute("embedImages", "0");
 316     }
 317 }
 318
 319 /**
 320  * \brief Redisplay the comment on the current approximation precision setting
 321  * Evenly divides the interval of possible values between the available labels.
 322  */
 323 void PdfImportDialog::_onPrecisionChanged() {
 324
 325     static Glib::ustring precision_comments[] = {
 326         Glib::ustring(_("rough")),
 327         Glib::ustring(_("medium")),
 328         Glib::ustring(_("fine")),
 329         Glib::ustring(_("very fine"))
 330     };
 331
 332     double min = _fallbackPrecisionSlider_adj->get_lower();
 333     double max = _fallbackPrecisionSlider_adj->get_upper();
 334     int num_intervals = sizeof(precision_comments) / sizeof(precision_comments[0]);
 335     double interval_len = ( max - min ) / (double)num_intervals;
 336     double value = _fallbackPrecisionSlider_adj->get_value();
 337     int comment_idx = (int)floor( ( value - min ) / interval_len );
 338     _labelPrecisionComment->set_label(precision_comments[comment_idx]);
 339 }
 340
 341 void PdfImportDialog::_onToggleCropping() {
 342     _cropTypeCombo->set_sensitive(_cropCheck->get_active());
 343 }
 344
 345 void PdfImportDialog::_onPageNumberChanged() {
 346     int page = _pageNumberSpin->get_value_as_int();
 347     _current_page = CLAMP(page, 1, _pdf_doc->getCatalog()->getNumPages());
 348     _setPreviewPage(_current_page);
 349 }
 350
 351 #ifdef HAVE_POPPLER_CAIRO
 352 /**
 353  * \brief Copies image data from a Cairo surface to a pixbuf
 354  *
 355  * Borrowed from libpoppler, from the file poppler-page.cc
 356  * Copyright (C) 2005, Red Hat, Inc.
 357  *
 358  */
 359 static void copy_cairo_surface_to_pixbuf (cairo_surface_t *surface,
 360                                           unsigned char   *data,
 361                                           GdkPixbuf       *pixbuf)
 362 {
 363     int cairo_width, cairo_height, cairo_rowstride;
 364     unsigned char *pixbuf_data, *dst, *cairo_data;
 365     int pixbuf_rowstride, pixbuf_n_channels;
 366     unsigned int *src;
 367     int x, y;
 368
 369     cairo_width = cairo_image_surface_get_width (surface);
 370     cairo_height = cairo_image_surface_get_height (surface);
 371     cairo_rowstride = cairo_width * 4;
 372     cairo_data = data;
 373
 374     pixbuf_data = gdk_pixbuf_get_pixels (pixbuf);
 375     pixbuf_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
 376     pixbuf_n_channels = gdk_pixbuf_get_n_channels (pixbuf);
 377
 378     if (cairo_width > gdk_pixbuf_get_width (pixbuf))
 379         cairo_width = gdk_pixbuf_get_width (pixbuf);
 380     if (cairo_height > gdk_pixbuf_get_height (pixbuf))
 381         cairo_height = gdk_pixbuf_get_height (pixbuf);
 382     for (y = 0; y < cairo_height; y++)
 383     {
 384         src = (unsigned int *) (cairo_data + y * cairo_rowstride);
 385         dst = pixbuf_data + y * pixbuf_rowstride;
 386         for (x = 0; x < cairo_width; x++)
 387         {
 388             dst[0] = (*src >> 16) & 0xff;
 389             dst[1] = (*src >> 8) & 0xff;
 390             dst[2] = (*src >> 0) & 0xff;
 391             if (pixbuf_n_channels == 4)
 392                 dst[3] = (*src >> 24) & 0xff;
 393             dst += pixbuf_n_channels;
 394             src++;
 395         }
 396     }
 397 }
 398 #endif
 399
 400 /**
 401  * \brief Updates the preview area with the previously rendered thumbnail
 402  */
 403 bool PdfImportDialog::_onExposePreview(GdkEventExpose *event) {
 404
 405 #ifdef HAVE_POPPLER_CAIRO
 406     Glib::RefPtr<Gdk::Pixbuf> thumb = Gdk::Pixbuf::create(Gdk::COLORSPACE_RGB, true,
 407             8, _thumb_width, _thumb_height);
 408     // Set background to white
 409     thumb->fill(0xffffffff);
 410     Glib::RefPtr<Gdk::Pixmap> back_pixmap = Gdk::Pixmap::create(_previewArea->get_window(),
 411             _thumb_width, _thumb_height, -1);
 412     back_pixmap->draw_pixbuf(Glib::RefPtr<Gdk::GC>(), thumb, 0, 0, 0, 0,
 413                              static_cast<int>(_thumb_width),
 414                              static_cast<int>(_thumb_height),
 415                              Gdk::RGB_DITHER_NONE, 0, 0);
 416     _previewArea->get_window()->set_back_pixmap(back_pixmap, false);
 417     _previewArea->get_window()->clear();
 418     // Copy the thumbnail image from the Cairo surface
 419     copy_cairo_surface_to_pixbuf(_cairo_surface, _thumb_data, thumb->gobj());
 420     _previewArea->get_window()->draw_pixbuf(Glib::RefPtr<Gdk::GC>(), thumb,
 421                                             0, 0, 0, 0, -1, -1,
 422                                             Gdk::RGB_DITHER_NONE, 0, 0);
 423 #endif
 424
 425     return true;
 426 }
 427
 428 /**
 429  * \brief Renders the given page's thumbnail using Cairo
 430  */
 431 void PdfImportDialog::_setPreviewPage(int page) {
 432
 433 #ifdef HAVE_POPPLER_CAIRO
 434     _previewed_page = _pdf_doc->getCatalog()->getPage(page);
 435     // TODO: When available, obtain the thumbnail from the PDF document itself
 436     // Get page size by accounting for rotation
 437     double width, height;
 438     int rotate = _previewed_page->getRotate();
 439     if ( rotate == 90 || rotate == 270 ) {
 440         height = _previewed_page->getCropWidth();
 441         width = _previewed_page->getCropHeight();
 442     } else {
 443         width = _previewed_page->getCropWidth();
 444         height = _previewed_page->getCropHeight();
 445     }
 446     // Calculate the needed scaling for the page
 447     double scale_x = (double)_preview_width / width;
 448     double scale_y = (double)_preview_height / height;
 449     double scale_factor = ( scale_x > scale_y ) ? scale_y : scale_x;
 450     // Create new Cairo surface
 451     _thumb_width = (int)ceil( width * scale_factor );
 452     _thumb_height = (int)ceil( height * scale_factor );
 453     int rowstride = _thumb_width * 4;
 454     if (_thumb_data) {
 455         delete _thumb_data;
 456     }
 457     _thumb_data = new unsigned char[ rowstride * _thumb_height ];
 458     if (_cairo_surface) {
 459         cairo_surface_destroy(_cairo_surface);
 460     }
 461     _cairo_surface = cairo_image_surface_create_for_data(_thumb_data,
 462             CAIRO_FORMAT_ARGB32, _thumb_width, _thumb_height, rowstride);
 463     cairo_t *cr = cairo_create(_cairo_surface);
 464     cairo_scale(cr, scale_factor, scale_factor);    // Use Cairo for resizing the image
 465     _preview_output_dev->setCairo(cr);
 466     // Render page
 467     _previewed_page->displaySlice(_preview_output_dev,
 468                        72.0, 72.0, 0,
 469                        FALSE, /* useMediaBox */
 470                        TRUE, /* crop */
 471                        0, 0,
 472                        (int)ceil(_previewed_page->getCropWidth()),
 473                        (int)ceil(_previewed_page->getCropHeight()),
 474                        FALSE, /* printing */
 475                        _pdf_doc->getCatalog());
 476     // Clean up
 477     _preview_output_dev->setCairo(NULL);
 478     cairo_destroy(cr);
 479     // Redraw preview area
 480     _previewArea->set_size_request(_preview_width, _preview_height);
 481     _previewArea->queue_draw();
 482 #endif
 483 }
 484
 485 ////////////////////////////////////////////////////////////////////////////////
 486
 487 /**
 488  * Parses the selected page of the given PDF document using PdfParser.
 489  */
 490 SPDocument *
 491 PdfInput::open(::Inkscape::Extension::Input * mod, const gchar * uri) {
 492
 493     // Initialize the globalParams variable for poppler
 494     if (!globalParams) {
 495         globalParams = new GlobalParams();
 496     }
 497     GooString *filename_goo = new GooString(uri);
 498     PDFDoc *pdf_doc = new PDFDoc(filename_goo, NULL, NULL, NULL);   // TODO: Could ask for password
 499     if (!pdf_doc->isOk()) {
 500         int error = pdf_doc->getErrorCode();
 501         delete pdf_doc;
 502         if (error == errEncrypted) {
 503             g_message("Document is encrypted.");
 504         } else {
 505             g_message("Failed to load document from data (error %d)", error);
 506         }
 507
 508         return NULL;
 509     }
 510     PdfImportDialog *dlg = new PdfImportDialog(pdf_doc);
 511     if (!dlg->showDialog()) {
 512         delete dlg;
 513         delete pdf_doc;
 514
 515         return NULL;
 516     }
 517
 518     // Get needed page
 519     int page_num = dlg->getSelectedPage();
 520     Catalog *catalog = pdf_doc->getCatalog();
 521     Page *page = catalog->getPage(page_num);
 522
 523     SPDocument *doc = sp_document_new(NULL, TRUE, TRUE);
 524     bool saved = sp_document_get_undo_sensitive(doc);
 525     sp_document_set_undo_sensitive(doc, false); // No need to undo in this temporary document
 526
 527     // Create builder
 528     gchar *docname = g_path_get_basename(uri);
 529     gchar *dot = g_strrstr(docname, ".");
 530     if (dot) {
 531         *dot = 0;
 532     }
 533     SvgBuilder *builder = new SvgBuilder(doc, docname, pdf_doc->getXRef());
 534
 535     // Get preferences
 536     Inkscape::XML::Node *prefs = builder->getPreferences();
 537     dlg->getImportSettings(prefs);
 538
 539     // Apply crop settings
 540     PDFRectangle *clipToBox = NULL;
 541     double crop_setting;
 542     sp_repr_get_double(prefs, "cropTo", &crop_setting);
 543     if ( crop_setting >= 0.0 ) {    // Do page clipping
 544         int crop_choice = (int)crop_setting;
 545         switch (crop_choice) {
 546             case 0: // Media box
 547                 clipToBox = page->getMediaBox();
 548                 break;
 549             case 1: // Crop box
 550                 clipToBox = page->getCropBox();
 551                 break;
 552             case 2: // Bleed box
 553                 clipToBox = page->getBleedBox();
 554                 break;
 555             case 3: // Trim box
 556                 clipToBox = page->getTrimBox();
 557                 break;
 558             case 4: // Art box
 559                 clipToBox = page->getArtBox();
 560                 break;
 561             default:
 562                 break;
 563         }
 564     }
 565
 566     // Create parser
 567     PdfParser *pdf_parser = new PdfParser(pdf_doc->getXRef(), builder, page_num-1, page->getRotate(),
 568                                           page->getResourceDict(), page->getCropBox(), clipToBox);
 569
 570     // Set up approximation precision for parser
 571     double color_delta;
 572     sp_repr_get_double(prefs, "approximationPrecision", &color_delta);
 573     if ( color_delta <= 0.0 ) {
 574         color_delta = 1.0 / 2.0;
 575     } else {
 576         color_delta = 1.0 / color_delta;
 577     }
 578     for ( int i = 1 ; i <= pdfNumShadingTypes ; i++ ) {
 579         pdf_parser->setApproximationPrecision(i, color_delta, 6);
 580     }
 581
 582     // Parse the document structure
 583     Object obj;
 584     page->getContents(&obj);
 585     if (!obj.isNull()) {
 586         pdf_parser->parse(&obj);
 587     }
 588
 589     // Cleanup
 590     obj.free();
 591     delete pdf_parser;
 592     delete builder;
 593     g_free(docname);
 594     delete pdf_doc;
 595
 596     // Restore undo
 597     sp_document_set_undo_sensitive(doc, saved);
 598
 599     return doc;
 600 }
 601
 602 #include "../clear-n_.h"
 603
 604 void
 605 PdfInput::init(void) {
 606     Inkscape::Extension::Extension * ext;
 607
 608     /* PDF in */
 609     ext = Inkscape::Extension::build_from_mem(
 610         "<inkscape-extension>\n"
 611             "<name>PDF Input</name>\n"
 612             "<id>org.inkscape.input.pdf</id>\n"
 613             "<input>\n"
 614                 "<extension>.pdf</extension>\n"
 615                 "<mimetype>application/pdf</mimetype>\n"
 616                 "<filetypename>Adobe PDF (*.pdf) [via poppler]</filetypename>\n"
 617                 "<filetypetooltip>Adobe Portable Document Format</filetypetooltip>\n"
 618             "</input>\n"
 619         "</inkscape-extension>", new PdfInput());
 620
 621     /* AI in */
 622     ext = Inkscape::Extension::build_from_mem(
 623         "<inkscape-extension>\n"
 624             "<name>AI Input</name>\n"
 625             "<id>org.inkscape.input.ai</id>\n"
 626             "<input>\n"
 627                 "<extension>.ai</extension>\n"
 628                 "<mimetype>image/x-adobe-illustrator</mimetype>\n"
 629                 "<filetypename>Adobe Illustrator (*.ai) [PDF-based]</filetypename>\n"
 630                 "<filetypetooltip>Open files saved with recent versions of Adobe Illustrator</filetypetooltip>\n"
 631             "</input>\n"
 632         "</inkscape-extension>", new PdfInput());
 633 } // init
 634
 635 } } }  /* namespace Inkscape, Extension, Implementation */
 636
 637 #endif /* HAVE_POPPLER */
 638
 639 /*
 640   Local Variables:
 641   mode:c++
 642   c-file-style:"stroustrup"
 643   c-file-offsets:((innamespace . 0)(inline-open . 0))
 644   indent-tabs-mode:nil
 645   fill-column:99
 646   End:
 647 */
 648 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :