static PyObject *
pdf_surface_new (PyTypeObject *type, PyObject *args, PyObject *kwds)
{
double width_in_points, height_in_points;
PyObject *file, *writer;
if (!PyArg_ParseTuple(args, "Odd:PDFSurface.__new__",
&file, &width_in_points, &height_in_points))
return NULL;
if (PyObject_TypeCheck (file, &PyBaseString_Type)) {
/* string (filename) argument */
return PycairoSurface_FromSurface (
cairo_pdf_surface_create (PyString_AsString(file),
width_in_points, height_in_points),
NULL);
}
/* file or file-like object argument */
writer = PyObject_GetAttrString (file, "write");
if (writer == NULL || !PyCallable_Check (writer)) {
Py_XDECREF(writer);
PyErr_SetString(PyExc_TypeError,
"PDFSurface argument 1 must be a filename (str), file object, or an object "
"that has a \"write\" method (like StringIO)");
return NULL;
}
Py_DECREF(writer);
return PycairoSurface_FromSurface (
cairo_pdf_surface_create_for_stream (_write_func, file,
width_in_points, height_in_points),
file);
}
static cairo_surface_t *
_pdf_surface_create (void *closure,
cairo_content_t content,
double width, double height)
{
return cairo_pdf_surface_create_for_stream (NULL, NULL, width, height);
}
void ofCairoRenderer::setup(string _filename, Type _type, bool multiPage_, bool b3D_, ofRectangle _viewport){
if( _viewport.width == 0 || _viewport.height == 0 ){
_viewport.set(0, 0, ofGetWidth(), ofGetHeight());
}
filename = _filename;
type = _type;
streamBuffer.clear();
if(type == FROM_FILE_EXTENSION){
string ext = ofFilePath::getFileExt(filename);
if(ofToLower(ext)=="svg"){
type = SVG;
}else if(ofToLower(ext)=="pdf"){
type = PDF;
}else{ // default to image
type = IMAGE;
}
}
switch(type){
case PDF:
if(filename==""){
surface = cairo_pdf_surface_create_for_stream(&ofCairoRenderer::stream_function,this,_viewport.width, _viewport.height);
}else{
surface = cairo_pdf_surface_create(ofToDataPath(filename).c_str(),_viewport.width, _viewport.height);
}
break;
case SVG:
if(filename==""){
surface = cairo_svg_surface_create_for_stream(&ofCairoRenderer::stream_function,this,_viewport.width, _viewport.height);
}else{
surface = cairo_svg_surface_create(ofToDataPath(filename).c_str(),_viewport.width, _viewport.height);
}
break;
case IMAGE:
imageBuffer.allocate(_viewport.width, _viewport.height, 4);
surface = cairo_image_surface_create_for_data(imageBuffer.getPixels(),CAIRO_FORMAT_ARGB32,_viewport.width, _viewport.height,_viewport.width*4);
break;
case FROM_FILE_EXTENSION:
ofLogFatalError("ofCairoRenderer") << "Type not determined from file extension!";
break;
default:
ofLogError("ofCairoRenderer") << "Unknown type encountered!";
break;
}
cr = cairo_create(surface);
cairo_set_antialias(cr,CAIRO_ANTIALIAS_SUBPIXEL);
viewportRect = _viewport;
viewport(viewportRect);
page = 0;
b3D = b3D_;
multiPage = multiPage_;
setStyle(ofGetStyle());
}
void gt_graphics_cairo_initialize(GtGraphics *gg, GtGraphicsOutType type,
unsigned int width, unsigned int height)
{
GtGraphicsCairo *g = gt_graphics_cairo_cast(gg);
g->outbuf = gt_str_new();
switch (type)
{
case GT_GRAPHICS_PDF:
#ifdef CAIRO_HAS_PDF_SURFACE
g->surf = cairo_pdf_surface_create_for_stream(str_write_func,
g->outbuf,
width,
height);
break;
#endif
case GT_GRAPHICS_PS:
#ifdef CAIRO_HAS_PS_SURFACE
g->surf = cairo_ps_surface_create_for_stream(str_write_func,
g->outbuf,
width,
height);
break;
#endif
case GT_GRAPHICS_SVG:
#ifdef CAIRO_HAS_SVG_SURFACE
g->surf = cairo_svg_surface_create_for_stream(str_write_func,
g->outbuf,
width,
height);
break;
#endif
case GT_GRAPHICS_PNG:
default:
g->surf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
break;
}
gt_assert(g->surf && cairo_surface_status(g->surf) == CAIRO_STATUS_SUCCESS);
g->cr = cairo_create(g->surf);
gt_assert(cairo_status(g->cr) == CAIRO_STATUS_SUCCESS);
/* set background default to transparent */
g->bg_color.red = g->bg_color.green = 0.0;
g->bg_color.blue = g->bg_color.alpha = 0.0;
g->width = width;
g->height = height;
g->margin_x = g->margin_y = 20;
cairo_set_line_join(g->cr, CAIRO_LINE_JOIN_ROUND);
cairo_set_line_cap(g->cr, CAIRO_LINE_CAP_ROUND);
cairo_select_font_face(g->cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
g->type = type;
}
static cairo_surface_t *
create_preview_surface_platform (GtkPaperSize *paper_size,
gdouble *dpi_x,
gdouble *dpi_y)
{
gdouble width, height;
width = gtk_paper_size_get_width (paper_size, GTK_UNIT_POINTS);
height = gtk_paper_size_get_height (paper_size, GTK_UNIT_POINTS);
*dpi_x = *dpi_y = PRINTER_DPI;
return cairo_pdf_surface_create_for_stream (dummy_write_func, NULL,
width, height);
}
int plotstuff_init2(plot_args_t* pargs) {
int i;
logverb("Creating drawing surface (%ix%i)\n", pargs->W, pargs->H);
// Allocate cairo surface
switch (pargs->outformat) {
case PLOTSTUFF_FORMAT_PDF:
if (pargs->outfn) {
pargs->fout = fopen(pargs->outfn, "wb");
if (!pargs->fout) {
SYSERROR("Failed to open output file \"%s\"", pargs->outfn);
return -1;
}
}
pargs->target = cairo_pdf_surface_create_for_stream(cairoutils_file_write_func, pargs->fout, pargs->W, pargs->H);
break;
case PLOTSTUFF_FORMAT_JPG:
case PLOTSTUFF_FORMAT_PPM:
case PLOTSTUFF_FORMAT_PNG:
case PLOTSTUFF_FORMAT_MEMIMG:
pargs->target = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, pargs->W, pargs->H);
break;
default:
ERROR("Unknown output format %i", pargs->outformat);
return -1;
break;
}
pargs->cairo = cairo_create(pargs->target);
/* D'oh, this flips the coord sys, but not text!
// Flip the cairo reference frame (make 0,0 the bottom-left)
cairo_scale(pargs->cairo, 1.0, -1.0);
// FIXME -- could deal with 0.5 issues here!
cairo_translate(pargs->cairo, 0.0, -pargs->H);
*/
for (i=0; i<pargs->NP; i++) {
if (pargs->plotters[i].init2 &&
pargs->plotters[i].init2(pargs, pargs->plotters[i].baton)) {
ERROR("Plot initializer failed");
exit(-1);
}
}
return 0;
}
/*
* Open an output PDF file.
*/
int
PDFmoOpen(WS_STATE_PTR ws)
{
Gint status = 1;
struct color_table *ptab;
double tmp;
cairo_surface_t *surface;
initLogFlag();
assert(ws != NULL);
if ((ws->mf.cgmo = (mf_cgmo*)umalloc(sizeof(mf_cgmo))) != NULL) {
mf_cgmo *cgmo = ws->mf.cgmo;
if ((cgmo->fp = fopen(ws->conn, "w")) == NULL) {
(void)CAIROmoClose(&ws->mf);
} else {
/* C. Doutriaux addition link to cairo lib */
#ifdef GENCAIRO
printf("#include <cairo.h>\n#include <cairo-ps.h>\n#include <stdio.h>\n");
printf(" cairo_status_t\nstream_cairo_write (void *closure,\n const unsigned char *data,\n unsigned int length)\n{\n FILE *fp = closure;\n int i;\n for(i=0;i<length;i++){\n fputc( data[i],fp);\n }\n return CAIRO_STATUS_SUCCESS;\n};\n");
printf("int main(){\ncairo_surface_t *surface;\ncairo_t *cr;\ncairo_pattern_t *pattern=NULL;\ncairo_surface_t *image=NULL;\ncairo_t *cr2=NULL;\n");
printf("double dashes[4];\nint ndashes;\ncairo_matrix_t matrix;\nchar achar[2];\n");
printf("FILE *fp;\n");
printf("fp = fopen(\"test.pdf\",\"w\");\n");
printf("surface = cairo_pdf_surface_create_for_stream(stream_cairo_write,fp,%i, %i);\n",XW,YW);
printf("cr = cairo_create (surface);\n");
#endif
surface = cairo_pdf_surface_create_for_stream(stream_cairo_write,
ws->mf.any->fp,
XW,YW);
#ifdef CAIRODRAW
ws->cr = cairo_create (surface);
#endif
cgmo->ws = ws;
cgmo->type = MF_CAIRO;
status = OK;
}
}
return status;
}
void br_file_start(duc_graph *g)
{
struct cairo_backend_data *bd = g->backend_data;
switch(bd->fmt) {
case DUC_GRAPH_FORMAT_PNG:
bd->cs = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, (int)g->size, (int)g->size);
break;
case DUC_GRAPH_FORMAT_SVG:
bd->cs = cairo_svg_surface_create_for_stream(cairo_writer, bd->fout, (int)g->size, (int)g->size);
break;
case DUC_GRAPH_FORMAT_PDF:
bd->cs = cairo_pdf_surface_create_for_stream(cairo_writer, bd->fout, (int)g->size, (int)g->size);
break;
default:
duc_log(g->duc, DUC_LOG_FTL, "Image format not handled by cairo backend");
exit(1);
}
bd->cr = cairo_create(bd->cs);
cairo_translate(bd->cr, g->pos_x, g->pos_y);
}
void ofCairoRenderer::setup(string _filename, Type _type, bool multiPage_, bool b3D_, ofRectangle _viewport){
if( _viewport.width == 0 || _viewport.height == 0 ){
_viewport.set(0, 0, ofGetViewportWidth(), ofGetViewportHeight());
}
filename = _filename;
type = _type;
streamBuffer.clear();
if(type == FROM_FILE_EXTENSION){
string ext = ofFilePath::getFileExt(filename);
if(ofToLower(ext)=="svg"){
type = SVG;
}else if(ofToLower(ext)=="pdf"){
type = PDF;
}else{ // default to image
type = IMAGE;
}
}
if(filename != "") {
switch(type) {
case PDF:
case SVG:
case IMAGE:
ofFilePath::createEnclosingDirectory(filename);
case FROM_FILE_EXTENSION:
break;
}
}
switch(type){
case PDF:
if(filename==""){
surface = cairo_pdf_surface_create_for_stream(&ofCairoRenderer::stream_function,this,_viewport.width, _viewport.height);
}else{
surface = cairo_pdf_surface_create(ofToDataPath(filename).c_str(),_viewport.width, _viewport.height);
}
break;
case SVG:
if(filename==""){
surface = cairo_svg_surface_create_for_stream(&ofCairoRenderer::stream_function,this,_viewport.width, _viewport.height);
}else{
surface = cairo_svg_surface_create(ofToDataPath(filename).c_str(),_viewport.width, _viewport.height);
}
break;
case IMAGE:
imageBuffer.allocate(_viewport.width, _viewport.height, OF_PIXELS_BGRA);
imageBuffer.set(0);
surface = cairo_image_surface_create_for_data(imageBuffer.getData(),CAIRO_FORMAT_ARGB32,_viewport.width, _viewport.height,_viewport.width*4);
break;
case FROM_FILE_EXTENSION:
ofLogFatalError("ofCairoRenderer") << "setup(): couldn't determine type from extension for filename: \"" << _filename << "\"!";
break;
default:
ofLogError("ofCairoRenderer") << "setup(): encountered unknown type for filename \"" << _filename << "\"";
break;
}
cr = cairo_create(surface);
cairo_set_antialias(cr,CAIRO_ANTIALIAS_SUBPIXEL);
viewportRect = _viewport;
originalViewport = _viewport;
viewport(viewportRect);
page = 0;
b3D = b3D_;
multiPage = multiPage_;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
/* Plug-in variables */
gboolean single_image;
gboolean defaults_proc;
/* Plug-In variables */
cairo_surface_t *pdf_file;
cairo_t *cr;
GimpExportCapabilities capabilities;
guint32 i = 0;
gint32 j = 0;
gdouble x_res, y_res;
gdouble x_scale, y_scale;
gint32 image_id;
gboolean exported;
GimpImageBaseType type;
gint32 temp;
gint *layers;
gint32 num_of_layers;
GimpDrawable *layer;
cairo_surface_t *layer_image;
gdouble opacity;
gint x, y;
GimpRGB layer_color;
gboolean single_color;
gint32 mask_id = -1;
GimpDrawable *mask = NULL;
cairo_surface_t *mask_image = NULL;
FILE *fp;
INIT_I18N ();
/* Setting mandatory output values */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Initializing all the settings */
multi_page.image_count = 0;
if (! init_vals (name, nparams, param, &single_image,
&defaults_proc, &run_mode))
{
values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
return;
}
/* Starting the executions */
if (run_mode == GIMP_RUN_INTERACTIVE)
{
if (single_image)
{
if (! gui_single ())
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
}
else if (! gui_multi ())
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
if (file_name == NULL)
{
values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
gimp_message (_("You must select a file to save!"));
return;
}
}
fp = g_fopen (file_name, "wb");
pdf_file = cairo_pdf_surface_create_for_stream (write_func, fp, 1, 1);
if (cairo_surface_status (pdf_file) != CAIRO_STATUS_SUCCESS)
{
char *str = g_strdup_printf
(_("An error occured while creating the PDF file:\n"
"%s\n"
"Make sure you entered a valid filename and that the selected location isn't read only!"),
cairo_status_to_string (cairo_surface_status (pdf_file)));
gimp_message (str);
g_free (str);
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
return;
}
cr = cairo_create (pdf_file);
capabilities = GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_ALPHA |
GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_LAYERS |
GIMP_EXPORT_CAN_HANDLE_INDEXED;
if (optimize.apply_masks)
capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS;
for (i = 0; i < multi_page.image_count; i++)
{
/* Save the state of the surface before any changes, so that settings
* from one page won't affect all the others */
cairo_save (cr);
image_id = multi_page.images[i];
/* We need the active layer in order to use gimp_image_export */
temp = gimp_image_get_active_drawable (image_id);
if (temp == -1)
exported = gimp_export_image (&image_id, &temp, NULL, capabilities) == GIMP_EXPORT_EXPORT;
else
exported = FALSE;
type = gimp_image_base_type (image_id);
gimp_image_get_resolution (image_id, &x_res, &y_res);
x_scale = 72.0 / x_res;
y_scale = 72.0 / y_res;
cairo_pdf_surface_set_size (pdf_file,
gimp_image_width (image_id) * x_scale,
gimp_image_height (image_id) * y_scale);
/* This way we set how many pixels are there in every inch.
* It's very important for PangoCairo */
cairo_surface_set_fallback_resolution (pdf_file, x_res, y_res);
/* PDF is usually 72 points per inch. If we have a different resolution,
* we will need this to fit our drawings */
cairo_scale (cr, x_scale, y_scale);
/* Now, we should loop over the layers of each image */
layers = gimp_image_get_layers (image_id, &num_of_layers);
for (j = 0; j < num_of_layers; j++)
{
layer = gimp_drawable_get (layers [num_of_layers-j-1]);
opacity = gimp_layer_get_opacity (layer->drawable_id)/100.0;
/* Gimp doesn't display indexed layers with opacity below 50%
* And if it's above 50%, it will be rounded to 100% */
if (type == GIMP_INDEXED)
{
if (opacity <= 0.5)
opacity = 0.0;
else
opacity = 1.0;
}
if (gimp_item_get_visible (layer->drawable_id)
&& (! optimize.ignore_hidden || (optimize.ignore_hidden && opacity > 0.0)))
{
mask_id = gimp_layer_get_mask (layer->drawable_id);
if (mask_id != -1)
{
mask = gimp_drawable_get (mask_id);
mask_image = get_drawable_image (mask);
}
gimp_drawable_offsets (layer->drawable_id, &x, &y);
/* For raster layers */
if (!gimp_item_is_text_layer (layer->drawable_id))
{
layer_color = get_layer_color (layer, &single_color);
cairo_rectangle (cr, x, y, layer->width, layer->height);
if (optimize.vectorize && single_color)
{
cairo_set_source_rgba (cr, layer_color.r, layer_color.g, layer_color.b, layer_color.a * opacity);
if (mask_id != -1)
cairo_mask_surface (cr, mask_image, x, y);
else
cairo_fill (cr);
}
else
{
cairo_clip (cr);
layer_image = get_drawable_image (layer);
cairo_set_source_surface (cr, layer_image, x, y);
cairo_push_group (cr);
cairo_paint_with_alpha (cr, opacity);
cairo_pop_group_to_source (cr);
if (mask_id != -1)
cairo_mask_surface (cr, mask_image, x, y);
else
cairo_paint (cr);
cairo_reset_clip (cr);
cairo_surface_destroy (layer_image);
}
}
/* For text layers */
else
{
drawText (layer, opacity, cr, x_res, y_res);
}
}
/* We are done with the layer - time to free some resources */
gimp_drawable_detach (layer);
if (mask_id != -1)
{
gimp_drawable_detach (mask);
cairo_surface_destroy (mask_image);
}
}
/* We are done with this image - Show it! */
cairo_show_page (cr);
cairo_restore (cr);
if (exported)
gimp_image_delete (image_id);
}
/* We are done with all the images - time to free the resources */
cairo_surface_destroy (pdf_file);
cairo_destroy (cr);
fclose (fp);
/* Finally done, let's save the parameters */
gimp_set_data (DATA_OPTIMIZE, &optimize, sizeof (optimize));
if (!single_image)
{
g_strlcpy (multi_page.file_name, file_name, MAX_FILE_NAME_LENGTH);
gimp_set_data (DATA_IMAGE_LIST, &multi_page, sizeof (multi_page));
}
}
imageObj* createImageCairo(int width, int height, outputFormatObj *format,colorObj* bg)
{
imageObj *image = NULL;
cairo_renderer *r=NULL;
if (format->imagemode != MS_IMAGEMODE_RGB && format->imagemode!= MS_IMAGEMODE_RGBA) {
msSetError(MS_MISCERR,
"Cairo driver only supports RGB or RGBA pixel models.","msImageCreateCairo()");
return image;
}
if (width > 0 && height > 0) {
image = (imageObj *) calloc(1, sizeof(imageObj));
r = (cairo_renderer*)calloc(1,sizeof(cairo_renderer));
if(!strcasecmp(format->driver,"cairo/pdf")) {
r->outputStream = (bufferObj*)malloc(sizeof(bufferObj));
msBufferInit(r->outputStream);
r->surface = cairo_pdf_surface_create_for_stream(
_stream_write_fn,
r->outputStream,
width,height);
} else if(!strcasecmp(format->driver,"cairo/svg")) {
r->outputStream = (bufferObj*)malloc(sizeof(bufferObj));
msBufferInit(r->outputStream);
r->surface = cairo_svg_surface_create_for_stream(
_stream_write_fn,
r->outputStream,
width,height);
} else if(!strcasecmp(format->driver,"cairo/winGDI") && format->device) {
#if CAIRO_HAS_WIN32_SURFACE
r->outputStream = NULL;
r->surface = cairo_win32_surface_create(format->device);
#else
msSetError(MS_RENDERERERR, "Cannot create cairo image. Cairo was not compiled with support for the win32 backend.",
"msImageCreateCairo()");
#endif
} else if(!strcasecmp(format->driver,"cairo/winGDIPrint") && format->device) {
#if CAIRO_HAS_WIN32_SURFACE
r->outputStream = NULL;
r->surface = cairo_win32_printing_surface_create(format->device);
#else
msSetError(MS_RENDERERERR, "Cannot create cairo image. Cairo was not compiled with support for the win32 backend.",
"msImageCreateCairo()");
#endif
} else {
r->outputStream = NULL;
r->surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
}
r->cr = cairo_create(r->surface);
if(format->transparent || !bg || !MS_VALID_COLOR(*bg)) {
r->use_alpha = 1;
cairo_set_source_rgba (r->cr, 0,0,0,0);
} else {
r->use_alpha = 0;
msCairoSetSourceColor(r->cr,bg);
}
cairo_save (r->cr);
cairo_set_operator (r->cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (r->cr);
cairo_restore (r->cr);
cairo_set_line_cap (r->cr,CAIRO_LINE_CAP_ROUND);
cairo_set_line_join(r->cr,CAIRO_LINE_JOIN_ROUND);
image->img.plugin = (void*)r;
} else {
msSetError(MS_RENDERERERR, "Cannot create cairo image of size %dx%d.",
"msImageCreateCairo()", width, height);
}
return image;
}
gfxPDFSurface::gfxPDFSurface(nsIOutputStream *aStream, const gfxSize& aSizeInPoints)
: mStream(aStream), mXDPI(-1), mYDPI(-1), mSize(aSizeInPoints)
{
Init(cairo_pdf_surface_create_for_stream(write_func, (void*)mStream, mSize.width, mSize.height));
}
int main(int argc, char **argv){
float width=8.5*72.0;
float height=11.0*72.0;
float xoff=0;
float yoff=0;
float fontsize=-1;
int havey=0;
float dpp=300.0/72.0;
char *text=NULL;
int c,long_option_index;
cairo_surface_t *cs;
cairo_t *ct;
cairo_text_extents_t extents;
while((c=getopt_long(argc,argv,optstring,options,&long_option_index))!=EOF){
switch(c){
case 'W':
case 'H':
case 'x':
case 'y':
{
float temp;
if(strstr(optarg,"cm")){
temp=atof(optarg)*28.3464566929;
}else if (strstr(optarg,"mm")){
temp=atof(optarg)*2.83464566929;
}else if (strstr(optarg,"pt")){
temp=atof(optarg);
}else{
temp=atof(optarg)*72.0;
}
switch(c){
case 'W':
width=temp;
break;
case 'H':
height=temp;
break;
case 'x':
xoff=temp;
break;
case 'y':
yoff=temp;
havey=1;
break;
}
}
break;
case 'r':
if(strstr(optarg,"dpcm")){
dpp=atof(optarg)*.03527777777778;
}else if (strstr(optarg,"dpmm")){
dpp=atof(optarg)*.35277777777778;
}else if (strstr(optarg,"dpp")){
dpp=atof(optarg);
}else{
dpp=atof(optarg)*.01388888888889;
}
break;
case 'f':
fontsize=atof(optarg);
break;
case 't':
text=strdup(optarg);
break;
case 'h':
usage(stdout);
exit(0);
case 'v':
fprintf(stderr,"pngxpdf "VERSION"\n");
default:
usage(stderr);
}
}
/* set up our surface */
cs = cairo_pdf_surface_create_for_stream (pdf_write, NULL, width, height);
if(!cs || cairo_surface_status(cs)!=CAIRO_STATUS_SUCCESS){
fprintf(stderr,"CAIRO ERROR: Unable to create PDF surface.\n\n");
exit(1);
}
ct = cairo_create(cs);
if(fontsize<=0){
fontsize=height*15./792.;
if(fontsize<5)fontsize=5;
}
cairo_set_font_size(ct, fontsize);
if(text){
cairo_text_extents(ct, text, &extents);
if(!havey)
yoff = -extents.height-fontsize*4;
}
/* Iterate through PNG files inline */
while(optind<argc){
int ww, hh;
char *filename = argv[optind];
cairo_pattern_t *pattern;
cairo_surface_t *ps=cairo_image_surface_create_from_png(filename);
cairo_status_t status = cairo_surface_status(ps);
if(!ps || status!=CAIRO_STATUS_SUCCESS){
fprintf(stderr,"CAIRO ERROR: Unable to load PNG file %s: %s\n\n",filename,cairo_status_to_string(status));
exit(1);
}
ww = cairo_image_surface_get_width(ps);
hh = cairo_image_surface_get_height(ps);
cairo_save(ct);
cairo_scale(ct, 1./dpp, 1./dpp);
pattern = cairo_pattern_create_for_surface(ps);
cairo_translate(ct,(width*dpp - (ww-1))*.5,((height+yoff)*dpp - (hh-1))*.5);
cairo_pattern_set_filter(pattern, CAIRO_FILTER_BEST);
cairo_set_source(ct,pattern);
cairo_paint(ct);
cairo_restore(ct);
/* draw comment text */
if(text){
cairo_set_source_rgba(ct, 1,1,1,.75);
cairo_move_to(ct, width-extents.width-fontsize*1.5, height-fontsize*1.5);
cairo_text_path (ct, text);
cairo_set_line_width(ct,3.);
cairo_set_line_join(ct,CAIRO_LINE_JOIN_ROUND);
cairo_stroke(ct);
cairo_set_source_rgb(ct, 0,0,0);
cairo_move_to(ct, width-extents.width-fontsize*1.5, height-fontsize*1.5);
cairo_show_text(ct, text);
}
cairo_surface_show_page(cs);
cairo_surface_destroy(ps);
optind++;
}
cairo_destroy(ct);
cairo_surface_destroy(cs);
}
static void cairogen_begin_page(GVJ_t * job)
{
cairo_t *cr = (cairo_t *) job->context;
cairo_surface_t *surface;
cairo_status_t status;
if (cr == NULL) {
switch (job->render.id) {
case FORMAT_PS:
#ifdef CAIRO_HAS_PS_SURFACE
surface = cairo_ps_surface_create_for_stream (writer,
job, job->width, job->height);
#endif
break;
case FORMAT_PDF:
#ifdef CAIRO_HAS_PDF_SURFACE
surface = cairo_pdf_surface_create_for_stream (writer,
job, job->width, job->height);
#endif
break;
case FORMAT_SVG:
#ifdef CAIRO_HAS_SVG_SURFACE
surface = cairo_svg_surface_create_for_stream (writer,
job, job->width, job->height);
#endif
break;
case FORMAT_CAIRO:
case FORMAT_PNG:
default:
if (job->width >= CAIRO_XMAX || job->height >= CAIRO_YMAX) {
double scale = MIN((double)CAIRO_XMAX / job->width,
(double)CAIRO_YMAX / job->height);
job->width *= scale;
job->height *= scale;
job->scale.x *= scale;
job->scale.y *= scale;
fprintf(stderr,
"%s: graph is too large for cairo-renderer bitmaps. Scaling by %g to fit\n",
job->common->cmdname, scale);
}
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
job->width, job->height);
if (job->common->verbose)
fprintf(stderr,
"%s: allocating a %dK cairo image surface (%d x %d pixels)\n",
job->common->cmdname,
ROUND(job->width * job->height * 4 / 1024.),
job->width, job->height);
break;
}
status = cairo_surface_status(surface);
if (status != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "%s: failure to create cairo surface: %s\n",
job->common->cmdname,
cairo_status_to_string(status));
cairo_surface_destroy (surface);
return;
}
cr = cairo_create(surface);
cairo_surface_destroy (surface);
job->context = (void *) cr;
}
cairo_scale(cr, job->scale.x, job->scale.y);
cairo_rotate(cr, -job->rotation * M_PI / 180.);
cairo_translate(cr, job->translation.x, -job->translation.y);
cairo_rectangle(cr, job->clip.LL.x, - job->clip.LL.y,
job->clip.UR.x - job->clip.LL.x, - (job->clip.UR.y - job->clip.LL.y));
cairo_clip(cr);
/* cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND); */
}
