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); */ }