static void
go_spectre_load_data (GOImage *image, GsfXMLIn *xin)
{
#ifdef GOFFICE_WITH_EPS
GOSpectre *spectre = GO_SPECTRE (image);
int width, height;
char *tmpname;
#endif
image->data_length = gsf_base64_decode_simple (xin->content->str, strlen(xin->content->str));
image->data = g_malloc (image->data_length);
memcpy (image->data, xin->content->str, image->data_length);
#ifdef GOFFICE_WITH_EPS
spectre->doc = spectre_document_new ();
if (spectre->doc == NULL)
return;
/* libspectre can only load files,
see https://bugs.freedesktop.org/show_bug.cgi?id=42424 */
tmpname = create_file (image->data, image->data_length);
if (!tmpname)
return;
spectre_document_load (spectre->doc, tmpname);
if (spectre_document_status (spectre->doc) != SPECTRE_STATUS_SUCCESS)
return;
spectre_document_get_page_size (spectre->doc, &width, &height);
image->width = width;
image->height = height;
unlink (tmpname);
g_free (tmpname);
#endif
}
Document::Document (const QString& path, QObject *plugin)
: SD_ (spectre_document_new ())
, DocURL_ (QUrl::fromLocalFile (path))
, Plugin_ (plugin)
{
spectre_document_load (SD_, path.toUtf8 ().constData ());
}
GOImage *
go_spectre_new_from_file (char const *filename, GError **error)
{
GOSpectre *spectre = g_object_new (GO_TYPE_SPECTRE, NULL);
guint8 *data;
GsfInput *input = gsf_input_stdio_new (filename, error);
#ifdef GOFFICE_WITH_EPS
int width, height;
#endif
GOImage *image;
if (!input)
return NULL;
image = GO_IMAGE (spectre);
image->data_length = gsf_input_size (input);
data = g_malloc (image->data_length);
if (!data || !gsf_input_read (input, image->data_length, data)) {
g_object_unref (spectre);
g_free (data);
return NULL;
}
image->data = data;
#ifdef GOFFICE_WITH_EPS
spectre->doc = spectre_document_new ();
if (spectre->doc == NULL) {
g_object_unref (spectre);
return NULL;
}
spectre_document_load (spectre->doc, filename);
if (spectre_document_status (spectre->doc) != SPECTRE_STATUS_SUCCESS) {
g_object_unref (spectre);
return NULL;
}
spectre_document_get_page_size (spectre->doc, &width, &height);
image->width = width;
image->height = height;
#else
{
GsfInput *input = gsf_input_memory_new (image->data, image->data_length, FALSE);
GsfInputTextline *text = GSF_INPUT_TEXTLINE (gsf_input_textline_new (input));
guint8 *line;
while ((line = gsf_input_textline_ascii_gets (text)))
if (!strncmp (line, "%%BoundingBox: ", 15)) {
unsigned x0, x1, y0, y1;
if (sscanf (line + 15, "%u %u %u %u", &x0, &y0, &x1, &y1) == 4) {
image->width = x1 - x0;
image->height = y1 - y0;
} else {
image->width = 100;
image->height = 100;
}
break;
}
g_object_unref (text);
g_object_unref (input);
}
#endif
return image;
}
static const char *
_spectre_render_page (const char *filename,
const char *page_label,
cairo_surface_t **surface_out)
{
static const cairo_user_data_key_t key;
SpectreDocument *document;
SpectreStatus status;
int width, height, stride;
unsigned char *pixels;
cairo_surface_t *surface;
document = spectre_document_new ();
spectre_document_load (document, filename);
status = spectre_document_status (document);
if (status) {
spectre_document_free (document);
return spectre_status_to_string (status);
}
if (page_label) {
SpectrePage *page;
SpectreRenderContext *rc;
page = spectre_document_get_page_by_label (document, page_label);
spectre_document_free (document);
if (page == NULL)
return "page not found";
spectre_page_get_size (page, &width, &height);
rc = spectre_render_context_new ();
spectre_render_context_set_page_size (rc, width, height);
spectre_page_render (page, rc, &pixels, &stride);
spectre_render_context_free (rc);
status = spectre_page_status (page);
spectre_page_free (page);
if (status) {
free (pixels);
return spectre_status_to_string (status);
}
} else {
spectre_document_get_page_size (document, &width, &height);
spectre_document_render (document, &pixels, &stride);
spectre_document_free (document);
}
surface = cairo_image_surface_create_for_data (pixels,
CAIRO_FORMAT_RGB24,
width, height,
stride);
cairo_surface_set_user_data (surface, &key,
pixels, (cairo_destroy_func_t) free);
*surface_out = surface;
return NULL;
}
QImage EpsRenderer::renderToImage(const QUrl& url, QSizeF* size)
{
#ifdef LIBSPECTRE_FOUND
SpectreDocument* doc = spectre_document_new();
SpectreRenderContext* rc = spectre_render_context_new();
qDebug() << "rendering eps file: " << url;
QByteArray local_file = url.toLocalFile().toUtf8();
spectre_document_load(doc, local_file.data());
int wdoc, hdoc;
qreal w, h;
double scale;
spectre_document_get_page_size(doc, &wdoc, &hdoc);
if(m_useHighRes) {
scale=1.2*4.0; //1.2 scaling factor, to make it look nice, 4x for high resolution
w = 1.2 * wdoc;
h = 1.2 * hdoc;
} else {
scale=1.8*m_scale;
w = 1.8 * wdoc;
h = 1.8 * hdoc;
}
qDebug()<<"scale: "<<scale;
qDebug()<<"dimension: "<<w<<"x"<<h;
unsigned char* data;
int rowLength;
spectre_render_context_set_scale(rc, scale, scale);
spectre_document_render_full( doc, rc, &data, &rowLength);
QImage img(data, wdoc*scale, hdoc*scale, rowLength, QImage::Format_RGB32);
spectre_document_free(doc);
spectre_render_context_free(rc);
img = img.convertToFormat(QImage::Format_ARGB32);
if (size)
*size = QSizeF(w,h);
return img;
#else
Q_UNUSED(url);
Q_UNUSED(size);
return QImage();
#endif
}
bool PostScriptDocument::load(const QString& fileName) {
p_filename = fileName;
p_internal_document = spectre_document_new();
spectre_document_load(p_internal_document, QFile::encodeName(p_filename));
const SpectreStatus loadStatus = spectre_document_status(p_internal_document);
if (loadStatus != SPECTRE_STATUS_SUCCESS) {
kDebug() << "ERR:" << spectre_status_to_string(loadStatus);
spectre_document_free(p_internal_document);
clear();
return FALSE;
}
int numPages = spectre_document_get_n_pages(p_internal_document);
if (numPages > 0) {
kDebug() << "Page Count: " << numPages;
} else {
kWarning() << "Unable to calculate number of pages.";
numPages = 0;
}
int width, height;
spectre_document_get_page_size(p_internal_document, &width, &height);
if ((width > 0) && (height > 0)) {
p_page_size = QSize(width, height);
kDebug() << "Page Size: " << width << "x" << height << " (" << PaperSizeUtils::paperSizeToString(PaperSizeUtils::sizeToPaperSize(p_page_size)) << ")";
} else {
kWarning() << "Unable to calculate page size.";
}
SpectreOrientation orientation = spectre_document_get_orientation(p_internal_document);
bool reversePage;
p_orientation = spectreOrientationToOrientation(orientation, &reversePage);
kDebug() << "Page Orientation: " << PaperSizeUtils::orientationToString(p_orientation);
kDebug() << "Note: The page orientation may differ from orientation for each page.";
/* Load the pages now */
SpectrePage *page;
SpectreOrientation pageOrientation;
QPrinter::Orientation pageOrientation2;
width = 0; height = 0;
for (int i = 0; i < numPages; ++i) {
pageOrientation = SPECTRE_ORIENTATION_PORTRAIT;
page = spectre_document_get_page(p_internal_document, i);
if (spectre_document_status(p_internal_document)) {
kWarning() << "Error getting page " << i << spectre_status_to_string(spectre_document_status(p_internal_document));
} else {
spectre_page_get_size(page, &width, &height);
pageOrientation = spectre_page_get_orientation(page);
}
spectre_page_free(page);
pageOrientation2 = spectreOrientationToOrientation(pageOrientation, &reversePage);
p_pages.append(PostScriptDocumentPage(QSize(width, height), pageOrientation2, reversePage));
kDebug() << "Append page" << i+1 << "with Size (" << width << "," << height << ")," << PaperSizeUtils::orientationToString(pageOrientation2);
}
kDebug() << "Loaded" << p_pages.count() << "pages";
p_is_valid = TRUE;
return TRUE;
}
