void CairoGLRenderer::InitDemo(HWND hWnd, HDC hdc)
{
RECT rect;
::GetClientRect(hWnd, &rect);
m_hdc = hdc;
m_hglrc = wglCreateContext(hdc);
long width = rect.right - rect.left;
long height = rect.bottom - rect.top;
m_device = cairo_wgl_device_create(m_hglrc);
if (cairo_device_status(m_device) != CAIRO_STATUS_SUCCESS)
printf("cairo device failed with %s\n", cairo_status_to_string(cairo_device_status(m_device)));
m_surface = cairo_gl_surface_create_for_dc(m_device, m_hdc, width, height);
if (cairo_surface_status(m_surface) != CAIRO_STATUS_SUCCESS)
{
const char* error = cairo_status_to_string(cairo_surface_status(m_surface));
fprintf(stderr, "cairo surface failed with %s\n", error);
}
m_cr = cairo_create (m_surface);
if (cairo_status(m_cr) != CAIRO_STATUS_SUCCESS)
printf("cairo failed with %s\n", cairo_status_to_string(cairo_status(m_cr)));
}
void CAIRODrawLines(cairo_t *cr,Gpoint *ype,int npnt,int mode)
{
int i;
/* printf("line: cr: %p\n",cr); */
if (mode != CoordModeOrigin ) {
printf("drawing lines in wrong coordmode! your mode: %i vs %i\n",mode,CoordModeOrigin);
exit(1);
}
cairo_move_to(cr,ype[0].x,ype[0].y);
if (cairo_status(cr) != CAIRO_STATUS_SUCCESS ) {
fprintf(stderr,"NOOOOOOOOOOOO BAD MOVETO%s\n",cairo_status_to_string(cairo_status(cr)));
exit(1);
}
for(i=1;i<npnt;i++) {
cairo_line_to(cr,ype[i].x,ype[i].y);
if (cairo_status(cr) != CAIRO_STATUS_SUCCESS ) {
fprintf(stderr,"NOOOOOOOOOOOO BAD LINETO%s\n",cairo_status_to_string(cairo_status(cr)));
exit(1);
}
}
cairo_stroke(cr);
if (cairo_status(cr) != CAIRO_STATUS_SUCCESS ) {
fprintf(stderr,"NOOOOOOOOOOOO BAD STROKE%s\n",cairo_status_to_string(cairo_status(cr)));
exit(1);
}
}
static void
render_cairo_surface (const RENDER * render, SNDFILE *infile, int samplerate, sf_count_t filelen)
{
cairo_surface_t * surface = NULL ;
cairo_status_t status ;
/*
** CAIRO_FORMAT_RGB24 each pixel is a 32-bit quantity, with the upper 8 bits
** unused. Red, Green, and Blue are stored in the remaining 24 bits in that order.
*/
surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, render->width, render->height) ;
if (surface == NULL || cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS)
{ status = cairo_surface_status (surface) ;
printf ("Error while creating surface : %s\n", cairo_status_to_string (status)) ;
exit (1) ;
} ;
cairo_surface_flush (surface) ;
render_to_surface (render, infile, samplerate, filelen, surface) ;
status = cairo_surface_write_to_png (surface, render->pngfilepath) ;
if (status != CAIRO_STATUS_SUCCESS)
{ printf ("Error while creating PNG file : %s\n", cairo_status_to_string (status)) ;
exit (1) ;
} ;
cairo_surface_destroy (surface) ;
return ;
} /* render_cairo_surface */
void CAIROFillPolygon(cairo_t *cr, Gpoint *ype, int npnt, int shape, int mode)
{
int i;
// printf("polyg: cr: %p\n",cr);
if (mode != CoordModeOrigin ){
printf("fill polygon in wrong coordmode, not implemented yet! your mode: %i vs %i\n",mode,CoordModeOrigin);
}
if (shape != Complex ) {
printf("fill polygon in wrong shape mode, not implemented yet!\nResults may be different from expected ones");
}
cairo_move_to(cr,ype[0].x,ype[0].y);
if (cairo_status(cr) != CAIRO_STATUS_SUCCESS ) {
fprintf(stderr,"NOOOOOOOOOOOO BAD PMOVE TO: %s\n",cairo_status_to_string(cairo_status(cr)));
exit(1);
}
for(i=1;i<npnt;i++) {
cairo_line_to(cr,ype[i].x,ype[i].y);
if (cairo_status(cr) != CAIRO_STATUS_SUCCESS ) {
fprintf(stderr,"NOOOOOOOOOOOO BAD PLINE TO: %s\n",cairo_status_to_string(cairo_status(cr)));
exit(1);
}
}
cairo_fill(cr);
if (cairo_status(cr) != CAIRO_STATUS_SUCCESS ) {
fprintf(stderr,"NOOOOOOOOOOOO BAD PFILL%s\n",cairo_status_to_string(cairo_status(cr)));
exit(1);
}
}
int
Pycairo_Check_Status (cairo_status_t status)
{
if (PyErr_Occurred() != NULL)
return 1;
switch (status) {
case CAIRO_STATUS_SUCCESS:
return 0;
/* if appropriate - translate the status string into Python,
* else - use cairo_status_to_string()
*/
case CAIRO_STATUS_NO_MEMORY:
PyErr_NoMemory();
break;
case CAIRO_STATUS_READ_ERROR:
case CAIRO_STATUS_WRITE_ERROR:
PyErr_SetString(PyExc_IOError, cairo_status_to_string (status));
break;
case CAIRO_STATUS_INVALID_RESTORE:
PyErr_SetString(CairoError, "Context.restore without matching "
"Context.save");
break;
case CAIRO_STATUS_INVALID_POP_GROUP:
PyErr_SetString(CairoError, "Context.pop_group without matching "
"Context.push_group");
break;
default:
PyErr_SetString(CairoError, cairo_status_to_string (status));
}
return 1;
}
static Rboolean
BM_Open(pDevDesc dd, pX11Desc xd, int width, int height)
{
cairo_status_t res;
if (xd->type == PNG || xd->type == JPEG ||
xd->type == TIFF || xd->type == BMP) {
xd->cs = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
xd->windowWidth,
xd->windowHeight);
} else if (xd->type == PNGdirect) {
xd->cs = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
xd->windowWidth,
xd->windowHeight);
} else if(xd->type == SVG || xd->type == PDF || xd->type == PS) {
/* leave creation to BM_Newpage */
return TRUE;
} else
error(_("unimplemented cairo-based device"));
res = cairo_surface_status(xd->cs);
if (res != CAIRO_STATUS_SUCCESS) {
warning("cairo error '%s'", cairo_status_to_string(res));
return FALSE;
}
xd->cc = cairo_create(xd->cs);
res = cairo_status(xd->cc);
if (res != CAIRO_STATUS_SUCCESS) {
warning("cairo error '%s'", cairo_status_to_string(res));
return FALSE;
}
cairo_set_operator(xd->cc, CAIRO_OPERATOR_OVER);
cairo_reset_clip(xd->cc);
cairo_set_antialias(xd->cc, xd->antialias);
return TRUE;
}
bool
args_parse (args_t *args, int argc, char **argv)
{
int i;
if (argc < 3) {
fprintf (stderr, "%s", copyright);
fprintf (stderr, "%s", usage);
return false;
}
for (i = 0; i < argc; i++) {
if (i == 1) {
args->surface_a = cairo_image_surface_create_from_png (argv[1]);
if (cairo_surface_status (args->surface_a))
{
fprintf (stderr, "FAIL: Cannot open %s: %s\n",
argv[1], cairo_status_to_string (cairo_surface_status (args->surface_a)));
return false;
}
} else if (i == 2) {
args->surface_b = cairo_image_surface_create_from_png (argv[2]);
if (cairo_surface_status (args->surface_b))
{
fprintf (stderr, "FAIL: Cannot open %s: %s\n",
argv[2], cairo_status_to_string (cairo_surface_status (args->surface_b)));
return false;
}
} else {
if (strstr(argv[i], "-fov")) {
if (i + 1 < argc) {
args->FieldOfView = (float) atof(argv[i + 1]);
}
} else if (strstr(argv[i], "-verbose")) {
args->Verbose = true;
} else if (strstr(argv[i], "-threshold")) {
if (i + 1 < argc) {
args->ThresholdPixels = atoi(argv[i + 1]);
}
} else if (strstr(argv[i], "-gamma")) {
if (i + 1 < argc) {
args->Gamma = (float) atof(argv[i + 1]);
}
}else if (strstr(argv[i], "-luminance")) {
if (i + 1 < argc) {
args->Luminance = (float) atof(argv[i + 1]);
}
}
}
} /* i */
return true;
}
int
main (int argc, char *argv[])
{
cairo_t *cr;
cairo_surface_t *argb, *rgb24;
cairo_status_t status;
const char *input, *output;
if (argc != 3) {
fprintf (stderr, "usage: %s input.png output.png", argv[0]);
fprintf (stderr, "Loads a PNG image (potentially with alpha) and writes out a flattened (no alpha)\nPNG image by first blending over white.\n");
return 1;
}
input = argv[1];
output = argv[2];
argb = cairo_image_surface_create_from_png (input);
status = cairo_surface_status (argb);
if (status) {
fprintf (stderr, "%s: Error: Failed to load %s: %s\n",
argv[0], input, cairo_status_to_string (status));
return 1;
}
rgb24 = cairo_image_surface_create (CAIRO_FORMAT_RGB24,
cairo_image_surface_get_width (argb),
cairo_image_surface_get_height (argb));
cr = cairo_create (rgb24);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
cairo_paint (cr);
cairo_set_source_surface (cr, argb, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
status = cairo_surface_write_to_png (rgb24, output);
if (status) {
fprintf (stderr, "%s: Error: Failed to write %s: %s\n",
argv[0], output, cairo_status_to_string (status));
return 1;
}
return 0;
}
static const char *
_cairo_script_render_page (const char *filename,
cairo_surface_t **surface_out)
{
cairo_script_interpreter_t *csi;
cairo_surface_t *surface = NULL;
cairo_status_t status;
const cairo_script_interpreter_hooks_t hooks = {
.closure = &surface,
.surface_create = _create_image,
};
csi = cairo_script_interpreter_create ();
cairo_script_interpreter_install_hooks (csi, &hooks);
cairo_script_interpreter_run (csi, filename);
status = cairo_script_interpreter_destroy (csi);
if (surface == NULL) {
return "cairo-script interpreter failed";
}
if (status == CAIRO_STATUS_SUCCESS)
status = cairo_surface_status (surface);
if (status) {
cairo_surface_destroy (surface);
return cairo_status_to_string (status);
}
*surface_out = surface;
return NULL;
}
int
conv_pdf (RioData *data, const char *filename)
{
int status;
/* Determine original image height & width */
uint32_t height, width;
status = rio_data_get_metadata_uint32 (data, RIO_KEY_IMAGE_ROWS, &height)
&& rio_data_get_metadata_uint32 (data, RIO_KEY_IMAGE_COLS, &width);
if (!status) {
fprintf (stderr, "ERROR: Could not determine image dimensions.\n");
return 0;
}
/* Create output surface */
cairo_surface_t *pdf = cairo_pdf_surface_create (filename, width, height);
if (cairo_surface_status (pdf) != CAIRO_STATUS_SUCCESS) {
fprintf (stderr, "ERROR: Could not create PDF surface for %s: %s\n",
filename, cairo_status_to_string (cairo_surface_status (pdf)));
return 0;
}
/* FIXME naively assumes that all will be fine from now on. */
svg_draw (data, pdf);
cairo_surface_finish (pdf);
return 1;
}
void *
addgra2cairo()
/* addgra2cairoile() returns NULL on error */
{
int i;
if (CompatibleFontHash == NULL) {
CompatibleFontHash = nhash_new();
if (CompatibleFontHash == NULL) {
return NULL;
}
for (i = 0; i < (int) (sizeof(CompatibleFont) / sizeof(*CompatibleFont)); i++) {
nhash_set_int(CompatibleFontHash, CompatibleFont[i].old_name, i);
}
}
if (Gra2CairoErrMsgs == NULL) {
Gra2CairoErrMsgs = g_malloc(sizeof(*Gra2CairoErrMsgs) * CAIRO_STATUS_LAST_STATUS);
Gra2CairoErrMsgNum = CAIRO_STATUS_LAST_STATUS;
for (i = 0; i < CAIRO_STATUS_LAST_STATUS; i++) {
Gra2CairoErrMsgs[i] = g_strdup(cairo_status_to_string(i));
}
}
return addobject(NAME, NULL, PARENT, OVERSION, TBLNUM, gra2cairo, Gra2CairoErrMsgNum, Gra2CairoErrMsgs, NULL, NULL);
}
static cairo_bool_t
check_count (const cairo_test_context_t *ctx,
const char *message, cairo_bool_t uses_clip_rects,
cairo_rectangle_list_t *list, int expected)
{
if (!uses_clip_rects) {
if (expected == 0 && list->num_rectangles == 0)
return 1;
if (list->num_rectangles == expected)
return 1;
if (list->status == CAIRO_STATUS_CLIP_NOT_REPRESENTABLE)
return 1;
cairo_test_log (ctx, "Error: %s; cairo_copy_clip_rectangle_list unexpectedly got %d rectangles\n",
message, list->num_rectangles);
return 0;
}
if (list->status != CAIRO_STATUS_SUCCESS) {
cairo_test_log (ctx, "Error: %s; cairo_copy_clip_rectangle_list failed with \"%s\"\n",
message, cairo_status_to_string(list->status));
return 0;
}
if (list->num_rectangles == expected)
return 1;
cairo_test_log (ctx, "Error: %s; expected %d rectangles, got %d\n", message,
expected, list->num_rectangles);
return 0;
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
int x,y;
int width = 10;
int height = 10;
cairo_surface_t *surf;
cairo_t *cr;
int false_positive_count = 0;
cairo_status_t status;
cairo_test_status_t ret;
surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
cr = cairo_create (surf);
cairo_surface_destroy (surf);
/* Empty horizontal trapezoid. */
cairo_move_to (cr, 0, height/3);
cairo_line_to (cr, width, height/3);
cairo_close_path (cr);
/* Empty non-horizontal trapezoid #1. */
cairo_move_to (cr, 0, 0);
cairo_line_to (cr, width, height/2);
cairo_close_path (cr);
/* Empty non-horizontal trapezoid #2 intersecting #1. */
cairo_move_to (cr, 0, height/2);
cairo_line_to (cr, width, 0);
cairo_close_path (cr);
status = cairo_status (cr);
/* Point sample the tessellated path. */
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
if (cairo_in_fill (cr, x, y)) {
false_positive_count++;
}
}
}
cairo_destroy (cr);
/* Check that everything went well. */
ret = CAIRO_TEST_SUCCESS;
if (CAIRO_STATUS_SUCCESS != status) {
cairo_test_log (ctx, "Failed to create a test surface and path: %s\n",
cairo_status_to_string (status));
ret = CAIRO_TEST_XFAILURE;
}
if (0 != false_positive_count) {
cairo_test_log (ctx, "Point sampling found %d false positives "
"from cairo_in_fill()\n",
false_positive_count);
ret = CAIRO_TEST_XFAILURE;
}
return ret;
}
explicit font_fc(cairo_t* cairo, FcPattern* pattern, double offset, double dpi_x, double dpi_y) : font(cairo, offset), m_pattern(pattern) {
cairo_matrix_t fm;
cairo_matrix_t ctm;
cairo_matrix_init_scale(&fm, size(dpi_x), size(dpi_y));
cairo_get_matrix(m_cairo, &ctm);
auto fontface = cairo_ft_font_face_create_for_pattern(m_pattern);
auto opts = cairo_font_options_create();
m_scaled = cairo_scaled_font_create(fontface, &fm, &ctm, opts);
cairo_font_options_destroy(opts);
cairo_font_face_destroy(fontface);
auto status = cairo_scaled_font_status(m_scaled);
if (status != CAIRO_STATUS_SUCCESS) {
throw application_error(sstream() << "cairo_scaled_font_create(): " << cairo_status_to_string(status));
}
auto lock = make_unique<utils::ft_face_lock>(m_scaled);
auto face = static_cast<FT_Face>(*lock);
if (FT_Select_Charmap(face, FT_ENCODING_UNICODE) == FT_Err_Ok) {
return;
} else if (FT_Select_Charmap(face, FT_ENCODING_BIG5) == FT_Err_Ok) {
return;
} else if (FT_Select_Charmap(face, FT_ENCODING_SJIS) == FT_Err_Ok) {
return;
}
lock.reset();
}
/* Shows how to draw with Cairo on SDL surfaces */
static void
draw_screen (SDL_Surface *screen)
{
cairo_t *cr;
cairo_status_t status;
/* Create a cairo drawing context, normalize it and draw a clock. */
SDL_LockSurface (screen); {
cr = cairosdl_create (screen);
cairo_scale (cr, screen->w, screen->h);
draw (cr);
status = cairo_status (cr);
cairosdl_destroy (cr);
}
SDL_UnlockSurface (screen);
SDL_Flip (screen);
/* Nasty nasty error handling. */
if (status != CAIRO_STATUS_SUCCESS) {
fprintf (stderr, "Unable to create or draw with a cairo context "
"for the screen: %s\n",
cairo_status_to_string (status));
exit (1);
}
}
static inline cairo_surface_t *
get_icon_from_gconf (GConfClient *client,
const gchar *plugin_id)
{
gchar *icon_path;
icon_path = get_icon_path_from_gconf (client, plugin_id);
if (icon_path)
{
cairo_surface_t *icon, *scaled_icon = NULL;
cairo_status_t status;
icon = cairo_image_surface_create_from_png (icon_path);
status = cairo_surface_status (icon);
if (status != CAIRO_STATUS_SUCCESS)
g_warning ("%s. Could not get thumbnail from file %s. %s",
__FUNCTION__,
icon_path,
cairo_status_to_string (status));
else
scaled_icon = scale_icon_if_required (icon);
cairo_surface_destroy (icon);
g_free (icon_path);
return scaled_icon;
}
return NULL;
}
static void
expose_event_cb (GtkDrawingArea *drawing_area,
GdkEventExpose *eev,
gpointer user_data)
{
GtkWidget *widget;
EomPrintPreviewPrivate *priv;
cairo_t *cr;
widget = GTK_WIDGET (drawing_area);
priv = EOM_PRINT_PREVIEW (user_data)->priv;
update_relative_sizes (EOM_PRINT_PREVIEW (user_data));
cr = gdk_cairo_create (gtk_widget_get_window (widget));
eom_print_preview_draw (EOM_PRINT_PREVIEW (user_data), cr);
if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {
fprintf (stderr, "Cairo is unhappy: %s\n",
cairo_status_to_string (cairo_status (cr)));
}
cairo_destroy (cr);
gdk_window_get_pointer (gtk_widget_get_window (widget), NULL, NULL, NULL);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
char *filename;
cairo_surface_t *surface;
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
cairo_test_status_t result;
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
free (filename);
return result;
}
cairo_set_source_surface (cr, surface, 0, 0);
cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
cairo_paint (cr);
cairo_surface_destroy (surface);
free (filename);
return CAIRO_TEST_SUCCESS;
}
static void
draw_page(SDL_Surface * dst, cairo_t * cr, PopplerDocument * document,
int page_num)
{
cairo_status_t status;
PopplerPage *page;
/* Create a cairo drawing context, normalize it and draw a clock. */
SDL_LockSurface(dst);
{
page = poppler_document_get_page(document, page_num - 1);
if (page == NULL) {
printf("poppler fail: page not found\n");
return;
}
cairo_save(cr);
poppler_page_render(page, cr);
cairo_restore(cr);
g_object_unref(page);
status = cairo_status(cr);
}
SDL_UnlockSurface(dst);
/* Nasty nasty error handling. */
if (status != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "Unable to create or draw with a cairo context "
"for the screen: %s\n", cairo_status_to_string(status));
exit(1);
}
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
cairo_t *cr;
const char *filename = "svg-clip.out.svg";
cairo_surface_t *surface;
if (! cairo_test_is_target_enabled (ctx, "svg11") &&
! cairo_test_is_target_enabled (ctx, "svg12"))
{
return CAIRO_TEST_UNTESTED;
}
surface = cairo_svg_surface_create (filename,
WIDTH_IN_POINTS, HEIGHT_IN_POINTS);
if (cairo_surface_status (surface)) {
cairo_test_log (ctx,
"Failed to create svg surface for file %s: %s\n",
filename, cairo_status_to_string (cairo_surface_status (surface)));
return CAIRO_TEST_FAILURE;
}
cr = cairo_create (surface);
test_clip (cr, WIDTH_IN_POINTS, HEIGHT_IN_POINTS);
cairo_show_page (cr);
cairo_destroy (cr);
cairo_surface_destroy (surface);
printf ("svg-clip: Please check %s to make sure it looks happy.\n",
filename);
return CAIRO_TEST_SUCCESS;
}
void
lsm_dom_view_render (LsmDomView *view, cairo_t *cairo, double x, double y)
{
LsmDomViewClass *view_class;
g_return_if_fail (LSM_IS_DOM_VIEW (view));
g_return_if_fail (LSM_IS_DOM_DOCUMENT (view->document));
g_return_if_fail (cairo != NULL);
lsm_dom_view_set_cairo_context (view, cairo);
cairo_save (view->cairo);
cairo_translate (view->cairo, x, y);
view_class = LSM_DOM_VIEW_GET_CLASS (view);
if (view_class->render != NULL)
view_class->render (view);
cairo_restore (view->cairo);
lsm_debug_render ("[LsmDomView::render] cairo status = %s",
cairo_status_to_string (cairo_status (view->cairo)));
lsm_dom_view_set_cairo_context (view, NULL);
}
CAMLexport value caml_cairo_status_to_string(value vstatus)
{
CAMLparam1(vstatus);
cairo_status_t status = (cairo_status_t) (Int_val(vstatus) + 2);
const char* msg = cairo_status_to_string(status);
CAMLreturn(caml_copy_string(msg));
}
static const char *
_rsvg_render_page (const char *filename,
cairo_surface_t **surface_out)
{
RsvgHandle *handle;
RsvgDimensionData dimensions;
GError *error = NULL;
cairo_surface_t *surface;
cairo_t *cr;
cairo_status_t status;
handle = rsvg_handle_new_from_file (filename, &error);
if (handle == NULL)
return error->message; /* XXX g_error_free */
rsvg_handle_get_dimensions (handle, &dimensions);
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
dimensions.width,
dimensions.height);
cr = cairo_create (surface);
rsvg_handle_render_cairo (handle, cr);
g_object_unref (handle);
status = cairo_status (cr);
cairo_destroy (cr);
if (status) {
cairo_surface_destroy (surface);
return cairo_status_to_string (status);
}
*surface_out = surface;
return NULL;
}
static void
generate_reference (double ppi_x, double ppi_y, const char *filename)
{
cairo_surface_t *surface, *target;
cairo_t *cr;
cairo_status_t status;
surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24,
SIZE*ppi_x/72, SIZE*ppi_y/72);
cr = cairo_create (surface);
cairo_surface_destroy (surface);
/* As we wish to mimic a PDF surface, copy across the default font options
* from the PDF backend.
*/
{
cairo_surface_t *pdf;
cairo_font_options_t *options;
options = cairo_font_options_create ();
pdf = cairo_pdf_surface_create ("tmp.pdf", 1, 1);
cairo_surface_get_font_options (pdf, options);
cairo_surface_destroy (pdf);
cairo_set_font_options (cr, options);
cairo_font_options_destroy (options);
}
#if SET_TOLERANCE
cairo_set_tolerance (cr, 3.0);
#endif
cairo_save (cr); {
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
} cairo_restore (cr);
cairo_scale (cr, ppi_x/72., ppi_y/72.);
draw (cr, SIZE, SIZE);
surface = cairo_surface_reference (cairo_get_target (cr));
cairo_destroy (cr);
target = cairo_image_surface_create (CAIRO_FORMAT_RGB24, SIZE, SIZE);
cr = cairo_create (target);
cairo_scale (cr, 72./ppi_x, 72./ppi_y);
cairo_set_source_surface (cr, surface, 0, 0);
cairo_paint (cr);
status = cairo_surface_write_to_png (cairo_get_target (cr), filename);
cairo_destroy (cr);
if (status) {
fprintf (stderr, "Failed to generate reference image '%s': %s\n",
filename, cairo_status_to_string (status));
exit (1);
}
}
/* adapted from pdf2png.c */
static const char *
_poppler_render_page (const char *filename,
const char *page_label,
cairo_surface_t **surface_out)
{
PopplerDocument *document;
PopplerPage *page;
double width, height;
GError *error = NULL;
gchar *absolute, *uri;
cairo_surface_t *surface;
cairo_t *cr;
cairo_status_t status;
if (g_path_is_absolute (filename)) {
absolute = g_strdup (filename);
} else {
gchar *dir = g_get_current_dir ();
absolute = g_build_filename (dir, filename, (gchar *) 0);
g_free (dir);
}
uri = g_filename_to_uri (absolute, NULL, &error);
g_free (absolute);
if (uri == NULL)
return error->message; /* XXX g_error_free (error) */
document = poppler_document_new_from_file (uri, NULL, &error);
g_free (uri);
if (document == NULL)
return error->message; /* XXX g_error_free (error) */
page = poppler_document_get_page_by_label (document, page_label);
g_object_unref (document);
if (page == NULL)
return "page not found";
poppler_page_get_size (page, &width, &height);
surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, height);
cr = cairo_create (surface);
cairo_set_source_rgb (cr, 1., 1., 1.);
cairo_paint (cr);
poppler_page_render (page, cr);
g_object_unref (page);
status = cairo_status (cr);
cairo_destroy (cr);
if (status) {
cairo_surface_destroy (surface);
return cairo_status_to_string (status);
}
*surface_out = surface;
return NULL;
}
int
main (int argc, char **argv)
{
FILE *in = stdin, *out = stdout;
cairo_status_t status;
int i;
if (argc >= 3) {
if (strcmp (argv[argc-1], "-")) {
out = fopen (argv[argc-1], "w");
if (out == NULL) {
fprintf (stderr, "Failed to open output '%s'\n", argv[argc-1]);
return 1;
}
}
}
if (argc > 2) {
for (i = 1; i < argc - 1; i++) {
in = fopen (argv[i], "r");
if (in == NULL) {
fprintf (stderr, "Failed to open input '%s'\n", argv[i]);
return 1;
}
status = cairo_script_interpreter_translate_stream (in, write_func, out);
fclose (in);
if (status)
break;
}
} else {
if (argc > 1) {
if (strcmp (argv[1], "-")) {
in = fopen (argv[1], "r");
if (in == NULL) {
fprintf (stderr, "Failed to open input '%s'\n", argv[1]);
return 1;
}
}
}
status = cairo_script_interpreter_translate_stream (in, write_func, out);
if (in != stdin)
fclose (in);
}
if (out != stdout)
fclose (out);
if (status) {
fprintf (stderr, "Translation failed: %s\n",
cairo_status_to_string (status));
return status;
}
return status;
}
PassRefPtr<Evas_Object> evasObjectFromCairoImageSurface(Evas* canvas, cairo_surface_t* surface)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(surface, 0);
cairo_status_t status = cairo_surface_status(surface);
if (status != CAIRO_STATUS_SUCCESS) {
EINA_LOG_ERR("cairo surface is invalid: %s", cairo_status_to_string(status));
return 0;
}
cairo_surface_type_t type = cairo_surface_get_type(surface);
if (type != CAIRO_SURFACE_TYPE_IMAGE) {
EINA_LOG_ERR("unknown surface type %d, required %d (CAIRO_SURFACE_TYPE_IMAGE).",
type, CAIRO_SURFACE_TYPE_IMAGE);
return 0;
}
cairo_format_t format = cairo_image_surface_get_format(surface);
if (format != CAIRO_FORMAT_ARGB32 && format != CAIRO_FORMAT_RGB24) {
EINA_LOG_ERR("unknown surface format %d, expected %d or %d.",
format, CAIRO_FORMAT_ARGB32, CAIRO_FORMAT_RGB24);
return 0;
}
int width = cairo_image_surface_get_width(surface);
int height = cairo_image_surface_get_height(surface);
int stride = cairo_image_surface_get_stride(surface);
if (width <= 0 || height <= 0 || stride <= 0) {
EINA_LOG_ERR("invalid image size %dx%d, stride=%d", width, height, stride);
return 0;
}
void* data = cairo_image_surface_get_data(surface);
if (!data) {
EINA_LOG_ERR("could not get source data.");
return 0;
}
RefPtr<Evas_Object> image = adoptRef(evas_object_image_filled_add(canvas));
if (!image) {
EINA_LOG_ERR("could not add image to canvas.");
return 0;
}
evas_object_image_colorspace_set(image.get(), EVAS_COLORSPACE_ARGB8888);
evas_object_image_size_set(image.get(), width, height);
evas_object_image_alpha_set(image.get(), format == CAIRO_FORMAT_ARGB32);
if (evas_object_image_stride_get(image.get()) != stride) {
EINA_LOG_ERR("evas' stride %d diverges from cairo's %d.",
evas_object_image_stride_get(image.get()), stride);
return 0;
}
evas_object_image_data_copy_set(image.get(), data);
return image.release();
}
/* Prints a message and quits with error status if a cairo status
* value is not "success". */
static inline void
export_cairo_check_error (cairo_status_t status)
{
if (status != CAIRO_STATUS_SUCCESS) {
fprintf (stderr, _("ERROR: %s.\n"), cairo_status_to_string (status));
exit (1);
}
}
int main (int argc, char **argv)
{
RsvgDimensionData dimensions;
RsvgHandle *logo_handle;
cairo_surface_t *surface;
GError *error = NULL;
cairo_t *cr;
cairo_status_t status;
char *input, *size, *output;
GString *layer;
char *layer_name;
int h, w;
g_type_init ();
input = argv[1];
size = argv[2];
layer = g_string_new (argv[3]);
g_string_ascii_down (layer);
g_string_prepend_c (layer, '#');
output = argv[4];
if (sscanf (size, "%dx%d", &w, &h) != 2) {
g_warning ("Couldn't parse size '%s'", size);
return 1;
}
logo_handle = rsvg_handle_new_from_file (input, &error);
if (!logo_handle) {
g_warning ("Couldn't open '%s': %s", input, error->message);
g_error_free (error);
return 1;
}
surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h);
cr = cairo_create (surface);
rsvg_handle_get_dimensions (logo_handle, &dimensions);
cairo_scale (cr,
(double) w / dimensions.width,
(double) h / dimensions.height);
layer_name = g_string_free (layer, FALSE);
rsvg_handle_render_cairo_sub (logo_handle, cr, "#background");
// rsvg_handle_render_cairo_sub (logo_handle, cr, "#base");
rsvg_handle_render_cairo_sub (logo_handle, cr, layer_name);
status = cairo_surface_write_to_png (surface, output);
if (status != CAIRO_STATUS_SUCCESS) {
g_warning ("Couldn't write output '%s': %s", output, cairo_status_to_string (status));
return 1;
}
g_free (layer_name);
cairo_destroy (cr);
return 0;
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
cairo_surface_t *surface;
cairo_t *cr;
cairo_status_t status;
size_t i;
char *filename;
const char *path = cairo_test_mkdir (CAIRO_TEST_OUTPUT_DIR) ? CAIRO_TEST_OUTPUT_DIR : ".";
if (! cairo_test_is_target_enabled (ctx, "pdf"))
return CAIRO_TEST_UNTESTED;
xasprintf (&filename, "%s/%s.pdf", path, BASENAME);
/* The initial size passed here is the default size that will be
* inheritable by each page. That is, any page for which this
* initial size applies will not have its own /MediaBox entry in
* its dictionary. */
surface = cairo_pdf_surface_create (filename,
INCHES_TO_POINTS(8.5),
INCHES_TO_POINTS(11));
cr = cairo_create (surface);
cairo_select_font_face (cr, CAIRO_TEST_FONT_FAMILY " Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
for (i = 0; i < ARRAY_LENGTH (pages); i++) {
cairo_pdf_surface_set_size (surface,
pages[i].width_in_points,
pages[i].height_in_points);
cairo_move_to (cr, TEXT_SIZE, TEXT_SIZE);
cairo_show_text (cr, pages[i].page_size);
cairo_show_text (cr, " - ");
cairo_show_text (cr, pages[i].orientation);
cairo_show_page (cr);
}
status = cairo_status (cr);
cairo_destroy (cr);
cairo_surface_destroy (surface);
free (filename);
if (status) {
cairo_test_log (ctx, "Failed to create pdf surface for file %s: %s\n",
filename, cairo_status_to_string (status));
return CAIRO_TEST_FAILURE;
}
printf ("pdf-features: Please check %s to ensure it looks/prints correctly.\n", filename);
return CAIRO_TEST_SUCCESS;
}
