[cairo] [XCB] patches for 1.0 RC2
Ian Osgood
iano at quirkster.com
Wed Oct 11 21:44:57 PDT 2006
This patch brings cairo XCB backend up to XCB RC2.
-------------- next part --------------
>From 1fae687d2fb98a834ad34a210fe6547644874296 Mon Sep 17 00:00:00 2001
From: Ian Osgood <iano at quirkster.com>
Date: Sat, 30 Sep 2006 13:23:06 -0700
Subject: [PATCH] Update XCB names for XCB 1.0 RC2 release.
New names are in line with cairo naming standards.
XIDs are now typedefs not structs.
xcb_generate_id replaces *_new functions.
Also fixed all warnings (one const, new enums in switch statements).
---
boilerplate/cairo-boilerplate.c | 56 +++----
configure.in | 2
src/cairo-xcb-surface.c | 303 ++++++++++++++++++++-------------------
src/cairo-xcb-xrender.h | 12 +-
src/cairo-xcb.h | 14 +-
5 files changed, 194 insertions(+), 193 deletions(-)
diff --git a/boilerplate/cairo-boilerplate.c b/boilerplate/cairo-boilerplate.c
index 0bb479b..d3976cc 100644
--- a/boilerplate/cairo-boilerplate.c
+++ b/boilerplate/cairo-boilerplate.c
@@ -782,19 +782,20 @@ #if CAIRO_HAS_XCB_SURFACE
#include "cairo-xcb-xrender.h"
typedef struct _xcb_target_closure
{
- XCBConnection *c;
- XCBDRAWABLE drawable;
+ xcb_connection_t *c;
+ xcb_pixmap_t pixmap;
} xcb_target_closure_t;
/* XXX: This is a nasty hack. Something like this should be in XCB's
- * bindings for Render, not here in this test. */
-static XCBRenderPICTFORMINFO
-_format_from_cairo(XCBConnection *c, cairo_format_t fmt)
+ * bindings for Render, not here in this test.
+ * TODO: replace with <xcb/xcb_renderutil.h> utilities */
+static xcb_render_pictforminfo_t
+_format_from_cairo(xcb_connection_t *c, cairo_format_t fmt)
{
- XCBRenderPICTFORMINFO ret = {{ 0 }};
+ xcb_render_pictforminfo_t ret = { 0 };
struct tmpl_t {
- XCBRenderDIRECTFORMAT direct;
- CARD8 depth;
+ xcb_render_directformat_t direct;
+ uint8_t depth;
};
static const struct tmpl_t templates[] = {
/* CAIRO_FORMAT_ARGB32 */
@@ -839,21 +840,21 @@ _format_from_cairo(XCBConnection *c, cai
},
};
const struct tmpl_t *tmpl;
- XCBRenderQueryPictFormatsRep *r;
- XCBRenderPICTFORMINFOIter fi;
+ xcb_render_query_pict_formats_reply_t *r;
+ xcb_render_pictforminfo_iterator_t fi;
if(fmt < 0 || fmt >= (sizeof(templates) / sizeof(*templates)))
return ret;
tmpl = templates + fmt;
- r = XCBRenderQueryPictFormatsReply(c, XCBRenderQueryPictFormats(c), 0);
+ r = xcb_render_query_pict_formats_reply(c, xcb_render_query_pict_formats(c), 0);
if(!r)
return ret;
- for(fi = XCBRenderQueryPictFormatsFormatsIter(r); fi.rem; XCBRenderPICTFORMINFONext(&fi))
+ for(fi = xcb_render_query_pict_formats_formats_iterator(r); fi.rem; xcb_render_pictforminfo_next(&fi))
{
- const XCBRenderDIRECTFORMAT *t, *f;
- if(fi.data->type != XCBRenderPictTypeDirect)
+ const xcb_render_directformat_t *t, *f;
+ if(fi.data->type != XCB_RENDER_PICT_TYPE_DIRECT)
continue;
if(fi.data->depth != tmpl->depth)
continue;
@@ -883,11 +884,11 @@ create_xcb_surface (const char *name,
cairo_boilerplate_mode_t mode,
void **closure)
{
- XCBSCREEN *root;
+ xcb_screen_t *root;
xcb_target_closure_t *xtc;
cairo_surface_t *surface;
- XCBConnection *c;
- XCBRenderPICTFORMINFO render_format;
+ xcb_connection_t *c;
+ xcb_render_pictforminfo_t render_format;
cairo_format_t format;
*closure = xtc = xmalloc (sizeof (xcb_target_closure_t));
@@ -897,21 +898,17 @@ create_xcb_surface (const char *name,
if (height == 0)
height = 1;
- xtc->c = c = XCBConnect(NULL,NULL);
+ xtc->c = c = xcb_connect(NULL,NULL);
if (c == NULL) {
CAIRO_BOILERPLATE_LOG ("Failed to connect to X server through XCB\n");
return NULL;
}
- root = XCBSetupRootsIter(XCBGetSetup(c)).data;
+ root = xcb_setup_roots_iterator(xcb_get_setup(c)).data;
- xtc->drawable.pixmap = XCBPIXMAPNew (c);
- {
- XCBDRAWABLE root_drawable;
- root_drawable.window = root->root;
- XCBCreatePixmap (c, 32, xtc->drawable.pixmap, root_drawable,
+ xtc->pixmap = xcb_generate_id (c);
+ xcb_create_pixmap (c, 32, xtc->pixmap, root->root,
width, height);
- }
switch (content) {
case CAIRO_CONTENT_COLOR:
@@ -920,15 +917,16 @@ create_xcb_surface (const char *name,
case CAIRO_CONTENT_COLOR_ALPHA:
format = CAIRO_FORMAT_ARGB32;
break;
+ case CAIRO_CONTENT_ALPHA:
default:
CAIRO_BOILERPLATE_LOG ("Invalid content for XCB test: %d\n", content);
return NULL;
}
render_format = _format_from_cairo (c, format);
- if (render_format.id.xid == 0)
+ if (render_format.id == 0)
return NULL;
- surface = cairo_xcb_surface_create_with_xrender_format (c, xtc->drawable, root,
+ surface = cairo_xcb_surface_create_with_xrender_format (c, xtc->pixmap, root,
&render_format,
width, height);
@@ -940,8 +938,8 @@ cleanup_xcb (void *closure)
{
xcb_target_closure_t *xtc = closure;
- XCBFreePixmap (xtc->c, xtc->drawable.pixmap);
- XCBDisconnect (xtc->c);
+ xcb_free_pixmap (xtc->c, xtc->pixmap);
+ xcb_disconnect (xtc->c);
free (xtc);
}
#endif
diff --git a/configure.in b/configure.in
index 6cc91bf..0d81131 100644
--- a/configure.in
+++ b/configure.in
@@ -269,7 +269,7 @@ CAIRO_BACKEND_ENABLE(nquartz, NativeQuar
dnl ===========================================================================
CAIRO_BACKEND_ENABLE(xcb, XCB, xcb, XCB_SURFACE, no, [
- xcb_REQUIRES="xcb xcb-render xcb-renderutil"
+ xcb_REQUIRES="xcb >= 0.9.92 xcb-render >= 0.9.92 xcb-renderutil"
PKG_CHECK_MODULES(xcb, $xcb_REQUIRES, , [
use_xcb="no (requires XCB http://xcb.freedesktop.org)"])
])
diff --git a/src/cairo-xcb-surface.c b/src/cairo-xcb-surface.c
index f60bc3b..c28b7ab 100644
--- a/src/cairo-xcb-surface.c
+++ b/src/cairo-xcb-surface.c
@@ -37,12 +37,12 @@
#include "cairoint.h"
#include "cairo-xcb.h"
#include "cairo-xcb-xrender.h"
-#include <X11/XCB/xcb_renderutil.h>
+#include <xcb/xcb_renderutil.h>
#define AllPlanes ((unsigned long)~0L)
static cairo_content_t
-_xcb_render_format_to_content (XCBRenderPICTFORMINFO *xrender_format)
+_xcb_render_format_to_content (xcb_render_pictforminfo_t *xrender_format)
{
cairo_bool_t xrender_format_has_alpha;
cairo_bool_t xrender_format_has_color;
@@ -78,13 +78,13 @@ #define CAIRO_ASSUME_PIXMAP 20
typedef struct cairo_xcb_surface {
cairo_surface_t base;
- XCBConnection *dpy;
- XCBSCREEN *screen;
+ xcb_connection_t *dpy;
+ xcb_screen_t *screen;
- XCBGCONTEXT gc;
- XCBDRAWABLE drawable;
+ xcb_gcontext_t gc;
+ xcb_drawable_t drawable;
int owns_pixmap;
- XCBVISUALTYPE *visual;
+ xcb_visualtype_t *visual;
int use_pixmap;
@@ -95,11 +95,11 @@ typedef struct cairo_xcb_surface {
int height;
int depth;
- XCBRECTANGLE *clip_rects;
+ xcb_rectangle_t *clip_rects;
int num_clip_rects;
- XCBRenderPICTURE picture;
- XCBRenderPICTFORMINFO format;
+ xcb_render_picture_t picture;
+ xcb_render_pictforminfo_t format;
int has_format;
} cairo_xcb_surface_t;
@@ -150,11 +150,11 @@ _cairo_xcb_surface_create_similar (void
int height)
{
cairo_xcb_surface_t *src = abstract_src;
- XCBConnection *dpy = src->dpy;
- XCBDRAWABLE d;
+ xcb_connection_t *dpy = src->dpy;
+ xcb_pixmap_t pixmap;
cairo_xcb_surface_t *surface;
cairo_format_t format = _cairo_format_from_content (content);
- XCBRenderPICTFORMINFO *xrender_format;
+ xcb_render_pictforminfo_t *xrender_format;
/* As a good first approximation, if the display doesn't have COMPOSITE,
* we're better off using image surfaces for all temporary operations
@@ -163,16 +163,16 @@ _cairo_xcb_surface_create_similar (void
return cairo_image_surface_create (format, width, height);
}
- d.pixmap = XCBPIXMAPNew (dpy);
- XCBCreatePixmap (dpy, _CAIRO_FORMAT_DEPTH (format),
- d.pixmap, src->drawable,
+ pixmap = xcb_generate_id (dpy);
+ xcb_create_pixmap (dpy, _CAIRO_FORMAT_DEPTH (format),
+ pixmap, src->drawable,
width <= 0 ? 1 : width,
height <= 0 ? 1 : height);
- xrender_format = XCBRenderUtilFindStandardFormat (XCBRenderUtilQueryFormats (dpy), format);
+ xrender_format = xcb_render_util_find_standard_format (xcb_render_util_query_formats (dpy), format);
/* XXX: what to do if xrender_format is null? */
surface = (cairo_xcb_surface_t *)
- cairo_xcb_surface_create_with_xrender_format (dpy, d, src->screen,
+ cairo_xcb_surface_create_with_xrender_format (dpy, pixmap, src->screen,
xrender_format,
width, height);
if (surface->base.status) {
@@ -189,14 +189,14 @@ static cairo_status_t
_cairo_xcb_surface_finish (void *abstract_surface)
{
cairo_xcb_surface_t *surface = abstract_surface;
- if (surface->picture.xid)
- XCBRenderFreePicture (surface->dpy, surface->picture);
+ if (surface->picture)
+ xcb_render_free_picture (surface->dpy, surface->picture);
if (surface->owns_pixmap)
- XCBFreePixmap (surface->dpy, surface->drawable.pixmap);
+ xcb_free_pixmap (surface->dpy, surface->drawable);
- if (surface->gc.xid)
- XCBFreeGC (surface->dpy, surface->gc);
+ if (surface->gc)
+ xcb_free_gc (surface->dpy, surface->gc);
free (surface->clip_rects);
@@ -206,10 +206,10 @@ _cairo_xcb_surface_finish (void *abstrac
}
static int
-_bits_per_pixel(XCBConnection *c, int depth)
+_bits_per_pixel(xcb_connection_t *c, int depth)
{
- XCBFORMAT *fmt = XCBSetupPixmapFormats(XCBGetSetup(c));
- XCBFORMAT *fmtend = fmt + XCBSetupPixmapFormatsLength(XCBGetSetup(c));
+ xcb_format_t *fmt = xcb_setup_pixmap_formats(xcb_get_setup(c));
+ xcb_format_t *fmtend = fmt + xcb_setup_pixmap_formats_length(xcb_get_setup(c));
for(; fmt != fmtend; ++fmt)
if(fmt->depth == depth)
@@ -225,9 +225,9 @@ _bits_per_pixel(XCBConnection *c, int de
}
static int
-_bytes_per_line(XCBConnection *c, int width, int bpp)
+_bytes_per_line(xcb_connection_t *c, int width, int bpp)
{
- int bitmap_pad = XCBGetSetup(c)->bitmap_format_scanline_pad;
+ int bitmap_pad = xcb_get_setup(c)->bitmap_format_scanline_pad;
return ((bpp * width + bitmap_pad - 1) & -bitmap_pad) >> 3;
}
@@ -278,7 +278,7 @@ _get_image_surface (cairo_xcb_surface_t
cairo_rectangle_int16_t *image_rect)
{
cairo_image_surface_t *image;
- XCBGetImageRep *imagerep;
+ xcb_get_image_reply_t *imagerep;
int bpp, bytes_per_line;
int x1, y1, x2, y2;
unsigned char *data;
@@ -324,9 +324,9 @@ _get_image_surface (cairo_xcb_surface_t
if (surface->use_pixmap == 0)
{
- XCBGenericError *error;
- imagerep = XCBGetImageReply(surface->dpy,
- XCBGetImage(surface->dpy, XCBImageFormatZPixmap,
+ xcb_generic_error_t *error;
+ imagerep = xcb_get_image_reply(surface->dpy,
+ xcb_get_image(surface->dpy, XCB_IMAGE_FORMAT_Z_PIXMAP,
surface->drawable,
x1, y1,
x2 - x1, y2 - y1,
@@ -346,31 +346,31 @@ _get_image_surface (cairo_xcb_surface_t
if (!imagerep)
{
- /* XCBGetImage from a window is dangerous because it can
+ /* xcb_get_image_t from a window is dangerous because it can
* produce errors if the window is unmapped or partially
* outside the screen. We could check for errors and
* retry, but to keep things simple, we just create a
* temporary pixmap
*/
- XCBDRAWABLE drawable;
- drawable.pixmap = XCBPIXMAPNew (surface->dpy);
- XCBCreatePixmap (surface->dpy,
+ xcb_pixmap_t pixmap;
+ pixmap = xcb_generate_id (surface->dpy);
+ xcb_create_pixmap (surface->dpy,
surface->depth,
- drawable.pixmap,
+ pixmap,
surface->drawable,
x2 - x1, y2 - y1);
_cairo_xcb_surface_ensure_gc (surface);
- XCBCopyArea (surface->dpy, surface->drawable, drawable, surface->gc,
+ xcb_copy_area (surface->dpy, surface->drawable, pixmap, surface->gc,
x1, y1, 0, 0, x2 - x1, y2 - y1);
- imagerep = XCBGetImageReply(surface->dpy,
- XCBGetImage(surface->dpy, XCBImageFormatZPixmap,
- drawable,
+ imagerep = xcb_get_image_reply(surface->dpy,
+ xcb_get_image(surface->dpy, XCB_IMAGE_FORMAT_Z_PIXMAP,
+ pixmap,
x1, y1,
x2 - x1, y2 - y1,
AllPlanes), 0);
- XCBFreePixmap (surface->dpy, drawable.pixmap);
+ xcb_free_pixmap (surface->dpy, pixmap);
}
if (!imagerep)
@@ -385,12 +385,12 @@ _get_image_surface (cairo_xcb_surface_t
return CAIRO_STATUS_NO_MEMORY;
}
- memcpy (data, XCBGetImageData (imagerep), bytes_per_line * surface->height);
+ memcpy (data, xcb_get_image_data (imagerep), bytes_per_line * surface->height);
free (imagerep);
/*
- * Compute the pixel format masks from either an XCBVISUALTYPE or
- * a XCBRenderPCTFORMINFO, failing we assume the drawable is an
+ * Compute the pixel format masks from either an xcb_visualtype_t or
+ * a xcb_render_pctforminfo_t, failing we assume the drawable is an
* alpha-only pixmap as it could only have been created that way
* through the cairo_xlib_surface_create_for_bitmap function.
*/
@@ -462,7 +462,7 @@ static void
_cairo_xcb_surface_set_picture_clip_rects (cairo_xcb_surface_t *surface)
{
if (surface->num_clip_rects)
- XCBRenderSetPictureClipRectangles (surface->dpy, surface->picture,
+ xcb_render_set_picture_clip_rectangles (surface->dpy, surface->picture,
0, 0,
surface->num_clip_rects,
surface->clip_rects);
@@ -472,7 +472,7 @@ static void
_cairo_xcb_surface_set_gc_clip_rects (cairo_xcb_surface_t *surface)
{
if (surface->num_clip_rects)
- XCBSetClipRectangles(surface->dpy, XCBClipOrderingYXSorted, surface->gc,
+ xcb_set_clip_rectangles(surface->dpy, XCB_CLIP_ORDERING_YX_SORTED, surface->gc,
0, 0,
surface->num_clip_rects,
surface->clip_rects );
@@ -481,11 +481,11 @@ _cairo_xcb_surface_set_gc_clip_rects (ca
static void
_cairo_xcb_surface_ensure_gc (cairo_xcb_surface_t *surface)
{
- if (surface->gc.xid)
+ if (surface->gc)
return;
- surface->gc = XCBGCONTEXTNew(surface->dpy);
- XCBCreateGC (surface->dpy, surface->gc, surface->drawable, 0, 0);
+ surface->gc = xcb_generate_id(surface->dpy);
+ xcb_create_gc (surface->dpy, surface->gc, surface->drawable, 0, 0);
_cairo_xcb_surface_set_gc_clip_rects(surface);
}
@@ -500,7 +500,7 @@ _draw_image_surface (cairo_xcb_surface_t
_cairo_xcb_surface_ensure_gc (surface);
bpp = _bits_per_pixel(surface->dpy, image->depth);
data_len = _bytes_per_line(surface->dpy, image->width, bpp) * image->height;
- XCBPutImage(surface->dpy, XCBImageFormatZPixmap, surface->drawable, surface->gc,
+ xcb_put_image(surface->dpy, XCB_IMAGE_FORMAT_Z_PIXMAP, surface->drawable, surface->gc,
image->width,
image->height,
dst_x, dst_y,
@@ -628,9 +628,9 @@ static cairo_status_t
_cairo_xcb_surface_set_matrix (cairo_xcb_surface_t *surface,
cairo_matrix_t *matrix)
{
- XCBRenderTRANSFORM xtransform;
+ xcb_render_transform_t xtransform;
- if (!surface->picture.xid)
+ if (!surface->picture)
return CAIRO_STATUS_SUCCESS;
xtransform.matrix11 = _cairo_fixed_from_double (matrix->xx);
@@ -647,19 +647,19 @@ _cairo_xcb_surface_set_matrix (cairo_xcb
if (!CAIRO_SURFACE_RENDER_HAS_PICTURE_TRANSFORM (surface))
{
- static const XCBRenderTRANSFORM identity = {
+ static const xcb_render_transform_t identity = {
1 << 16, 0x00000, 0x00000,
0x00000, 1 << 16, 0x00000,
0x00000, 0x00000, 1 << 16
};
- if (memcmp (&xtransform, &identity, sizeof (XCBRenderTRANSFORM)) == 0)
+ if (memcmp (&xtransform, &identity, sizeof (xcb_render_transform_t)) == 0)
return CAIRO_STATUS_SUCCESS;
return CAIRO_INT_STATUS_UNSUPPORTED;
}
- XCBRenderSetPictureTransform (surface->dpy, surface->picture, xtransform);
+ xcb_render_set_picture_transform (surface->dpy, surface->picture, xtransform);
return CAIRO_STATUS_SUCCESS;
}
@@ -668,9 +668,9 @@ static cairo_status_t
_cairo_xcb_surface_set_filter (cairo_xcb_surface_t *surface,
cairo_filter_t filter)
{
- char *render_filter;
+ const char *render_filter;
- if (!surface->picture.xid)
+ if (!surface->picture)
return CAIRO_STATUS_SUCCESS;
if (!CAIRO_SURFACE_RENDER_HAS_FILTERS (surface))
@@ -697,12 +697,13 @@ _cairo_xcb_surface_set_filter (cairo_xcb
case CAIRO_FILTER_BILINEAR:
render_filter = "bilinear";
break;
+ case CAIRO_FILTER_GAUSSIAN:
default:
render_filter = "best";
break;
}
- XCBRenderSetPictureFilter(surface->dpy, surface->picture,
+ xcb_render_set_picture_filter(surface->dpy, surface->picture,
strlen(render_filter), render_filter, 0, NULL);
return CAIRO_STATUS_SUCCESS;
@@ -711,13 +712,13 @@ _cairo_xcb_surface_set_filter (cairo_xcb
static cairo_status_t
_cairo_xcb_surface_set_repeat (cairo_xcb_surface_t *surface, int repeat)
{
- CARD32 mask = XCBRenderCPRepeat;
- CARD32 pa[] = { repeat };
+ uint32_t mask = XCB_RENDER_CP_REPEAT;
+ uint32_t pa[] = { repeat };
- if (!surface->picture.xid)
+ if (!surface->picture)
return CAIRO_STATUS_SUCCESS;
- XCBRenderChangePicture (surface->dpy, surface->picture, mask, pa);
+ xcb_render_change_picture (surface->dpy, surface->picture, mask, pa);
return CAIRO_STATUS_SUCCESS;
}
@@ -757,35 +758,35 @@ _render_operator (cairo_operator_t op)
{
switch (op) {
case CAIRO_OPERATOR_CLEAR:
- return XCBRenderPictOpClear;
+ return XCB_RENDER_PICT_OP_CLEAR;
case CAIRO_OPERATOR_SOURCE:
- return XCBRenderPictOpSrc;
+ return XCB_RENDER_PICT_OP_SRC;
case CAIRO_OPERATOR_DEST:
- return XCBRenderPictOpDst;
+ return XCB_RENDER_PICT_OP_DST;
case CAIRO_OPERATOR_OVER:
- return XCBRenderPictOpOver;
+ return XCB_RENDER_PICT_OP_OVER;
case CAIRO_OPERATOR_DEST_OVER:
- return XCBRenderPictOpOverReverse;
+ return XCB_RENDER_PICT_OP_OVER_REVERSE;
case CAIRO_OPERATOR_IN:
- return XCBRenderPictOpIn;
+ return XCB_RENDER_PICT_OP_IN;
case CAIRO_OPERATOR_DEST_IN:
- return XCBRenderPictOpInReverse;
+ return XCB_RENDER_PICT_OP_IN_REVERSE;
case CAIRO_OPERATOR_OUT:
- return XCBRenderPictOpOut;
+ return XCB_RENDER_PICT_OP_OUT;
case CAIRO_OPERATOR_DEST_OUT:
- return XCBRenderPictOpOutReverse;
+ return XCB_RENDER_PICT_OP_OUT_REVERSE;
case CAIRO_OPERATOR_ATOP:
- return XCBRenderPictOpAtop;
+ return XCB_RENDER_PICT_OP_ATOP;
case CAIRO_OPERATOR_DEST_ATOP:
- return XCBRenderPictOpAtopReverse;
+ return XCB_RENDER_PICT_OP_ATOP_REVERSE;
case CAIRO_OPERATOR_XOR:
- return XCBRenderPictOpXor;
+ return XCB_RENDER_PICT_OP_XOR;
case CAIRO_OPERATOR_ADD:
- return XCBRenderPictOpAdd;
+ return XCB_RENDER_PICT_OP_ADD;
case CAIRO_OPERATOR_SATURATE:
- return XCBRenderPictOpSaturate;
+ return XCB_RENDER_PICT_OP_SATURATE;
default:
- return XCBRenderPictOpOver;
+ return XCB_RENDER_PICT_OP_OVER;
}
}
@@ -830,7 +831,7 @@ _cairo_xcb_surface_composite (cairo_oper
{
status = _cairo_xcb_surface_set_attributes (mask, &mask_attr);
if (status == CAIRO_STATUS_SUCCESS)
- XCBRenderComposite (dst->dpy,
+ xcb_render_composite (dst->dpy,
_render_operator (op),
src->picture,
mask->picture,
@@ -844,9 +845,9 @@ _cairo_xcb_surface_composite (cairo_oper
}
else
{
- static XCBRenderPICTURE maskpict = { 0 };
+ static xcb_render_picture_t maskpict = { 0 };
- XCBRenderComposite (dst->dpy,
+ xcb_render_composite (dst->dpy,
_render_operator (op),
src->picture,
maskpict,
@@ -875,7 +876,7 @@ _cairo_xcb_surface_fill_rectangles (void
int num_rects)
{
cairo_xcb_surface_t *surface = abstract_surface;
- XCBRenderCOLOR render_color;
+ xcb_render_color_t render_color;
if (!CAIRO_SURFACE_RENDER_HAS_FILL_RECTANGLE (surface))
return CAIRO_INT_STATUS_UNSUPPORTED;
@@ -885,11 +886,11 @@ _cairo_xcb_surface_fill_rectangles (void
render_color.blue = color->blue_short;
render_color.alpha = color->alpha_short;
- /* XXX: This XCBRECTANGLE cast is evil... it needs to go away somehow. */
- XCBRenderFillRectangles (surface->dpy,
+ /* XXX: This xcb_rectangle_t cast is evil... it needs to go away somehow. */
+ xcb_render_fill_rectangles (surface->dpy,
_render_operator (op),
surface->picture,
- render_color, num_rects, (XCBRECTANGLE *) rects);
+ render_color, num_rects, (xcb_rectangle_t *) rects);
return CAIRO_STATUS_SUCCESS;
}
@@ -915,7 +916,7 @@ _cairo_xcb_surface_composite_trapezoids
int render_reference_x, render_reference_y;
int render_src_x, render_src_y;
int cairo_format;
- XCBRenderPICTFORMINFO *render_format;
+ xcb_render_pictforminfo_t *render_format;
if (!CAIRO_SURFACE_RENDER_HAS_TRAPEZOIDS (dst))
return CAIRO_INT_STATUS_UNSUPPORTED;
@@ -942,23 +943,26 @@ _cairo_xcb_surface_composite_trapezoids
case CAIRO_ANTIALIAS_NONE:
cairo_format = CAIRO_FORMAT_A1;
break;
+ case CAIRO_ANTIALIAS_DEFAULT:
+ case CAIRO_ANTIALIAS_GRAY:
+ case CAIRO_ANTIALIAS_SUBPIXEL:
default:
cairo_format = CAIRO_FORMAT_A8;
break;
}
- render_format = XCBRenderUtilFindStandardFormat (XCBRenderUtilQueryFormats (dst->dpy), cairo_format);
+ render_format = xcb_render_util_find_standard_format (xcb_render_util_query_formats (dst->dpy), cairo_format);
/* XXX: what to do if render_format is null? */
/* XXX: The XTrapezoid cast is evil and needs to go away somehow. */
status = _cairo_xcb_surface_set_attributes (src, &attributes);
if (status == CAIRO_STATUS_SUCCESS)
- XCBRenderTrapezoids (dst->dpy,
+ xcb_render_trapezoids (dst->dpy,
_render_operator (op),
src->picture, dst->picture,
render_format->id,
render_src_x + attributes.x_offset,
render_src_y + attributes.y_offset,
- num_traps, (XCBRenderTRAPEZOID *) traps);
+ num_traps, (xcb_render_trapezoid_t *) traps);
_cairo_pattern_release_surface (pattern, &src->base, &attributes);
@@ -979,27 +983,27 @@ _cairo_xcb_surface_set_clip_region (void
surface->num_clip_rects = 0;
if (region == NULL) {
- if (surface->gc.xid) {
- CARD32 mask = XCBGCClipMask;
- CARD32 pa[] = { XCBNone };
+ if (surface->gc) {
+ uint32_t mask = XCB_GC_CLIP_MASK;
+ uint32_t pa[] = { XCB_NONE };
- XCBChangeGC (surface->dpy, surface->gc, mask, pa);
+ xcb_change_gc (surface->dpy, surface->gc, mask, pa);
}
- if (surface->has_format && surface->picture.xid) {
- CARD32 mask = XCBRenderCPClipMask;
- CARD32 pa[] = { XCBNone };
+ if (surface->has_format && surface->picture) {
+ uint32_t mask = XCB_RENDER_CP_CLIP_MASK;
+ uint32_t pa[] = { XCB_NONE };
- XCBRenderChangePicture (surface->dpy, surface->picture, mask, pa);
+ xcb_render_change_picture (surface->dpy, surface->picture, mask, pa);
}
} else {
pixman_box16_t *boxes;
- XCBRECTANGLE *rects = NULL;
+ xcb_rectangle_t *rects = NULL;
int n_boxes, i;
n_boxes = pixman_region_num_rects (region);
if (n_boxes > 0) {
- rects = malloc (sizeof(XCBRECTANGLE) * n_boxes);
+ rects = malloc (sizeof(xcb_rectangle_t) * n_boxes);
if (rects == NULL)
return CAIRO_STATUS_NO_MEMORY;
} else {
@@ -1018,10 +1022,10 @@ _cairo_xcb_surface_set_clip_region (void
surface->clip_rects = rects;
surface->num_clip_rects = n_boxes;
- if (surface->gc.xid)
+ if (surface->gc)
_cairo_xcb_surface_set_gc_clip_rects (surface);
- if (surface->picture.xid)
+ if (surface->picture)
_cairo_xcb_surface_set_picture_clip_rects (surface);
}
@@ -1083,17 +1087,17 @@ _cairo_surface_is_xcb (cairo_surface_t *
}
static cairo_surface_t *
-_cairo_xcb_surface_create_internal (XCBConnection *dpy,
- XCBDRAWABLE drawable,
- XCBSCREEN *screen,
- XCBVISUALTYPE *visual,
- XCBRenderPICTFORMINFO *format,
+_cairo_xcb_surface_create_internal (xcb_connection_t *dpy,
+ xcb_drawable_t drawable,
+ xcb_screen_t *screen,
+ xcb_visualtype_t *visual,
+ xcb_render_pictforminfo_t *format,
int width,
int height,
int depth)
{
cairo_xcb_surface_t *surface;
- const XCBRenderQueryVersionRep *r;
+ const xcb_render_query_version_reply_t *r;
surface = malloc (sizeof (cairo_xcb_surface_t));
if (surface == NULL) {
@@ -1107,7 +1111,7 @@ _cairo_xcb_surface_create_internal (XCBC
surface->dpy = dpy;
surface->screen = screen;
- surface->gc.xid = 0;
+ surface->gc = XCB_NONE;
surface->drawable = drawable;
surface->owns_pixmap = FALSE;
surface->visual = visual;
@@ -1115,7 +1119,7 @@ _cairo_xcb_surface_create_internal (XCBC
surface->format = *format;
surface->has_format = 1;
} else {
- surface->format.id.xid = 0;
+ surface->format.id = XCB_NONE;
surface->has_format = 0;
}
surface->use_pixmap = 0;
@@ -1129,19 +1133,19 @@ _cairo_xcb_surface_create_internal (XCBC
if (format) {
surface->depth = format->depth;
} else if (visual) {
- XCBDEPTHIter depths;
- XCBVISUALTYPEIter visuals;
+ xcb_depth_iterator_t depths;
+ xcb_visualtype_iterator_t visuals;
/* This is ugly, but we have to walk over all visuals
* for the screen to find the depth.
*/
- depths = XCBSCREENAllowedDepthsIter(screen);
- for(; depths.rem; XCBDEPTHNext(&depths))
+ depths = xcb_screen_allowed_depths_iterator(screen);
+ for(; depths.rem; xcb_depth_next(&depths))
{
- visuals = XCBDEPTHVisualsIter(depths.data);
- for(; visuals.rem; XCBVISUALTYPENext(&visuals))
+ visuals = xcb_depth_visuals_iterator(depths.data);
+ for(; visuals.rem; xcb_visualtype_next(&visuals))
{
- if(visuals.data->visual_id.id == visual->visual_id.id)
+ if(visuals.data->visual_id == visual->visual_id)
{
surface->depth = depths.data->depth;
goto found;
@@ -1155,58 +1159,59 @@ _cairo_xcb_surface_create_internal (XCBC
surface->render_major = -1;
surface->render_minor = -1;
- r = XCBRenderUtilQueryVersion(dpy);
+ r = xcb_render_util_query_version(dpy);
if (r) {
surface->render_major = r->major_version;
surface->render_minor = r->minor_version;
}
- surface->picture.xid = 0;
+ surface->picture = XCB_NONE;
if (CAIRO_SURFACE_RENDER_HAS_CREATE_PICTURE (surface))
{
- static const XCBRenderPICTFORMAT nil = { 0 };
- const XCBRenderPICTFORMAT *pict_format = &nil;
+ static const xcb_render_pictformat_t nil = { 0 };
+ const xcb_render_pictformat_t *pict_format = &nil;
if (format) {
pict_format = &format->id;
} else if (visual) {
- XCBRenderPICTVISUAL *pict_visual;
- pict_visual = XCBRenderUtilFindVisualFormat (XCBRenderUtilQueryFormats (dpy), visual->visual_id);
+ xcb_render_pictvisual_t *pict_visual;
+ pict_visual = xcb_render_util_find_visual_format (xcb_render_util_query_formats (dpy), visual->visual_id);
if (pict_visual)
pict_format = &pict_visual->format;
} else if (depth == 1) {
- XCBRenderPICTFORMINFO *format_info;
- format_info = XCBRenderUtilFindStandardFormat (XCBRenderUtilQueryFormats (dpy), CAIRO_FORMAT_A1);
+ xcb_render_pictforminfo_t *format_info;
+ format_info = xcb_render_util_find_standard_format (xcb_render_util_query_formats (dpy), CAIRO_FORMAT_A1);
if (format_info)
pict_format = &format_info->id;
}
/* XXX: if pict_format is nil, should we still call CreatePicture? */
- surface->picture = XCBRenderPICTURENew(dpy);
- XCBRenderCreatePicture (dpy, surface->picture, drawable,
+ surface->picture = xcb_generate_id(dpy);
+ xcb_render_create_picture (dpy, surface->picture, drawable,
*pict_format, 0, NULL);
}
return (cairo_surface_t *) surface;
}
-static XCBSCREEN *
-_cairo_xcb_screen_from_visual (XCBConnection *c, XCBVISUALTYPE *visual)
+static xcb_screen_t *
+_cairo_xcb_screen_from_visual (xcb_connection_t *c, xcb_visualtype_t *visual)
{
- XCBSCREENIter s = XCBSetupRootsIter(XCBGetSetup(c));
- for (; s.rem; XCBSCREENNext(&s))
+ xcb_depth_iterator_t d;
+ xcb_screen_iterator_t s = xcb_setup_roots_iterator(xcb_get_setup(c));
+ for (; s.rem; xcb_screen_next(&s))
{
- if (s.data->root_visual.id == visual->visual_id.id)
+ if (s.data->root_visual == visual->visual_id)
return s.data;
- XCBDEPTHIter d = XCBSCREENAllowedDepthsIter(s.data);
- for (; d.rem; XCBDEPTHNext(&d))
+ d = xcb_screen_allowed_depths_iterator(s.data);
+ for (; d.rem; xcb_depth_next(&d))
{
- XCBVISUALTYPEIter v = XCBDEPTHVisualsIter(d.data);
- for (; v.rem; XCBVISUALTYPENext(&v))
+ xcb_visualtype_iterator_t v = xcb_depth_visuals_iterator(d.data);
+ for (; v.rem; xcb_visualtype_next(&v))
{
- if (v.data->visual_id.id == visual->visual_id.id)
+ if (v.data->visual_id == visual->visual_id)
return s.data;
}
}
@@ -1235,13 +1240,13 @@ _cairo_xcb_screen_from_visual (XCBConnec
* Return value: the newly created surface
**/
cairo_surface_t *
-cairo_xcb_surface_create (XCBConnection *c,
- XCBDRAWABLE drawable,
- XCBVISUALTYPE *visual,
+cairo_xcb_surface_create (xcb_connection_t *c,
+ xcb_drawable_t drawable,
+ xcb_visualtype_t *visual,
int width,
int height)
{
- XCBSCREEN *screen = _cairo_xcb_screen_from_visual (c, visual);
+ xcb_screen_t *screen = _cairo_xcb_screen_from_visual (c, visual);
if (screen == NULL) {
_cairo_error (CAIRO_STATUS_INVALID_VISUAL);
@@ -1267,15 +1272,13 @@ cairo_xcb_surface_create (XCBConnection
* Return value: the newly created surface
**/
cairo_surface_t *
-cairo_xcb_surface_create_for_bitmap (XCBConnection *c,
- XCBPIXMAP bitmap,
- XCBSCREEN *screen,
+cairo_xcb_surface_create_for_bitmap (xcb_connection_t *c,
+ xcb_pixmap_t bitmap,
+ xcb_screen_t *screen,
int width,
int height)
{
- XCBDRAWABLE drawable;
- drawable.pixmap = bitmap;
- return _cairo_xcb_surface_create_internal (c, drawable, screen,
+ return _cairo_xcb_surface_create_internal (c, bitmap, screen,
NULL, NULL,
width, height, 1);
}
@@ -1301,10 +1304,10 @@ cairo_xcb_surface_create_for_bitmap (XCB
* Return value: the newly created surface.
**/
cairo_surface_t *
-cairo_xcb_surface_create_with_xrender_format (XCBConnection *c,
- XCBDRAWABLE drawable,
- XCBSCREEN *screen,
- XCBRenderPICTFORMINFO *format,
+cairo_xcb_surface_create_with_xrender_format (xcb_connection_t *c,
+ xcb_drawable_t drawable,
+ xcb_screen_t *screen,
+ xcb_render_pictforminfo_t *format,
int width,
int height)
{
diff --git a/src/cairo-xcb-xrender.h b/src/cairo-xcb-xrender.h
index a584953..9df6856 100644
--- a/src/cairo-xcb-xrender.h
+++ b/src/cairo-xcb-xrender.h
@@ -41,16 +41,16 @@ #include <cairo.h>
#if CAIRO_HAS_XCB_SURFACE
-#include <X11/XCB/xcb.h>
-#include <X11/XCB/render.h>
+#include <xcb/xcb.h>
+#include <xcb/render.h>
CAIRO_BEGIN_DECLS
cairo_public cairo_surface_t *
-cairo_xcb_surface_create_with_xrender_format (XCBConnection *c,
- XCBDRAWABLE drawable,
- XCBSCREEN *screen,
- XCBRenderPICTFORMINFO *format,
+cairo_xcb_surface_create_with_xrender_format (xcb_connection_t *c,
+ xcb_drawable_t drawable,
+ xcb_screen_t *screen,
+ xcb_render_pictforminfo_t *format,
int width,
int height);
diff --git a/src/cairo-xcb.h b/src/cairo-xcb.h
index 54fd325..e180bb6 100644
--- a/src/cairo-xcb.h
+++ b/src/cairo-xcb.h
@@ -41,21 +41,21 @@ #include <cairo.h>
#if CAIRO_HAS_XCB_SURFACE
-#include <X11/XCB/xcb.h>
+#include <xcb/xcb.h>
CAIRO_BEGIN_DECLS
cairo_public cairo_surface_t *
-cairo_xcb_surface_create (XCBConnection *c,
- XCBDRAWABLE drawable,
- XCBVISUALTYPE *visual,
+cairo_xcb_surface_create (xcb_connection_t *c,
+ xcb_drawable_t drawable,
+ xcb_visualtype_t *visual,
int width,
int height);
cairo_public cairo_surface_t *
-cairo_xcb_surface_create_for_bitmap (XCBConnection *c,
- XCBPIXMAP bitmap,
- XCBSCREEN *screen,
+cairo_xcb_surface_create_for_bitmap (xcb_connection_t *c,
+ xcb_pixmap_t bitmap,
+ xcb_screen_t *screen,
int width,
int height);
--
1.4.2.3
More information about the cairo
mailing list