static cairo_surface_t *
_svg_surface_create (void *closure,
cairo_content_t content,
double width, double height)
{
return cairo_svg_surface_create_for_stream (NULL, NULL, width, height);
}
static PyObject *
svg_surface_new (PyTypeObject *type, PyObject *args, PyObject *kwds)
{
double width_in_points, height_in_points;
PyObject *file, *writer;
if (!PyArg_ParseTuple(args, "Odd:SVGSurface.__new__",
&file, &width_in_points, &height_in_points))
return NULL;
if (PyObject_TypeCheck (file, &PyBaseString_Type)) {
/* string (filename) argument */
return PycairoSurface_FromSurface (
cairo_svg_surface_create (PyString_AsString(file),
width_in_points, height_in_points),
NULL);
}
/* else: file or file-like object argument */
writer = PyObject_GetAttrString (file, "write");
if (writer == NULL || !PyCallable_Check (writer)) {
Py_XDECREF(writer);
PyErr_SetString(PyExc_TypeError,
"SVGSurface 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_svg_surface_create_for_stream (_write_func, file,
width_in_points, height_in_points),
file);
}
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;
}
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_;
}
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;
}
/*!
* \brief Object update function called after property change
*
* Not in the object interface but very important anyway.
* Used to recalculate the object data after a change
* \protected \memberof Outline
*/
static void
outline_update_data (Outline *outline)
{
DiaObject *obj = &outline->object;
/* calculate the ink_rect from two points and the given rotation */
cairo_t *cr;
cairo_surface_t *surface;
cairo_text_extents_t extents;
real x, y;
DiaFontStyle style;
if (outline->path)
cairo_path_destroy (outline->path);
outline->path = NULL;
/* surface will not be used to render anything, it is just to create the cairo context */
surface = cairo_svg_surface_create_for_stream (write_nul, NULL, 100, 100);
cr = cairo_create (surface);
cairo_surface_destroy (surface); /* in fact: unref() */
style = dia_font_get_style (outline->font);
/* not exact matching but almost the best we can do with the toy api */
cairo_select_font_face (cr, dia_font_get_family (outline->font),
DIA_FONT_STYLE_GET_SLANT (style) == DIA_FONT_NORMAL ? CAIRO_FONT_SLANT_NORMAL : CAIRO_FONT_SLANT_ITALIC,
DIA_FONT_STYLE_GET_WEIGHT (style) < DIA_FONT_MEDIUM ? CAIRO_FONT_WEIGHT_NORMAL : CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, outline->font_height);
cairo_text_extents (cr, outline->name, &extents);
/* unfortunately this has no effect on the returned path? See below. */
cairo_rotate (cr, outline->rotation/(2*G_PI));
outline->mat.xx = cos(G_PI*outline->rotation/180);
outline->mat.xy = sin(G_PI*outline->rotation/180);
outline->mat.yx = -sin(G_PI*outline->rotation/180);
outline->mat.yy = cos(G_PI*outline->rotation/180);
/* fix point */
outline->ink_rect[0].x = x = obj->position.x;
outline->ink_rect[0].y = y = obj->position.y;
/* handle rotation */
outline->ink_rect[1].x = x + extents.width * outline->mat.xx;
outline->ink_rect[1].y = y + extents.width * outline->mat.yx;
outline->ink_rect[2].x = x + extents.width * outline->mat.xx + extents.height * outline->mat.xy;
outline->ink_rect[2].y = y + extents.width * outline->mat.yx + extents.height * outline->mat.yy;
outline->ink_rect[3].x = x + extents.height * outline->mat.xy;
outline->ink_rect[3].y = y + extents.height * outline->mat.yy;
/* x_advance? */
/* calculate bounding box */
{
PolyBBExtras bbex = {0, 0, outline->line_width/2, 0, 0 };
polyline_bbox (&outline->ink_rect[0], 4, &bbex, TRUE, &obj->bounding_box);
}
outline_update_handles (outline),
cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing);
#if 0
/* reset the matrix to not yet change the outline_draw method */
outline->mat.xx = 1.0;
outline->mat.xy = 0.0;
outline->mat.yx = 0.0;
outline->mat.yy = 1.0;
#endif
cairo_text_path (cr, outline->name);
/* reset the rotation to not have the path rotated back and forth: no effect */
cairo_rotate (cr, 0.0);
outline->path = cairo_copy_path (cr);
/* the cairo context is only used in this fuinction */
cairo_destroy (cr);
}
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); */
}
