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;
}
bool PostScriptDocument::close() {
spectre_document_free(p_internal_document);
clear();
return TRUE;
}
static void
go_spectre_finalize (GObject *obj)
{
GOSpectre *spectre = GO_SPECTRE (obj);
if (spectre->surface)
cairo_surface_destroy (spectre->surface);
#ifdef GOFFICE_WITH_EPS
if (spectre->doc)
spectre_document_free (spectre->doc);
#endif
(parent_klass->finalize) (obj);
}
int main(int argc, char *argv[])
{
SpectreDocument *document;
SpectreRenderContext *rc;
(void)argc;
(void)argv;
document = spectre_document_new();
rc = spectre_render_context_new();
spectre_document_free(document);
spectre_render_context_free(rc);
return 0;
}
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;
}
Document::~Document ()
{
spectre_document_free (SD_);
}
