From 0cd985e2a73949e7eb578c3f067efc93af73e48b Mon Sep 17 00:00:00 2001 From: ishmal Date: Fri, 28 Jul 2006 19:18:18 +0000 Subject: [PATCH] Add Miklos's new Cairo PDF rendering --- src/extension/extension.h | 1 + src/extension/init.cpp | 4 + src/extension/internal/Makefile_insert | 8 +- src/extension/internal/cairo-pdf-out.cpp | 137 +++ src/extension/internal/cairo-pdf-out.h | 46 + src/extension/internal/pdf-cairo.cpp | 1030 ++++++++++++++++++++++ src/extension/internal/pdf-cairo.h | 107 +++ 7 files changed, 1330 insertions(+), 3 deletions(-) create mode 100644 src/extension/internal/cairo-pdf-out.cpp create mode 100644 src/extension/internal/cairo-pdf-out.h create mode 100644 src/extension/internal/pdf-cairo.cpp create mode 100644 src/extension/internal/pdf-cairo.h diff --git a/src/extension/extension.h b/src/extension/extension.h index de3dda19b..81629a2dc 100644 --- a/src/extension/extension.h +++ b/src/extension/extension.h @@ -45,6 +45,7 @@ #define SP_MODULE_KEY_PRINT_PS "org.inkscape.print.ps" /** Defines the key for PDF printing */ #define SP_MODULE_KEY_PRINT_PDF "org.inkscape.print.pdf" +#define SP_MODULE_KEY_PRINT_CAIRO_PDF "org.inkscape.print.pdf.cairo" /** Defines the key for LaTeX printing */ #define SP_MODULE_KEY_PRINT_LATEX "org.inkscape.print.latex" /** Defines the key for printing with GNOME Print */ diff --git a/src/extension/init.cpp b/src/extension/init.cpp index a1833bcde..48ebeff78 100644 --- a/src/extension/init.cpp +++ b/src/extension/init.cpp @@ -26,6 +26,7 @@ #include "internal/svgz.h" #include "internal/ps.h" #include "internal/pdf.h" +#include "internal/pdf-cairo.h" #ifdef WITH_GNOME_PRINT # include "internal/gnome.h" #endif @@ -34,6 +35,7 @@ #endif #include "internal/ps-out.h" #include "internal/pdf-out.h" +#include "internal/cairo-pdf-out.h" #include "internal/pov-out.h" #include "internal/odf.h" #include "internal/latex-pstricks-out.h" @@ -107,6 +109,8 @@ init() Internal::PrintPS::init(); Internal::PdfOutput::init(); Internal::PrintPDF::init(); + Internal::CairoPdfOutput::init(); + Internal::PrintCairoPDF::init(); #ifdef WITH_GNOME_PRINT Internal::PrintGNOME::init(); #endif diff --git a/src/extension/internal/Makefile_insert b/src/extension/internal/Makefile_insert index 834bf0d31..57fd17b36 100644 --- a/src/extension/internal/Makefile_insert +++ b/src/extension/internal/Makefile_insert @@ -14,10 +14,9 @@ endif extension_internal_libinternal_a_SOURCES = \ extension/internal/bluredge.h \ extension/internal/bluredge.cpp \ - extension/internal/clear-n_.h \ + extension/internal/clear-n_.h \ extension/internal/grid.h \ extension/internal/grid.cpp \ -\ extension/internal/gimpgrad.h \ extension/internal/gimpgrad.cpp \ extension/internal/svg.h \ @@ -33,6 +32,10 @@ extension_internal_libinternal_a_SOURCES = \ extension/internal/pdf-mini.h \ extension/internal/pdf-out.h \ extension/internal/pdf-out.cpp \ + extension/internal/pdf-cairo.cpp \ + extension/internal/pdf-cairo.h \ + extension/internal/cairo-pdf-out.h \ + extension/internal/cairo-pdf-out.cpp \ extension/internal/eps-out.h \ extension/internal/eps-out.cpp \ extension/internal/gdkpixbuf-input.h \ @@ -45,6 +48,5 @@ extension_internal_libinternal_a_SOURCES = \ extension/internal/latex-pstricks.h \ extension/internal/latex-pstricks-out.cpp \ extension/internal/latex-pstricks-out.h \ -\ $(extension_internal_gnome_print_sources) diff --git a/src/extension/internal/cairo-pdf-out.cpp b/src/extension/internal/cairo-pdf-out.cpp new file mode 100644 index 000000000..52eb668c9 --- /dev/null +++ b/src/extension/internal/cairo-pdf-out.cpp @@ -0,0 +1,137 @@ +/* + * A quick hack to use the print output to write out a file. This + * then makes 'save as...' PDF. + * + * Authors: + * Ted Gould + * Ulf Erikson + * + * Copyright (C) 2004-2006 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifdef HAVE_CONFIG_H +# include +#endif +#include "cairo-pdf-out.h" +#include +#include "extension/system.h" +#include "extension/print.h" +#include "extension/db.h" +#include "extension/output.h" +#include "display/nr-arena.h" +#include "display/nr-arena-item.h" +#include "sp-path.h" + +namespace Inkscape { +namespace Extension { +namespace Internal { + +bool +CairoPdfOutput::check (Inkscape::Extension::Extension * module) +{ + if (NULL == Inkscape::Extension::db.get(SP_MODULE_KEY_PRINT_CAIRO_PDF)) + return FALSE; + + return TRUE; +} + + +static void +pdf_print_document_to_file(SPDocument *doc, gchar const *filename) +{ + Inkscape::Extension::Print *mod; + SPPrintContext context; + gchar const *oldconst; + gchar *oldoutput; + unsigned int ret; + + sp_document_ensure_up_to_date(doc); + + mod = Inkscape::Extension::get_print(SP_MODULE_KEY_PRINT_CAIRO_PDF); + oldconst = mod->get_param_string("destination"); + oldoutput = g_strdup(oldconst); + mod->set_param_string("destination", (gchar *)filename); + +/* Start */ + context.module = mod; + /* fixme: This has to go into module constructor somehow */ + /* Create new arena */ + mod->base = SP_ITEM(sp_document_root(doc)); + mod->arena = NRArena::create(); + mod->dkey = sp_item_display_key_new(1); + mod->root = sp_item_invoke_show(mod->base, mod->arena, mod->dkey, SP_ITEM_SHOW_DISPLAY); + /* Print document */ + ret = mod->begin(doc); + sp_item_invoke_print(mod->base, &context); + ret = mod->finish(); + /* Release arena */ + sp_item_invoke_hide(mod->base, mod->dkey); + mod->base = NULL; + nr_arena_item_unref(mod->root); + mod->root = NULL; + nr_object_unref((NRObject *) mod->arena); + mod->arena = NULL; +/* end */ + + mod->set_param_string("destination", oldoutput); + g_free(oldoutput); + + return; +} + + +/** + \brief This function calls the print system with the filename + \param mod unused + \param doc Document to be saved + \param uri Filename to save to (probably will end in .pdf) + + The most interesting thing that this function does is just attach + an '>' on the front of the filename. This is the syntax used to + tell the printing system to save to file. +*/ +void +CairoPdfOutput::save (Inkscape::Extension::Output *mod, SPDocument *doc, const gchar *uri) +{ + Inkscape::Extension::Extension * ext; + + ext = Inkscape::Extension::db.get(SP_MODULE_KEY_PRINT_CAIRO_PDF); + if (ext == NULL) + return; + + gchar * final_name; + final_name = g_strdup_printf("> %s", uri); + pdf_print_document_to_file(doc, final_name); + g_free(final_name); + + return; +} + +/** + \brief A function allocate a copy of this function. + + This is the definition of PDF out. This function just + calls the extension system with the memory allocated XML that + describes the data. +*/ +void +CairoPdfOutput::init (void) +{ + Inkscape::Extension::build_from_mem( + "\n" + "Cairo PDF Output\n" + "org.inkscape.output.pdf.cairo\n" + "\n" + ".pdf\n" + "application/pdf\n" + "Cairo PDF (*.pdf)\n" + "PDF File\n" + "\n" + "", new CairoPdfOutput()); + + return; +} + +} } } /* namespace Inkscape, Extension, Implementation */ diff --git a/src/extension/internal/cairo-pdf-out.h b/src/extension/internal/cairo-pdf-out.h new file mode 100644 index 000000000..394c0749a --- /dev/null +++ b/src/extension/internal/cairo-pdf-out.h @@ -0,0 +1,46 @@ +/* + * A quick hack to use the print output to write out a file. This + * then makes 'save as...' PDF. + * + * Authors: + * Ted Gould + * Ulf Erikson + * + * Copyright (C) 2004-2006 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifndef EXTENSION_INTERNAL_CAIRO_PDF_OUT_H +#define EXTENSION_INTERNAL_CAIRO_PDF_OUT_H + +#include "extension/implementation/implementation.h" + +namespace Inkscape { +namespace Extension { +namespace Internal { + +class CairoPdfOutput : Inkscape::Extension::Implementation::Implementation { + +public: + bool check(Inkscape::Extension::Extension *module); + void save(Inkscape::Extension::Output *mod, + SPDocument *doc, + gchar const *uri); + static void init(); +}; + +} } } /* namespace Inkscape, Extension, Implementation */ + +#endif /* !EXTENSION_INTERNAL_CAIRO_PDF_OUT_H */ + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 : diff --git a/src/extension/internal/pdf-cairo.cpp b/src/extension/internal/pdf-cairo.cpp new file mode 100644 index 000000000..c35fbe8b4 --- /dev/null +++ b/src/extension/internal/pdf-cairo.cpp @@ -0,0 +1,1030 @@ +#define __SP_PDF_CAIRO_C__ + +/** \file + * PDF printing with Cairo. + */ +/* + * Authors: + * Miklós Erdélyi + * + * Based on pdf.cpp + * + * Licensed under GNU GPL + */ + +/* Plain Print */ + +#define PANGO_ENABLE_BACKEND +#define PANGO_ENABLE_ENGINE + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "display/nr-arena-item.h" +#include "display/canvas-bpath.h" +#include "sp-item.h" +#include "style.h" +#include "sp-linear-gradient.h" +#include "sp-radial-gradient.h" + +#include "libnrtype/font-instance.h" +#include "libnrtype/font-style-to-pos.h" + +#include + +#include "pdf-cairo.h" +#include "extension/system.h" +#include "extension/print.h" + +#include "io/sys.h" + +#include "cairo.h" +#include "cairo-pdf.h" +#include "cairo-ft.h" + +#include + +#ifdef USE_PANGO_CAIRO +#include +#endif + +namespace Inkscape { +namespace Extension { +namespace Internal { + +static cairo_status_t _write_callback(void *closure, const unsigned char *data, unsigned int length); +static void _concat_transform(cairo_t *cr, double xx, double yx, double xy, double yy, double x0, double y0); + +PrintCairoPDF::PrintCairoPDF() : + cr(NULL), + pdf_surface(NULL), + _layout(NULL), + _dpi(72), + _bitmap(false) +{ + _num_alphas = 8; + _alpha_stack = (float*)malloc(sizeof(float) * _num_alphas); +} + +PrintCairoPDF::~PrintCairoPDF(void) +{ + if (cr) cairo_destroy(cr); + if (pdf_surface) cairo_surface_destroy(pdf_surface); + if (_layout) g_object_unref(_layout); + + free(_alpha_stack); + + /* restore default signal handling for SIGPIPE */ +#if !defined(_WIN32) && !defined(__WIN32__) + (void) signal(SIGPIPE, SIG_DFL); +#endif + + return; +} + +unsigned int +PrintCairoPDF::setup(Inkscape::Extension::Print * mod) +{ + static gchar const *const pdr[] = {"72", "75", "100", "144", "150", "200", "300", "360", "600", "1200", "2400", NULL}; + +#ifdef TED + Inkscape::XML::Node *repr = ((SPModule *) mod)->repr; +#endif + + unsigned int ret = FALSE; + + /* Create dialog */ + GtkTooltips *tt = gtk_tooltips_new(); + g_object_ref((GObject *) tt); + gtk_object_sink((GtkObject *) tt); + + GtkWidget *dlg = gtk_dialog_new_with_buttons(_("Print Destination"), +// SP_DT_WIDGET(SP_ACTIVE_DESKTOP)->window, + NULL, + (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT), + GTK_STOCK_CANCEL, + GTK_RESPONSE_CANCEL, + GTK_STOCK_PRINT, + GTK_RESPONSE_OK, + NULL); + + gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK); + + GtkWidget *vbox = GTK_DIALOG(dlg)->vbox; + gtk_container_set_border_width(GTK_CONTAINER(vbox), 4); + /* Print properties frame */ + GtkWidget *f = gtk_frame_new(_("Print properties")); + gtk_box_pack_start(GTK_BOX(vbox), f, FALSE, FALSE, 4); + GtkWidget *vb = gtk_vbox_new(FALSE, 4); + gtk_container_add(GTK_CONTAINER(f), vb); + gtk_container_set_border_width(GTK_CONTAINER(vb), 4); + /* Print type */ + bool const p2bm = mod->get_param_bool("bitmap"); + GtkWidget *rb = gtk_radio_button_new_with_label(NULL, _("Print using PDF operators")); + gtk_tooltips_set_tip((GtkTooltips *) tt, rb, + _("Use PDF vector operators. The resulting image is usually smaller " + "in file size and can be arbitrarily scaled, but " + "patterns will be lost."), NULL); + if (!p2bm) gtk_toggle_button_set_active((GtkToggleButton *) rb, TRUE); + gtk_box_pack_start(GTK_BOX(vb), rb, FALSE, FALSE, 0); + rb = gtk_radio_button_new_with_label(gtk_radio_button_get_group((GtkRadioButton *) rb), _("Print as bitmap")); + gtk_tooltips_set_tip((GtkTooltips *) tt, rb, + _("Print everything as bitmap. The resulting image is usually larger " + "in file size and cannot be arbitrarily scaled without quality loss, " + "but all objects will be rendered exactly as displayed."), NULL); + if (p2bm) gtk_toggle_button_set_active((GtkToggleButton *) rb, TRUE); + gtk_box_pack_start(GTK_BOX(vb), rb, FALSE, FALSE, 0); + /* Resolution */ + GtkWidget *hb = gtk_hbox_new(FALSE, 4); + gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, 0); + GtkWidget *combo = gtk_combo_new(); + gtk_combo_set_value_in_list(GTK_COMBO(combo), FALSE, FALSE); + gtk_combo_set_use_arrows(GTK_COMBO(combo), TRUE); + gtk_combo_set_use_arrows_always(GTK_COMBO(combo), TRUE); + gtk_widget_set_size_request(combo, 64, -1); + gtk_tooltips_set_tip((GtkTooltips *) tt, GTK_COMBO(combo)->entry, + _("Preferred resolution (dots per inch) of bitmap"), NULL); + /* Setup strings */ + GList *sl = NULL; + for (unsigned i = 0; pdr[i] != NULL; i++) { + sl = g_list_prepend(sl, (gpointer) pdr[i]); + } + sl = g_list_reverse(sl); + gtk_combo_set_popdown_strings(GTK_COMBO(combo), sl); + g_list_free(sl); + if (1) { + gchar const *val = mod->get_param_string("resolution"); + gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), val); + } + gtk_box_pack_end(GTK_BOX(hb), combo, FALSE, FALSE, 0); + GtkWidget *l = gtk_label_new(_("Resolution:")); + gtk_box_pack_end(GTK_BOX(hb), l, FALSE, FALSE, 0); + + /* Print destination frame */ + f = gtk_frame_new(_("Print destination")); + gtk_box_pack_start(GTK_BOX(vbox), f, FALSE, FALSE, 4); + vb = gtk_vbox_new(FALSE, 4); + gtk_container_add(GTK_CONTAINER(f), vb); + gtk_container_set_border_width(GTK_CONTAINER(vb), 4); + + l = gtk_label_new(_("Printer name (as given by lpstat -p);\n" + "leave empty to use the system default printer.\n" + "Use '> filename' to print to file.\n" + "Use '| prog arg...' to pipe to a program.")); + gtk_box_pack_start(GTK_BOX(vb), l, FALSE, FALSE, 0); + + GtkWidget *e = gtk_entry_new(); + if (1) { + gchar const *val = mod->get_param_string("destination"); + gtk_entry_set_text(GTK_ENTRY(e), ( val != NULL + ? val + : "" )); + } + gtk_box_pack_start(GTK_BOX(vb), e, FALSE, FALSE, 0); + + // pressing enter in the destination field is the same as clicking Print: + gtk_entry_set_activates_default(GTK_ENTRY(e), TRUE); + + gtk_widget_show_all(vbox); + + int const response = gtk_dialog_run(GTK_DIALOG(dlg)); + + g_object_unref((GObject *) tt); + + if (response == GTK_RESPONSE_OK) { + gchar const *fn; + char const *sstr; + + _bitmap = gtk_toggle_button_get_active((GtkToggleButton *) rb); + sstr = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry)); + _dpi = (unsigned int) MAX((int)(atof(sstr)), 1); + /* Arrgh, have to do something */ + fn = gtk_entry_get_text(GTK_ENTRY(e)); + /* skip leading whitespace, bug #1068483 */ + while (fn && *fn==' ') { fn++; } + /* g_print("Printing to %s\n", fn); */ + + mod->set_param_bool("bitmap", _bitmap); + mod->set_param_string("resolution", (gchar *)sstr); + mod->set_param_string("destination", (gchar *)fn); + ret = TRUE; + } + + gtk_widget_destroy(dlg); + + return ret; +} + +unsigned int +PrintCairoPDF::begin(Inkscape::Extension::Print *mod, SPDocument *doc) +{ + FILE *osf = NULL; + FILE *osp = NULL; + + _alpha_ptr = 0; + _alpha_stack[_alpha_ptr] = 1.0; + + gsize bytesRead = 0; + gsize bytesWritten = 0; + GError *error = NULL; + gchar const *utf8_fn = mod->get_param_string("destination"); + gchar *local_fn = g_filename_from_utf8( utf8_fn, + -1, &bytesRead, &bytesWritten, &error); + gchar const *fn = local_fn; + + /* TODO: Replace the below fprintf's with something that does the right thing whether in + * gui or batch mode (e.g. --print=blah). Consider throwing an exception: currently one of + * the callers (sp_print_document_to_file, "ret = mod->begin(doc)") wrongly ignores the + * return code. + */ + if (fn != NULL) { + if (*fn == '|') { + fn += 1; + while (isspace(*fn)) fn += 1; +#ifndef WIN32 + osp = popen(fn, "w"); +#else + osp = _popen(fn, "w"); +#endif + if (!osp) { + fprintf(stderr, "inkscape: popen(%s): %s\n", + fn, strerror(errno)); + return 0; + } + _stream = osp; + } else if (*fn == '>') { + fn += 1; + while (isspace(*fn)) fn += 1; + Inkscape::IO::dump_fopen_call(fn, "K"); + osf = Inkscape::IO::fopen_utf8name(fn, "w+"); + if (!osf) { + fprintf(stderr, "inkscape: fopen(%s): %s\n", + fn, strerror(errno)); + return 0; + } + _stream = osf; + } else { + /* put cwd stuff in here */ + gchar *qn = ( *fn + ? g_strdup_printf("lpr -P %s", fn) /* FIXME: quote fn */ + : g_strdup("lpr") ); +#ifndef WIN32 + osp = popen(qn, "w"); +#else + osp = _popen(qn, "w"); +#endif + if (!osp) { + fprintf(stderr, "inkscape: popen(%s): %s\n", + qn, strerror(errno)); + return 0; + } + g_free(qn); + _stream = osp; + } + } + + g_free(local_fn); + + if (_stream) { + /* fixme: this is kinda icky */ +#if !defined(_WIN32) && !defined(__WIN32__) + (void) signal(SIGPIPE, SIG_IGN); +#endif + } + + // test output stream? + + // width and height in pt + _width = sp_document_width(doc) * PT_PER_PX; + _height = sp_document_height(doc) * PT_PER_PX; + + NRRect d; + bool pageBoundingBox; + pageBoundingBox = mod->get_param_bool("pageBoundingBox"); + // printf("Page Bounding Box: %s\n", pageBoundingBox ? "TRUE" : "FALSE"); + if (pageBoundingBox) { + d.x0 = d.y0 = 0; + d.x1 = ceil(_width); + d.y1 = ceil(_height); + } else { + SPItem* doc_item = SP_ITEM(sp_document_root(doc)); + sp_item_invoke_bbox(doc_item, &d, sp_item_i2r_affine(doc_item), TRUE); + // convert from px to pt + d.x0 *= PT_PER_PX; + d.x1 *= PT_PER_PX; + d.y0 *= PT_PER_PX; + d.y1 *= PT_PER_PX; + } + printf("%f %f\n", _width, _height); + + pdf_surface = cairo_pdf_surface_create_for_stream(Inkscape::Extension::Internal::_write_callback, _stream, d.x1-d.x0, d.y1-d.y0); + cr = cairo_create(pdf_surface); + + if (!_bitmap) { + cairo_scale(cr, PT_PER_PX, PT_PER_PX); + + // from now on we can output px, but they will be treated as pt + // note that the we do not have to flip the y axis + // because Cairo's coordinate system is identical to Inkscape's + } + + return 1; +} + +unsigned int +PrintCairoPDF::finish(Inkscape::Extension::Print *mod) +{ + if (!_stream) return 0; + if (_bitmap) return 0; + + cairo_show_page(cr); + + cairo_destroy(cr); + cairo_surface_destroy(pdf_surface); + cr = NULL; + pdf_surface = NULL; + + /* Flush stream to be sure. */ + (void) fflush(_stream); + + /* fixme: should really use pclose for popen'd streams */ + fclose(_stream); + _stream = 0; + + return 0; +} + +unsigned int +PrintCairoPDF::bind(Inkscape::Extension::Print *mod, NRMatrix const *transform, float opacity) +{ + if (!_stream) return 0; // XXX: fixme, returning -1 as unsigned. + if (_bitmap) return 0; + + cairo_save(cr); + _concat_transform(cr, transform->c[0], transform->c[1], transform->c[2], transform->c[3], transform->c[4], transform->c[5]); +// g_printf("bind: (%f) %f %f %f %f %f %f\n", opacity, transform->c[0], transform->c[1], transform->c[2], transform->c[3], transform->c[4], transform->c[5]); + // remember these to be able to undo them when outputting text + _last_tx = transform->c[4]; + _last_ty = transform->c[5]; + + if (_num_alphas <= ++_alpha_ptr) { + _num_alphas *= 2; + _alpha_stack = (float*)realloc((void*)_alpha_stack, sizeof(float) * _num_alphas); + } + _alpha_stack[_alpha_ptr] = _alpha_stack[_alpha_ptr-1] * opacity; + + return 1; +} + +unsigned int +PrintCairoPDF::release(Inkscape::Extension::Print *mod) +{ + if (!_stream) return 0; // XXX: fixme, returning -1 as unsigned. + if (_bitmap) return 0; + + cairo_restore(cr); +// g_printf("release\n"); + if (_alpha_ptr > 0) + _alpha_ptr--; + + return 1; +} + +unsigned int +PrintCairoPDF::comment(Inkscape::Extension::Print *mod, char const *comment) +{ + if (!_stream) return 0; // XXX: fixme, returning -1 as unsigned. + if (_bitmap) return 0; + + return 1; +} + +cairo_pattern_t* +PrintCairoPDF::create_pattern_for_paint(SPPaintServer const *const paintserver, NRRect const *pbox, float alpha) +{ + cairo_pattern_t *pattern = NULL; + bool apply_bbox2user = false; + + if (SP_IS_LINEARGRADIENT (paintserver)) { + + SPLinearGradient *lg=SP_LINEARGRADIENT(paintserver); + + sp_gradient_ensure_vector(SP_GRADIENT(lg)); // when exporting from commandline, vector is not built + + NR::Point p1 (lg->x1.computed, lg->y1.computed); + NR::Point p2 (lg->x2.computed, lg->y2.computed); + if (pbox && SP_GRADIENT(lg)->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) { + // convert to userspace + NR::Matrix bbox2user(pbox->x1 - pbox->x0, 0, 0, pbox->y1 - pbox->y0, pbox->x0, pbox->y0); + p1 *= bbox2user; + p2 *= bbox2user; + } + + // create linear gradient pattern + pattern = cairo_pattern_create_linear(p1[NR::X], p1[NR::Y], p2[NR::X], p2[NR::Y]); + + // add stops + for (gint i = 0; unsigned(i) < lg->vector.stops.size(); i++) { + float rgb[3]; + sp_color_get_rgb_floatv(&lg->vector.stops[i].color, rgb); + cairo_pattern_add_color_stop_rgba(pattern, lg->vector.stops[i].offset, rgb[0], rgb[1], rgb[2], lg->vector.stops[i].opacity * alpha); + } + } else if (SP_IS_RADIALGRADIENT (paintserver)) { + + SPRadialGradient *rg=SP_RADIALGRADIENT(paintserver); + + sp_gradient_ensure_vector(SP_GRADIENT(rg)); // when exporting from commandline, vector is not built + + NR::Point c (rg->cx.computed, rg->cy.computed); + NR::Point f (rg->fx.computed, rg->fy.computed); + double r = rg->r.computed; + if (pbox && SP_GRADIENT(rg)->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) + apply_bbox2user = true; + + // create radial gradient pattern + pattern = cairo_pattern_create_radial(f[NR::X], f[NR::Y], 0, c[NR::X], c[NR::Y], r); + + // add stops + for (gint i = 0; unsigned(i) < rg->vector.stops.size(); i++) { + float rgb[3]; + sp_color_get_rgb_floatv(&rg->vector.stops[i].color, rgb); + cairo_pattern_add_color_stop_rgba(pattern, rg->vector.stops[i].offset, rgb[0], rgb[1], rgb[2], rg->vector.stops[i].opacity * alpha); + } + } + + if (pattern) { + SPGradient *g = SP_GRADIENT(paintserver); + + // set extend type + SPGradientSpread spread = sp_gradient_get_spread(g); + switch (spread) { + case SP_GRADIENT_SPREAD_REPEAT: + cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT); + break; + case SP_GRADIENT_SPREAD_REFLECT: // not supported by cairo-pdf yet + //cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REFLECT); + //break; + case SP_GRADIENT_SPREAD_PAD: + default: + cairo_pattern_set_extend(pattern, CAIRO_EXTEND_NONE); // PAD not supported by cairo-pdf yet + break; + } + + cairo_matrix_t pattern_matrix; + if (g->gradientTransform_set) { + // apply gradient transformation + cairo_matrix_init(&pattern_matrix, + g->gradientTransform[0], g->gradientTransform[1], + g->gradientTransform[2], g->gradientTransform[3], + g->gradientTransform[4], g->gradientTransform[5]); + } else { + cairo_matrix_init_identity (&pattern_matrix); + } + + if (apply_bbox2user) { + // convert to userspace + cairo_matrix_t bbox2user; + cairo_matrix_init (&bbox2user, pbox->x1 - pbox->x0, 0, 0, pbox->y1 - pbox->y0, pbox->x0, pbox->y0); + cairo_matrix_multiply (&pattern_matrix, &bbox2user, &pattern_matrix); + } + cairo_matrix_invert(&pattern_matrix); // because Cairo expects a userspace->patternspace matrix + cairo_pattern_set_matrix(pattern, &pattern_matrix); + } + + return pattern; +} + +void +PrintCairoPDF::print_fill_style(cairo_t *cr, SPStyle const *const style, NRRect const *pbox) +{ + g_return_if_fail( style->fill.type == SP_PAINT_TYPE_COLOR + || ( style->fill.type == SP_PAINT_TYPE_PAINTSERVER + && SP_IS_GRADIENT(SP_STYLE_FILL_SERVER(style)) ) ); + + if (style->fill.type == SP_PAINT_TYPE_COLOR) { + float rgb[3]; + sp_color_get_rgb_floatv(&style->fill.value.color, rgb); + + float alpha = 1.0; + alpha *= SP_SCALE24_TO_FLOAT(style->fill_opacity.value); + alpha *= _alpha_stack[_alpha_ptr]; + + cairo_set_source_rgba(cr, rgb[0], rgb[1], rgb[2], alpha); + } else { + g_assert( style->fill.type == SP_PAINT_TYPE_PAINTSERVER + && SP_IS_GRADIENT(SP_STYLE_FILL_SERVER(style)) ); + + cairo_pattern_t *pattern = create_pattern_for_paint(SP_STYLE_FILL_SERVER(style), pbox, 1.0); + + if (pattern) { + cairo_set_source(cr, pattern); + cairo_pattern_destroy(pattern); + } + } +} + +unsigned int +PrintCairoPDF::fill(Inkscape::Extension::Print *mod, NRBPath const *bpath, NRMatrix const *ctm, SPStyle const *const style, + NRRect const *pbox, NRRect const *dbox, NRRect const *bbox) +{ + if (!_stream) return 0; // XXX: fixme, returning -1 as unsigned. + if (_bitmap) return 0; + + if ( style->fill.type == SP_PAINT_TYPE_COLOR + || ( style->fill.type == SP_PAINT_TYPE_PAINTSERVER + && SP_IS_GRADIENT(SP_STYLE_FILL_SERVER(style)) ) ) { + + float alpha = 1.0; + alpha *= SP_SCALE24_TO_FLOAT(style->fill_opacity.value); +if (alpha != 1.0) +g_printf( "fa: %f a:%f fa*a = %f\n", alpha, _alpha_stack[_alpha_ptr], alpha*_alpha_stack[_alpha_ptr]); + alpha *= _alpha_stack[_alpha_ptr]; + + cairo_save(cr); + + print_fill_style(cr, style, pbox); + print_bpath(cr, bpath->path); + if (style->fill_rule.value == SP_WIND_RULE_EVENODD) { + cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD); + } else { + cairo_set_fill_rule(cr, CAIRO_FILL_RULE_WINDING); + } + if (alpha != 1.0 && + style->fill.type != SP_PAINT_TYPE_COLOR) { + + cairo_clip (cr); + cairo_paint_with_alpha (cr, alpha); + } else { + cairo_fill(cr); + } + + cairo_restore(cr); + } + + return 0; +} + +void +PrintCairoPDF::print_stroke_style(cairo_t *cr, SPStyle const *style, NRRect const *pbox) +{ + float alpha = 1.0; + alpha *= SP_SCALE24_TO_FLOAT(style->stroke_opacity.value); + alpha *= _alpha_stack[_alpha_ptr]; + + if ( style->stroke.type == SP_PAINT_TYPE_COLOR ) { + float rgb[3]; + sp_color_get_rgb_floatv(&style->stroke.value.color, rgb); + + cairo_set_source_rgba(cr, rgb[0], rgb[1], rgb[2], alpha); + } else if ( style->stroke.type == SP_PAINT_TYPE_PAINTSERVER + && SP_IS_GRADIENT(SP_STYLE_STROKE_SERVER(style)) ) { + + cairo_pattern_t *pattern = create_pattern_for_paint(SP_STYLE_STROKE_SERVER(style), pbox, alpha); + + if (pattern) { + cairo_set_source(cr, pattern); + cairo_pattern_destroy(pattern); + } + } + + if (style->stroke_dash.n_dash && + style->stroke_dash.dash ) + { + cairo_set_dash(cr, style->stroke_dash.dash, style->stroke_dash.n_dash, style->stroke_dash.offset); + } else { + cairo_set_dash(cr, NULL, 0, 0.0); // disable dashing + } + + cairo_set_line_width(cr, style->stroke_width.computed); + + // set line join type + cairo_line_join_t join = CAIRO_LINE_JOIN_MITER; + switch (style->stroke_linejoin.computed) { + case SP_STROKE_LINEJOIN_MITER: + join = CAIRO_LINE_JOIN_MITER; + break; + case SP_STROKE_LINEJOIN_ROUND: + join = CAIRO_LINE_JOIN_ROUND; + break; + case SP_STROKE_LINEJOIN_BEVEL: + join = CAIRO_LINE_JOIN_BEVEL; + break; + } + cairo_set_line_join(cr, join); + + // set line cap type + cairo_line_cap_t cap = CAIRO_LINE_CAP_BUTT; + switch (style->stroke_linecap.computed) { + case SP_STROKE_LINECAP_BUTT: + cap = CAIRO_LINE_CAP_BUTT; + break; + case SP_STROKE_LINECAP_ROUND: + cap = CAIRO_LINE_CAP_ROUND; + break; + case SP_STROKE_LINECAP_SQUARE: + cap = CAIRO_LINE_CAP_SQUARE; + break; + } + cairo_set_line_cap(cr, cap); + cairo_set_miter_limit(cr, MAX(1, style->stroke_miterlimit.value)); +} + +unsigned int +PrintCairoPDF::stroke(Inkscape::Extension::Print *mod, NRBPath const *bpath, NRMatrix const *ctm, SPStyle const *style, + NRRect const *pbox, NRRect const *dbox, NRRect const *bbox) +{ + if (!_stream) return 0; // XXX: fixme, returning -1 as unsigned. + if (_bitmap) return 0; + + if ( style->stroke.type == SP_PAINT_TYPE_COLOR || + ( style->stroke.type == SP_PAINT_TYPE_PAINTSERVER + && SP_IS_GRADIENT(SP_STYLE_STROKE_SERVER(style)) ) ) { + + cairo_save(cr); + + print_stroke_style(cr, style, pbox); + print_bpath(cr, bpath->path); + cairo_stroke(cr); + + cairo_restore(cr); + } + + return 0; +} + +unsigned int +PrintCairoPDF::image(Inkscape::Extension::Print *mod, guchar *px, unsigned int w, unsigned int h, unsigned int rs, + NRMatrix const *transform, SPStyle const *style) +{ + if (!_stream) return 0; // XXX: fixme, returning -1 as unsigned. + if (_bitmap) return 0; + + guchar* px_rgba = (guchar*)g_malloc(4 * w * h); + if (!px_rgba) return 0; + + float alpha = _alpha_stack[_alpha_ptr]; + + // make a copy of the original pixbuf with premultiplied alpha + // if we pass the original pixbuf it will get messed up + for (unsigned i = 0; i < h; i++) { + for (unsigned j = 0; j < w; j++) { + guchar const *src = px + i * rs + j * 4; + guint32 *dst = (guint32 *)(px_rgba + i * rs + j * 4); + guchar r, g, b, alpha_dst; + + // calculate opacity-modified alpha + alpha_dst = src[3]; + if (alpha != 1.0) + alpha_dst = (guchar)ceil((float)alpha_dst * alpha); + + // premul alpha (needed because this will be undone by cairo-pdf) + r = src[0]*alpha_dst/255; + g = src[1]*alpha_dst/255; + b = src[2]*alpha_dst/255; + + *dst = (((alpha_dst) << 24) | (((r)) << 16) | (((g)) << 8) | (b)); + } + } + + cairo_surface_t *image_surface = cairo_image_surface_create_for_data(px_rgba, CAIRO_FORMAT_ARGB32, w, h, w * 4); + if (cairo_surface_status(image_surface)) { + g_printf("%s\n", cairo_status_to_string(cairo_surface_status(image_surface))); + return 0; + } + + cairo_save(cr); + + // scaling by width & height is not needed because it will be done by cairo-pdf + // we have to translate down by height also in order to eliminate the last translation done by sp_image_print + cairo_matrix_t matrix; + cairo_matrix_init(&matrix, + transform->c[0]/w, transform->c[1], + transform->c[2], -transform->c[3]/h, + transform->c[4], transform->c[5] + transform->c[3]); + cairo_transform(cr, &matrix); + + cairo_pattern_t *pattern = cairo_pattern_create_for_surface(image_surface); + cairo_pattern_set_extend(pattern, CAIRO_EXTEND_NONE); + + cairo_set_source(cr, pattern); + cairo_pattern_destroy(pattern); + + // set clip region so that the pattern will not be repeated (bug in Cairo prior 1.2.1) + cairo_new_path(cr); + cairo_rectangle(cr, 0, 0, w, h); + cairo_clip(cr); + + cairo_paint(cr); + + cairo_restore(cr); + + cairo_surface_destroy(image_surface); + g_free(px_rgba); + + return 0; +} + +#define GLYPH_ARRAY_SIZE 64 + +NR::Point +PrintCairoPDF::draw_glyphs(cairo_t *cr, NR::Point p, PangoFont *font, PangoGlyphString *glyph_string, + bool vertical, bool stroke) +{ + cairo_glyph_t glyph_array[GLYPH_ARRAY_SIZE]; + cairo_glyph_t *glyphs = glyph_array; + if (glyph_string->num_glyphs > GLYPH_ARRAY_SIZE) + glyphs = (cairo_glyph_t*)g_malloc(sizeof(cairo_glyph_t) * glyph_string->num_glyphs); + + PangoGlyphUnit x_offset = 0, y_offset = 0; + PangoGlyphInfo *info; + int num_invalid_glyphs = 0; + for (gint i = 0; i < glyph_string->num_glyphs; i++) { + info = &glyph_string->glyphs[i]; + // skip empty or unknown glyphs + if (info->glyph == PANGO_GLYPH_EMPTY || info->glyph & PANGO_GLYPH_UNKNOWN_FLAG) { + num_invalid_glyphs++; + continue; + } + glyphs[i - num_invalid_glyphs].index = info->glyph; + glyphs[i - num_invalid_glyphs].x = p[NR::X] + (x_offset + info->geometry.x_offset)/PANGO_SCALE; + glyphs[i - num_invalid_glyphs].y = p[NR::Y] + (y_offset + info->geometry.y_offset)/PANGO_SCALE; + + if (vertical) { + cairo_text_extents_t extents; + cairo_glyph_extents(cr, &glyphs[i - num_invalid_glyphs], 1, &extents); + y_offset += (PangoGlyphUnit)(extents.y_advance * PANGO_SCALE); + } + else + x_offset += info->geometry.width; + } + + if (stroke) + cairo_glyph_path(cr, glyphs, glyph_string->num_glyphs - num_invalid_glyphs); + else + cairo_show_glyphs(cr, glyphs, glyph_string->num_glyphs - num_invalid_glyphs); + + if (glyph_string->num_glyphs > GLYPH_ARRAY_SIZE) + g_free(glyphs); + + return NR::Point(x_offset, y_offset); +} + +unsigned int +PrintCairoPDF::text(Inkscape::Extension::Print *mod, char const *text, NR::Point p, + SPStyle const *const style) +{ + bool dirty_pattern = false; + + if (!_stream) return 0; // XXX: fixme, returning -1 as unsigned. + if (_bitmap) return 0; + + cairo_save(cr); + + // this needs to be there to encounter Cairo's userspace locking semantics for set_source + // otherwise gradients won't be shown correctly + cairo_translate(cr, -_last_tx, -_last_ty); + + // create pango layout and context if needed + if (_layout == NULL) { +#ifdef USE_PANGO_CAIRO + //_context = pango_cairo_font_map_create_context(PANGO_CAIRO_FONT_MAP(pango_cairo_font_map_get_default())); + _layout = pango_cairo_create_layout(cr); +#else + _layout = pango_layout_new((font_factory::Default())->fontContext); +#endif + } + + // create font instance from style and use it + font_instance *tf = (font_factory::Default())->Face(style->text->font_family.value, font_style_to_pos(*style)); + if (tf == NULL) { // do something + g_printf("Warning: trouble getting font_instance\n"); + tf = (font_factory::Default())->Face("sans", font_style_to_pos(*style)); + } + PangoFontDescription *adjusted = pango_font_description_copy(tf->descr); + + pango_font_description_set_absolute_size(adjusted, (gint)(style->font_size.computed * PANGO_SCALE)); + pango_layout_set_font_description(_layout, adjusted); + pango_layout_set_text(_layout, text, -1); + + pango_font_description_free(adjusted); + tf->Unref(); + +#ifdef USE_PANGO_CAIRO + pango_cairo_update_layout(cr, _layout); +#else + pango_layout_context_changed(_layout); // is this needed? +#endif + + PangoLayoutLine *line = pango_layout_get_line(_layout, 0); + if (line == NULL) + return 0; + +#ifndef USE_PANGO_CAIRO + // apply the selected font + double size; + PangoLayoutRun *first_run = (PangoLayoutRun *)line->runs->data; + PangoFcFont *fc_font = PANGO_FC_FONT(first_run->item->analysis.font); + FcPattern *fc_pattern = fc_font->font_pattern; + + if ( style->writing_mode.set && + (style->writing_mode.computed == SP_CSS_WRITING_MODE_TB_RL || + style->writing_mode.computed == SP_CSS_WRITING_MODE_TB_LR) ) + { + FcPatternDel(fc_pattern, FC_VERTICAL_LAYOUT); + FcPatternAddBool(fc_pattern, FC_VERTICAL_LAYOUT, FcTrue); + dirty_pattern = true; + } + + cairo_font_face_t *font_face = cairo_ft_font_face_create_for_pattern(fc_pattern); + cairo_set_font_face(cr, font_face); + + if (FcPatternGetDouble(fc_pattern, FC_PIXEL_SIZE, 0, &size) != FcResultMatch) + size = 12.0; + + // adjust size and horizontal flip + cairo_matrix_t matrix; + cairo_get_font_matrix(cr, &matrix); + matrix.xx = size; + matrix.yy = -matrix.xx; + cairo_set_font_matrix(cr, &matrix); +#endif + + if ( style->fill.type == SP_PAINT_TYPE_COLOR + || ( style->fill.type == SP_PAINT_TYPE_PAINTSERVER + && SP_IS_GRADIENT(SP_STYLE_FILL_SERVER(style)) ) ) + { + // set fill style + print_fill_style(cr, style, NULL); + +#ifndef USE_PANGO_CAIRO + NR::Point cursor(_last_tx, _last_ty); + for (GSList *tmpList = line->runs; tmpList && tmpList->data; tmpList = tmpList->next) { + PangoLayoutRun *run = (PangoLayoutRun *)tmpList->data; + cursor += draw_glyphs(cr, cursor, run->item->analysis.font, run->glyphs, dirty_pattern, false) / PANGO_SCALE; + } +#else + cairo_new_path(cr); + cairo_move_to(cr, _last_tx, _last_ty); + pango_cairo_show_layout_line(cr, line); +#endif + } + + if (style->stroke.type == SP_PAINT_TYPE_COLOR + || ( style->stroke.type == SP_PAINT_TYPE_PAINTSERVER + && SP_IS_GRADIENT(SP_STYLE_STROKE_SERVER(style)) ) ) + { + // set stroke style + print_stroke_style(cr, style, NULL); + + // paint stroke +#ifndef USE_PANGO_CAIRO + NR::Point cursor(_last_tx, _last_ty); + for (GSList *tmpList = line->runs; tmpList && tmpList->data; tmpList = tmpList->next) { + PangoLayoutRun *run = (PangoLayoutRun *)tmpList->data; + cursor += draw_glyphs(cr, cursor, run->item->analysis.font, run->glyphs, dirty_pattern, true) / PANGO_SCALE; + } +#else + cairo_new_path(cr); + cairo_move_to(cr, _last_tx, _last_ty); + pango_cairo_layout_line_path(cr, line); +#endif + cairo_stroke(cr); + } + + cairo_font_face_destroy(font_face); + + cairo_restore(cr); + +#ifndef USE_PANGO_CAIRO + if (dirty_pattern) { + FcPatternDel(fc_pattern, FC_VERTICAL_LAYOUT); + FcPatternAddBool(fc_pattern, FC_VERTICAL_LAYOUT, FcFalse); + } +#endif + tf->Unref(); + +return 0; +} + +/* Helper functions */ + +void +PrintCairoPDF::print_bpath(cairo_t *cr, NArtBpath const *bp) +{ + cairo_new_path(cr); + bool closed = false; + while (bp->code != NR_END) { + switch (bp->code) { + case NR_MOVETO: + if (closed) { + cairo_close_path(cr); + } + closed = true; + cairo_move_to(cr, bp->x3, bp->y3); + break; + case NR_MOVETO_OPEN: + if (closed) { + cairo_close_path(cr); + } + closed = false; + cairo_move_to(cr, bp->x3, bp->y3); + break; + case NR_LINETO: + cairo_line_to(cr, bp->x3, bp->y3); + break; + case NR_CURVETO: + cairo_curve_to(cr, bp->x1, bp->y1, bp->x2, bp->y2, bp->x3, bp->y3); + break; + default: + break; + } + bp += 1; + } + if (closed) { + cairo_close_path(cr); + } +} + +static void +_concat_transform(cairo_t *cr, double xx, double yx, double xy, double yy, double x0, double y0) +{ + cairo_matrix_t matrix; + + cairo_matrix_init(&matrix, xx, yx, xy, yy, x0, y0); + cairo_transform(cr, &matrix); +} + +static cairo_status_t +_write_callback(void *closure, const unsigned char *data, unsigned int length) +{ + size_t written; + FILE *file = (FILE*)closure; + + written = fwrite (data, 1, length, file); + + if (written == length) + return CAIRO_STATUS_SUCCESS; + else + return CAIRO_STATUS_WRITE_ERROR; +} + +bool +PrintCairoPDF::textToPath(Inkscape::Extension::Print * ext) +{ + return ext->get_param_bool("textToPath"); +} + +#include "clear-n_.h" + +void +PrintCairoPDF::init(void) +{ + /* PDF out */ + (void) Inkscape::Extension::build_from_mem( + "\n" + "" N_("PDF Print") "\n" + "" SP_MODULE_KEY_PRINT_CAIRO_PDF "\n" + "FALSE\n" + "72\n" + "| lp\n" + "TRUE\n" + "TRUE\n" + "\n" + "", new PrintCairoPDF()); +} + + +} /* namespace Internal */ +} /* namespace Extension */ +} /* namespace Inkscape */ + +/* End of GNU GPL code */ + + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 : diff --git a/src/extension/internal/pdf-cairo.h b/src/extension/internal/pdf-cairo.h new file mode 100644 index 000000000..63f537ad1 --- /dev/null +++ b/src/extension/internal/pdf-cairo.h @@ -0,0 +1,107 @@ +#ifndef EXTENSION_INTERNAL_PDF_CAIRO_H_SEEN +#define EXTENSION_INTERNAL_PDF_CAIRO_H_SEEN + +/** \file + * Declaration of PrintCairoPDF, the internal module used to do PDF printing with Cairo. + */ +/* + * Authors: + * Lauris Kaplinski + * Ted Gould + * + * Lauris' original code is in the public domain. + * Ted's changes are licensed under the GNU GPL. + */ + +#include +#include "extension/extension.h" +#include "extension/implementation/implementation.h" +#include +#include + +#include "libnr/nr-path.h" +#include "libnrtype/font-instance.h" + +#include "svg/stringstream.h" +#include "sp-gradient.h" + +#include "cairo.h" +#include + +namespace Inkscape { +namespace Extension { +namespace Internal { + +class PrintCairoPDF : public Inkscape::Extension::Implementation::Implementation { + float _width; + float _height; + FILE *_stream; + cairo_t *cr; + cairo_surface_t *pdf_surface; + PangoLayout *_layout; +// PangoContext *_context; + float *_alpha_stack; + int _num_alphas, _alpha_ptr; + double _last_tx, _last_ty; + + unsigned short _dpi; + bool _bitmap; + + void print_bpath(cairo_t *cr, NArtBpath const *bp); + cairo_pattern_t *create_pattern_for_paint(SPPaintServer const *const paintserver, NRRect const *pbox, float alpha); + + void print_fill_style(cairo_t *cr, SPStyle const *const style, NRRect const *pbox); + void print_stroke_style(cairo_t *cr, SPStyle const *style, NRRect const *pbox); + +#ifndef USE_PANGO_CAIRO + NR::Point draw_glyphs(cairo_t *cr, NR::Point p, PangoFont *font, PangoGlyphString *glyph_string, + bool vertical, bool stroke); +#endif + +public: + PrintCairoPDF(void); + virtual ~PrintCairoPDF(void); + + /* Print functions */ + virtual unsigned int setup(Inkscape::Extension::Print *module); + /* + virtual unsigned int set_preview(Inkscape::Extension::Print *module); + */ + + virtual unsigned int begin(Inkscape::Extension::Print *module, SPDocument *doc); + virtual unsigned int finish(Inkscape::Extension::Print *module); + + /* Rendering methods */ + virtual unsigned int bind(Inkscape::Extension::Print *module, NRMatrix const *transform, float opacity); + virtual unsigned int release(Inkscape::Extension::Print *module); + virtual unsigned int comment(Inkscape::Extension::Print *module, char const *comment); + virtual unsigned int fill(Inkscape::Extension::Print *module, NRBPath const *bpath, NRMatrix const *ctm, SPStyle const *style, + NRRect const *pbox, NRRect const *dbox, NRRect const *bbox); + virtual unsigned int stroke(Inkscape::Extension::Print *module, NRBPath const *bpath, NRMatrix const *transform, SPStyle const *style, + NRRect const *pbox, NRRect const *dbox, NRRect const *bbox); + virtual unsigned int image(Inkscape::Extension::Print *module, unsigned char *px, unsigned int w, unsigned int h, unsigned int rs, + NRMatrix const *transform, SPStyle const *style); + virtual unsigned int text(Inkscape::Extension::Print *module, char const *text, + NR::Point p, SPStyle const *style); + + bool textToPath(Inkscape::Extension::Print *ext); + static void init(void); +}; + +} /* namespace Internal */ +} /* namespace Extension */ +} /* namespace Inkscape */ + + +#endif /* !EXTENSION_INTERNAL_PDF_CAIRO_H_SEEN */ + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 : -- 2.30.2