commit: d239994c9ce048dc3b4c85d8a11d6549cb1556bf Author: Justin Lecher <jlec <AT> gentoo <DOT> org> AuthorDate: Mon Oct 19 13:37:56 2015 +0000 Commit: Justin Lecher <jlec <AT> gentoo <DOT> org> CommitDate: Mon Oct 19 16:29:11 2015 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=d239994c
dev-python/pycairo: Add python3.5 support and import latest debian patches Add missing die run epatch with multiple patches at once Package-Manager: portage-2.2.23 Signed-off-by: Justin Lecher <jlec <AT> gentoo.org> .../files/pycairo-1.10.0-101_pycairo-region.patch | 917 +++++++++++++++++++++ .../files/pycairo-1.10.0-10_test-target-py3.patch | 18 + ...pycairo-1.10.0-50_specify-encoding-in-waf.patch | 32 + .../pycairo-1.10.0-70_dont-link-libpython.patch | 29 + .../files/pycairo-1.10.0-80_fix-pickle.patch | 30 + .../files/pycairo-1.10.0-81_pickling-again.patch | 37 + dev-python/pycairo/pycairo-1.10.0-r5.ebuild | 147 ++++ 7 files changed, 1210 insertions(+) diff --git a/dev-python/pycairo/files/pycairo-1.10.0-101_pycairo-region.patch b/dev-python/pycairo/files/pycairo-1.10.0-101_pycairo-region.patch new file mode 100644 index 0000000..4143f33 --- /dev/null +++ b/dev-python/pycairo/files/pycairo-1.10.0-101_pycairo-region.patch @@ -0,0 +1,917 @@ +Description: Add support for cairo_region_t + This patch fix missing support for cairo_region_t. +Author: Bug Fly +Origin: https://bugs.freedesktop.org/attachment.cgi?id=61553 +Bug-Debian: http://bugs.debian.org/688079 +Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/py3cairo/+bug/1028115 +Last-Update: 2012-08-20 +Applied-Upstream: http://cgit.freedesktop.org/pycairo/commit/?id=75e82a1b3f495a3abbc78e50a5c66356d320fb15 + +--- py3cairo-1.10.0+dfsg.orig/doc/pycairo_c_api.rst ++++ py3cairo-1.10.0+dfsg/doc/pycairo_c_api.rst +@@ -51,6 +51,8 @@ Objects:: + PycairoGradient + PycairoLinearGradient + PycairoRadialGradient ++ PycairoRectangleInt ++ PycairoRegion + PycairoScaledFont + PycairoSurface + PycairoImageSurface +@@ -78,6 +80,8 @@ Types:: + PyTypeObject *Gradient_Type; + PyTypeObject *LinearGradient_Type; + PyTypeObject *RadialGradient_Type; ++ PyTypeObject *RectangleInt_Type; ++ PyTypeObject *Region_Type; + PyTypeObject *ScaledFont_Type; + PyTypeObject *Surface_Type; + PyTypeObject *ImageSurface_Type; +@@ -115,6 +119,12 @@ Functions + .. c:function:: PyObject * PycairoPattern_FromPattern(cairo_pattern_t *pattern, PyObject *base) + + ++.. c:function:: PyObject * PycairoRectangleInt_FromRectangleInt(const cairo_rectangle_int_t *rectangle_int) ++ ++ ++.. c:function:: PyObject * PycairoRegion_FromRegion(const cairo_region_t *region) ++ ++ + .. c:function:: PyObject * PycairoScaledFont_FromScaledFont(cairo_scaled_font_t *scaled_font) + + +--- py3cairo-1.10.0+dfsg.orig/doc/reference/index.rst ++++ py3cairo-1.10.0+dfsg/doc/reference/index.rst +@@ -15,5 +15,6 @@ Reference + matrix + paths + patterns ++ region + surfaces + text +--- /dev/null ++++ py3cairo-1.10.0+dfsg/doc/reference/region.rst +@@ -0,0 +1,52 @@ ++.. _region: ++ ++****** ++Region ++****** ++Region — Representing a pixel-aligned area ++ ++.. currentmodule:: cairo ++ ++ ++class Region() ++============== ++*Region* is a simple graphical data type representing an area of ++integer-aligned rectangles. They are often used on raster surfaces to track ++areas of interest, such as change or clip areas. ++ ++ ++.. class:: Region([rectangle_int|rectangle_ints]) ++ ++ :param rectangle_int: a rectangle or a list of rectangle ++ :type rectangle_int: :class:`RectangleInt` or [:class:`RectangleInt`] ++ ++ Allocates a new empty region object or a region object with the containing ++ rectangle(s). ++ ++ ++ .. method:: copy() ++ ++ :returns: A newly allocated :class:`Region`. ++ :raises: :exc:`NoMemory` if memory cannot be allocated. ++ ++ Allocates a new *Region* object copying the area from original. ++ ++ ++class RectangleInt() ++==================== ++*RectangleInt* is a data structure for holding a rectangle with integer ++coordinates. ++ ++ ++.. class:: RectangleInt(x=0, y=0, width=0, height=0) ++ ++ :param x: X coordinate of the left side of the rectangle ++ :type x: int ++ :param y: Y coordinate of the the top side of the rectangle ++ :type y: int ++ :param width: width of the rectangle ++ :type width: int ++ :param height: height of the rectangle ++ :type height: int ++ ++ Allocates a new *RectangleInt* object. +--- /dev/null ++++ py3cairo-1.10.0+dfsg/src/region.c +@@ -0,0 +1,598 @@ ++/* -*- mode: C; c-basic-offset: 2 -*- ++ * ++ * Copyright © 2005,2010 Steve Chaplin ++ * ++ * This file is part of pycairo. ++ * ++ * Pycairo is free software: you can redistribute it and/or modify it under ++ * the terms of the GNU Lesser General Public License version 3 as published ++ * by the Free Software Foundation. ++ * ++ * Pycairo is distributed in the hope that it will be useful, but WITHOUT ANY ++ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS ++ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for ++ * more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public License ++ * along with pycairo. If not, see <http://www.gnu.org/licenses/>. ++ */ ++ ++#define PY_SSIZE_T_CLEAN ++#include <Python.h> ++#include "structmember.h" ++ ++#include "config.h" ++#include "private.h" ++ ++/* PycairoRectangleInt_FromRectangleInt ++ * Create a new PycairoRectangleInt from a cairo_rectangle_int_t ++ * rectangle_int - a cairo_rectangle_int_t to 'wrap' into a Python object. ++ * rectangle_int is unreferenced if the PycairoRectangleInt creation ++ * fails. ++ * Return value: New reference or NULL on failure ++ */ ++PyObject * ++PycairoRectangleInt_FromRectangleInt (cairo_rectangle_int_t *rectangle_int) { ++ PyObject *o; ++ ++ assert (rectangle_int != NULL); ++ ++ o = PycairoRectangleInt_Type.tp_alloc (&PycairoRectangleInt_Type, 0); ++ if (o) ++ ((PycairoRectangleInt *)o)->rectangle_int = *rectangle_int; ++ return o; ++} ++ ++static void ++rectangle_int_dealloc(PycairoRectangleInt *o) { ++#ifdef DEBUG ++ printf("rectangle_int_dealloc start\n"); ++#endif ++ //o->ob_type->tp_free((PyObject *)o); ++ Py_TYPE(o)->tp_free(o); ++#ifdef DEBUG ++ printf("rectangle_int_dealloc end\n"); ++#endif ++} ++ ++static PyObject * ++rectangle_int_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { ++ static char *kwlist[] = { "x", "y", "width", "height", NULL }; ++ int x, y, w, h; ++ x = y = w = h = 0; ++ cairo_rectangle_int_t rect; ++ ++ if (!PyArg_ParseTupleAndKeywords(args, kwds, ++ "|iiii:RectangleInt.__new__", kwlist, ++ &x, &y, &w, &h)) ++ return NULL; ++ ++ rect.x = x; ++ rect.y = y; ++ rect.width = w; ++ rect.height = h; ++ ++ return PycairoRectangleInt_FromRectangleInt(&rect); ++} ++ ++static PyObject * ++rectangle_int_str(PycairoRectangleInt *rect_o) { ++ PyObject *s; ++ cairo_rectangle_int_t *rect = &(rect_o->rectangle_int); ++ char buf[80]; ++ PyOS_snprintf(buf, sizeof(buf), "cairo.RectangleInt(%d, %d, %d, %d)", ++ rect->x, rect->y, rect->width, rect->height); ++ s = PyUnicode_FromString(buf); ++ return s; ++} ++ ++static PyObject * ++rectangle_int_richcompare(PycairoRectangleInt *self, ++ PycairoRectangleInt *other, int op) { ++ int res = 0; ++ PyObject *b; ++ ++ if (op != Py_EQ && op != Py_NE) { ++ PyErr_SetString(PyExc_TypeError, "Only support testing for == or !="); ++ return NULL; ++ } ++ if (!PyObject_IsInstance((PyObject*)other, ++ (PyObject*)&PycairoRectangleInt_Type)) { ++ res = 0; ++ } ++ else if ( ++ self->rectangle_int.x == other->rectangle_int.x && ++ self->rectangle_int.y == other->rectangle_int.y && ++ self->rectangle_int.width == other->rectangle_int.width && ++ self->rectangle_int.height == other->rectangle_int.height ++ ) ++ res = 1; ++ res = op == Py_NE ? !res : res; ++ b = res ? Py_True : Py_False; ++ Py_INCREF(b); ++ ++ return b; ++} ++ ++static PyMemberDef RectangleInt_members[] = { ++ {"x", T_INT, sizeof(PyObject), 0, ++ "X coordinate of the left side of the rectangle"}, ++ {"y", T_INT, sizeof(PyObject)+sizeof(int), 0, ++ "Y coordinate of the the top side of the rectangle"}, ++ {"width", T_INT, sizeof(PyObject)+sizeof(int)*2, 0, ++ "width of the rectangle"}, ++ {"height", T_INT, sizeof(PyObject)+sizeof(int)*3, 0, ++ "height of the rectangle"}, ++ {NULL} ++}; ++ ++PyTypeObject PycairoRectangleInt_Type = { ++ PyVarObject_HEAD_INIT(&PyType_Type, 0) ++ "cairo.RectangleInt", /* tp_name */ ++ sizeof(PycairoRectangleInt), /* tp_basicsize */ ++ 0, /* tp_itemsize */ ++ (destructor)rectangle_int_dealloc, /* tp_dealloc */ ++ 0, /* tp_print */ ++ 0, /* tp_getattr */ ++ 0, /* tp_setattr */ ++ 0, /* tp_compare */ ++ 0, /* tp_repr */ ++ 0, /* tp_as_number */ ++ 0, /* tp_as_sequence */ ++ 0, /* tp_as_mapping */ ++ 0, /* tp_hash */ ++ 0, /* tp_call */ ++ (reprfunc)rectangle_int_str, /* tp_str */ ++ 0, /* tp_getattro */ ++ 0, /* tp_setattro */ ++ 0, /* tp_as_buffer */ ++ Py_TPFLAGS_DEFAULT, /* tp_flags */ ++ 0, /* tp_doc */ ++ 0, /* tp_traverse */ ++ 0, /* tp_clear */ ++ (richcmpfunc)rectangle_int_richcompare, /* tp_richcompare */ ++ 0, /* tp_weaklistoffset */ ++ 0, /* tp_iter */ ++ 0, /* tp_iternext */ ++ 0, /* tp_methods */ ++ RectangleInt_members, /* tp_members */ ++ 0, /* tp_getset */ ++ 0, /* tp_base */ ++ 0, /* tp_dict */ ++ 0, /* tp_descr_get */ ++ 0, /* tp_descr_set */ ++ 0, /* tp_dictoffset */ ++ 0, /* tp_init */ ++ 0, /* tp_alloc */ ++ (newfunc)rectangle_int_new, /* tp_new */ ++}; ++ ++/* PycairoRegion_FromRegion ++ * Create a new PycairoRegion from a cairo_region_t ++ * region - a cairo_region_t to 'wrap' into a Python object. ++ * region is unreferenced if the PycairoRegion creation fails, or if ++ * region is in an error status. ++ * Return value: New reference or NULL on failure ++ */ ++PyObject * ++PycairoRegion_FromRegion (cairo_region_t *region) { ++ PyObject *o; ++ ++ assert (region != NULL); ++ ++ if (Pycairo_Check_Status (cairo_region_status(region))) { ++ cairo_region_destroy (region); ++ return NULL; ++ } ++ ++ o = PycairoRegion_Type.tp_alloc (&PycairoRegion_Type, 0); ++ if (o) ++ ((PycairoRegion *)o)->region = region; ++ else ++ cairo_region_destroy (region); ++ return o; ++} ++ ++static void ++region_dealloc(PycairoRegion *o) { ++#ifdef DEBUG ++ printf("region_dealloc start\n"); ++#endif ++ if (o->region) { ++ cairo_region_destroy(o->region); ++ o->region = NULL; ++ } ++ //o->ob_type->tp_free((PyObject *)o); ++ Py_TYPE(o)->tp_free(o); ++#ifdef DEBUG ++ printf("region_dealloc end\n"); ++#endif ++} ++ ++static PyObject * ++region_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { ++ PyObject *s = NULL; ++ PycairoRectangleInt *rect_obj = NULL; ++ cairo_region_t *region = NULL; ++ cairo_rectangle_int_t *rect = NULL; ++ ++ if (PyArg_ParseTuple(args, "|O!:Region.__new__", ++ &PycairoRectangleInt_Type, &rect_obj)) { ++ if (rect_obj != NULL) { ++ region = cairo_region_create_rectangle(&(rect_obj->rectangle_int)); ++ } ++ } else if (!PyArg_ParseTuple(args, "|O:Region.__new__", &s)) { ++ PyErr_SetString(PyExc_TypeError, ++ "argument must be a RectangleInt or a sequence of RectangleInt."); ++ return NULL; ++ } ++ PyErr_Clear(); /* Clear possible err in the 1st arg parser. */ ++ ++ /* list of rectangle_int or no args */ ++ if (s != NULL) { ++ int i; ++ int rect_size; ++ PyObject *seq = NULL; ++ seq = PySequence_Fast (s, ++ "argument must be a RectangleInt or a sequence of RectangleInt."); ++ if (seq == NULL) { ++ return NULL; ++ } ++ rect_size = PySequence_Fast_GET_SIZE(seq); ++ rect = PyMem_Malloc (rect_size * sizeof(cairo_rectangle_int_t)); ++ if (rect == NULL) { ++ Py_DECREF(seq); ++ return PyErr_NoMemory(); ++ } ++ ++ for(i=0; i<rect_size; i++) { ++ PyObject *obj_tmp = PySequence_Fast_GET_ITEM(seq, i); ++ if (PyObject_IsInstance(obj_tmp, ++ (PyObject*)&PycairoRectangleInt_Type) != 1) { ++ Py_DECREF(seq); ++ PyMem_Free(rect); ++ return NULL; ++ } ++ rect_obj = (PycairoRectangleInt*) obj_tmp; ++ rect[i] = rect_obj->rectangle_int; ++ } ++ ++ region = cairo_region_create_rectangles(rect, rect_size); ++ ++ Py_DECREF(seq); ++ PyMem_Free(rect); ++ } ++ ++ if (region == NULL) { ++ region = cairo_region_create(); ++ } ++ ++ RETURN_NULL_IF_CAIRO_REGION_ERROR(region); ++ return PycairoRegion_FromRegion(region); ++} ++ ++PyObject * ++region_copy (PycairoRegion *o) { ++ cairo_region_t *res; ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_copy (o->region); ++ Py_END_ALLOW_THREADS; ++ RETURN_NULL_IF_CAIRO_REGION_ERROR(res); ++ return PycairoRegion_FromRegion(res); ++} ++ ++ ++PyObject * ++region_get_extents (PycairoRegion *o) { ++ cairo_rectangle_int_t rect; ++ Py_BEGIN_ALLOW_THREADS; ++ cairo_region_get_extents(o->region, &rect); ++ Py_END_ALLOW_THREADS; ++ ++ return PycairoRectangleInt_FromRectangleInt(&rect); ++} ++ ++ ++PyObject * ++region_num_rectangles (PycairoRegion *o) { ++ int res; ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_num_rectangles(o->region); ++ Py_END_ALLOW_THREADS; ++ return Py_BuildValue("i", res); ++} ++ ++ ++PyObject * ++region_get_rectangle (PycairoRegion *o, PyObject *args) { ++ cairo_rectangle_int_t rect; ++ int i; ++ int total; ++ if (!PyArg_ParseTuple (args, "i:Region.get_rectangle", &i)) ++ return NULL; ++ total = cairo_region_num_rectangles(o->region); ++ if (i >= total || i < 0) { ++ if ( i < 0) ++ PyErr_SetString(PyExc_ValueError, "index must be a positive number"); ++ else ++ PyErr_SetString(PyExc_ValueError, "index is to big for the region"); ++ return NULL; ++ } ++ Py_BEGIN_ALLOW_THREADS; ++ cairo_region_get_rectangle(o->region, i, &rect); ++ Py_END_ALLOW_THREADS; ++ return PycairoRectangleInt_FromRectangleInt(&rect); ++} ++ ++ ++PyObject * ++region_is_empty (PycairoRegion *o) { ++ cairo_bool_t res; ++ PyObject *b; ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_is_empty(o->region); ++ Py_END_ALLOW_THREADS; ++ b = res ? Py_True : Py_False; ++ Py_INCREF(b); ++ return b; ++} ++ ++ ++PyObject * ++region_contains_point (PycairoRegion *o, PyObject *args) { ++ int x, y; ++ cairo_bool_t res; ++ PyObject *b; ++ if (!PyArg_ParseTuple (args, "ii:Region.contains_point", &x, &y)) ++ return NULL; ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_contains_point(o->region, x, y); ++ Py_END_ALLOW_THREADS; ++ b = res ? Py_True : Py_False; ++ Py_INCREF(b); ++ return b; ++} ++ ++ ++PyObject * ++region_contains_rectangle (PycairoRegion *o, PyObject *args) { ++ cairo_region_overlap_t res; ++ PycairoRectangleInt *rect_int; ++ if (!PyArg_ParseTuple (args, "O!:Region.contains_rectangle", ++ &PycairoRectangleInt_Type, &rect_int)) ++ return NULL; ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_contains_rectangle(o->region, &(rect_int->rectangle_int)); ++ Py_END_ALLOW_THREADS; ++ return Py_BuildValue("i", res); ++} ++ ++ ++PyObject * ++region_equal (PycairoRegion *o, PyObject *args) { ++ cairo_bool_t res; ++ PyObject *b; ++ PycairoRegion *region_obj; ++ if (!PyArg_ParseTuple (args, "O!:Region.equal", ++ &PycairoRegion_Type, ®ion_obj)) ++ return NULL; ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_equal (o->region, region_obj->region); ++ Py_END_ALLOW_THREADS; ++ b = res ? Py_True : Py_False; ++ Py_INCREF(b); ++ return b; ++} ++ ++static PyObject * ++region_richcompare(PycairoRegion *self, PycairoRegion *other, int op) { ++ int res = 0; ++ PyObject *b; ++ ++ if (op != Py_EQ && op != Py_NE) { ++ PyErr_SetString(PyExc_TypeError, "Only support testing for == or !="); ++ return NULL; ++ } ++ if (!PyObject_IsInstance((PyObject*)other, (PyObject*)&PycairoRegion_Type)) { ++ res = 0; ++ } else { ++ res = cairo_region_equal (self->region, other->region); ++ } ++ ++ res = op == Py_NE ? !res : res; ++ b = res ? Py_True : Py_False; ++ Py_INCREF(b); ++ ++ return b; ++} ++ ++PyObject * ++region_translate (PycairoRegion *o, PyObject *args) { ++ int x, y; ++ if (!PyArg_ParseTuple (args, "ii:Region.translate", &x, &y)) ++ return NULL; ++ Py_BEGIN_ALLOW_THREADS; ++ cairo_region_translate (o->region, x, y); ++ Py_END_ALLOW_THREADS; ++ Py_RETURN_NONE; ++} ++ ++ ++PyObject * ++region_intersect (PycairoRegion *o, PyObject *args) { ++ cairo_status_t res; ++ PyObject *other; ++ if (!PyArg_ParseTuple (args, "O:Region.intersect", &other)) ++ return NULL; ++ ++ if (PyObject_IsInstance(other, (PyObject*)&PycairoRegion_Type) == 1) { ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_intersect(o->region, ++ ((PycairoRegion *)other)->region); ++ Py_END_ALLOW_THREADS; ++ } else if (PyObject_IsInstance(other, ++ (PyObject*)&PycairoRectangleInt_Type) == 1) { ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_intersect_rectangle(o->region, ++ &(((PycairoRectangleInt *)other)->rectangle_int)); ++ Py_END_ALLOW_THREADS; ++ } else { ++ PyErr_SetString(PyExc_TypeError, ++ "argument must be a Region or a RectangleInt."); ++ return NULL; ++ } ++ ++ RETURN_NULL_IF_CAIRO_ERROR(res); ++ Py_RETURN_NONE; ++} ++ ++PyObject * ++region_subtract (PycairoRegion *o, PyObject *args) { ++ cairo_status_t res; ++ PyObject *other; ++ if (!PyArg_ParseTuple (args, "O:Region.subtract", &other)) ++ return NULL; ++ ++ if (PyObject_IsInstance(other, (PyObject*)&PycairoRegion_Type) == 1) { ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_subtract(o->region, ++ ((PycairoRegion *)other)->region); ++ Py_END_ALLOW_THREADS; ++ } else if (PyObject_IsInstance(other, ++ (PyObject*)&PycairoRectangleInt_Type) == 1) { ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_subtract_rectangle(o->region, ++ &(((PycairoRectangleInt *)other)->rectangle_int)); ++ Py_END_ALLOW_THREADS; ++ } else { ++ PyErr_SetString(PyExc_TypeError, ++ "argument must be a Region or a RectangleInt."); ++ return NULL; ++ } ++ RETURN_NULL_IF_CAIRO_ERROR(res); ++ Py_RETURN_NONE; ++} ++ ++PyObject * ++region_union (PycairoRegion *o, PyObject *args) { ++ cairo_status_t res; ++ PyObject *other; ++ if (!PyArg_ParseTuple (args, "O:Region.union", &other)) ++ return NULL; ++ ++ if (PyObject_IsInstance(other, (PyObject*)&PycairoRegion_Type) == 1) { ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_union(o->region, ++ ((PycairoRegion *)other)->region); ++ Py_END_ALLOW_THREADS; ++ } else if (PyObject_IsInstance(other, ++ (PyObject*)&PycairoRectangleInt_Type) == 1) { ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_union_rectangle(o->region, ++ &(((PycairoRectangleInt *)other)->rectangle_int)); ++ Py_END_ALLOW_THREADS; ++ } else { ++ PyErr_SetString(PyExc_TypeError, ++ "argument must be a Region or a RectangleInt."); ++ return NULL; ++ } ++ RETURN_NULL_IF_CAIRO_ERROR(res); ++ Py_RETURN_NONE; ++} ++ ++PyObject * ++region_xor (PycairoRegion *o, PyObject *args) { ++ cairo_status_t res; ++ PyObject *other; ++ if (!PyArg_ParseTuple (args, "O:Region.xorg", &other)) ++ return NULL; ++ ++ if (PyObject_IsInstance(other, (PyObject*)&PycairoRegion_Type) == 1) { ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_xor(o->region, ++ ((PycairoRegion *)other)->region); ++ Py_END_ALLOW_THREADS; ++ } else if (PyObject_IsInstance(other, ++ (PyObject*)&PycairoRectangleInt_Type) == 1) { ++ Py_BEGIN_ALLOW_THREADS; ++ res = cairo_region_xor_rectangle(o->region, ++ &(((PycairoRectangleInt *)other)->rectangle_int)); ++ Py_END_ALLOW_THREADS; ++ } else { ++ PyErr_SetString(PyExc_TypeError, ++ "argument must be a Region or a RectangleInt."); ++ return NULL; ++ } ++ RETURN_NULL_IF_CAIRO_ERROR(res); ++ Py_RETURN_NONE; ++} ++ ++static PyMethodDef region_methods[] = { ++ /* methods never exposed in a language binding: ++ * cairo_region_destroy() ++ * cairo_region_get_type() ++ * cairo_region_reference() ++ * ++ * cairo_region_status() ++ * - not needed since Pycairo handles status checking ++ * ++ * _(intersect/subtract/union/xor)_rectangle are merged with the region ++ * ones. ++ */ ++ {"copy", (PyCFunction)region_copy, METH_NOARGS }, ++ {"get_extents", (PyCFunction)region_get_extents, METH_NOARGS }, ++ {"num_rectangles", (PyCFunction)region_num_rectangles, METH_NOARGS }, ++ {"get_rectangle", (PyCFunction)region_get_rectangle, METH_VARARGS }, ++ {"is_empty", (PyCFunction)region_is_empty, METH_NOARGS }, ++ {"contains_point", (PyCFunction)region_contains_point, METH_VARARGS }, ++ {"contains_rectangle", (PyCFunction)region_contains_rectangle, ++ METH_VARARGS }, ++ {"equal", (PyCFunction)region_equal, METH_VARARGS }, ++ {"translate", (PyCFunction)region_translate, METH_VARARGS }, ++ {"intersect", (PyCFunction)region_intersect, METH_VARARGS }, ++ {"subtract", (PyCFunction)region_subtract, METH_VARARGS }, ++ {"union", (PyCFunction)region_union, METH_VARARGS }, ++ {"xor", (PyCFunction)region_xor, METH_VARARGS }, ++ {NULL, NULL, 0, NULL}, ++}; ++ ++PyTypeObject PycairoRegion_Type = { ++ PyVarObject_HEAD_INIT(&PyType_Type, 0) ++ "cairo.Region", /* tp_name */ ++ sizeof(PycairoRegion), /* tp_basicsize */ ++ 0, /* tp_itemsize */ ++ (destructor)region_dealloc, /* tp_dealloc */ ++ 0, /* tp_print */ ++ 0, /* tp_getattr */ ++ 0, /* tp_setattr */ ++ 0, /* tp_compare */ ++ 0, /* tp_repr */ ++ 0, /* tp_as_number */ ++ 0, /* tp_as_sequence */ ++ 0, /* tp_as_mapping */ ++ 0, /* tp_hash */ ++ 0, /* tp_call */ ++ 0, /* tp_str */ ++ 0, /* tp_getattro */ ++ 0, /* tp_setattro */ ++ 0, /* tp_as_buffer */ ++ Py_TPFLAGS_DEFAULT, /* tp_flags */ ++ 0, /* tp_doc */ ++ 0, /* tp_traverse */ ++ 0, /* tp_clear */ ++ (richcmpfunc)region_richcompare, /* tp_richcompare */ ++ 0, /* tp_weaklistoffset */ ++ 0, /* tp_iter */ ++ 0, /* tp_iternext */ ++ region_methods, /* tp_methods */ ++ 0, /* tp_members */ ++ 0, /* tp_getset */ ++ 0, /* tp_base */ ++ 0, /* tp_dict */ ++ 0, /* tp_descr_get */ ++ 0, /* tp_descr_set */ ++ 0, /* tp_dictoffset */ ++ 0, /* tp_init */ ++ 0, /* tp_alloc */ ++ (newfunc)region_new, /* tp_new */ ++}; +--- py3cairo-1.10.0+dfsg.orig/src/py3cairo.h ++++ py3cairo-1.10.0+dfsg/src/py3cairo.h +@@ -67,6 +67,16 @@ typedef struct { + + typedef struct { + PyObject_HEAD ++ cairo_rectangle_int_t rectangle_int; ++} PycairoRectangleInt; ++ ++typedef struct { ++ PyObject_HEAD ++ cairo_region_t *region; ++} PycairoRegion; ++ ++typedef struct { ++ PyObject_HEAD + cairo_scaled_font_t *scaled_font; + } PycairoScaledFont; + +@@ -129,6 +139,14 @@ typedef struct { + + /* misc functions */ + int (*Check_Status)(cairo_status_t status); ++ ++ PyTypeObject *RectangleInt_Type; ++ PyObject *(*RectangleInt_FromRectangleInt)( ++ const cairo_rectangle_int_t *rectangle_int); ++ ++ PyTypeObject *Region_Type; ++ PyObject *(*Region_FromRegion)(const cairo_region_t *region); ++ + } Pycairo_CAPI_t; + + +@@ -156,6 +174,13 @@ typedef struct { + #define PycairoRadialGradient_Type *(Pycairo_CAPI->RadialGradient_Type) + #define PycairoPattern_FromPattern (Pycairo_CAPI->Pattern_FromPattern) + ++#define PycairoRectangleInt_Type *(Pycairo_CAPI->RectangleInt_Type) ++#define PycairoRectangleInt_FromRectangleInt \ ++ (Pycairo_CAPI->RectangleInt_FromRectangleInt) ++ ++#define PycairoRegion_Type *(Pycairo_CAPI->Region_Type) ++#define PycairoRegion_FromRegion (Pycairo_CAPI->Region_FromRegion) ++ + #define PycairoScaledFont_Type *(Pycairo_CAPI->ScaledFont_Type) + #define PycairoScaledFont_FromScaledFont \ + (Pycairo_CAPI->ScaledFont_FromScaledFont) +--- py3cairo-1.10.0+dfsg.orig/src/cairomodule.c ++++ py3cairo-1.10.0+dfsg/src/cairomodule.c +@@ -141,6 +141,12 @@ static Pycairo_CAPI_t CAPI = { + PycairoSurface_FromSurface, + + Pycairo_Check_Status, ++ ++ &PycairoRectangleInt_Type, ++ PycairoRectangleInt_FromRectangleInt, ++ ++ &PycairoRegion_Type, ++ PycairoRegion_FromRegion, + }; + + static PyObject * +@@ -230,6 +236,12 @@ PyInit__cairo(void) + if (PyType_Ready(&PycairoRadialGradient_Type) < 0) + return NULL; + ++ if (PyType_Ready(&PycairoRectangleInt_Type) < 0) ++ return NULL; ++ ++ if (PyType_Ready(&PycairoRegion_Type) < 0) ++ return NULL; ++ + if (PyType_Ready(&PycairoScaledFont_Type) < 0) + return NULL; + +@@ -315,6 +327,12 @@ PyInit__cairo(void) + PyModule_AddObject(m, "RadialGradient", + (PyObject *)&PycairoRadialGradient_Type); + ++ Py_INCREF(&PycairoRectangleInt_Type); ++ PyModule_AddObject(m, "RectangleInt", (PyObject *)&PycairoRectangleInt_Type); ++ ++ Py_INCREF(&PycairoRegion_Type); ++ PyModule_AddObject(m, "Region", (PyObject *)&PycairoRegion_Type); ++ + Py_INCREF(&PycairoScaledFont_Type); + PyModule_AddObject(m, "ScaledFont", (PyObject *)&PycairoScaledFont_Type); + +@@ -519,6 +537,10 @@ PyInit__cairo(void) + CONSTANT(PS_LEVEL_3); + #endif + ++ CONSTANT(REGION_OVERLAP_IN); ++ CONSTANT(REGION_OVERLAP_OUT); ++ CONSTANT(REGION_OVERLAP_PART); ++ + CONSTANT(SUBPIXEL_ORDER_DEFAULT); + CONSTANT(SUBPIXEL_ORDER_RGB); + CONSTANT(SUBPIXEL_ORDER_BGR); +--- py3cairo-1.10.0+dfsg.orig/src/wscript ++++ py3cairo-1.10.0+dfsg/src/wscript +@@ -25,6 +25,7 @@ def build(ctx): + 'font.c', + 'path.c', + 'pattern.c', ++ 'region.c', + 'matrix.c', + 'surface.c', + ], +--- py3cairo-1.10.0+dfsg.orig/src/private.h ++++ py3cairo-1.10.0+dfsg/src/private.h +@@ -60,6 +60,13 @@ extern PyTypeObject PycairoLinearGradien + extern PyTypeObject PycairoRadialGradient_Type; + PyObject *PycairoPattern_FromPattern (cairo_pattern_t *pattern, + PyObject *base); ++ ++extern PyTypeObject PycairoRectangleInt_Type; ++PyObject *PycairoRectangleInt_FromRectangleInt ( ++ cairo_rectangle_int_t *rectangle_int); ++ ++extern PyTypeObject PycairoRegion_Type; ++PyObject *PycairoRegion_FromRegion (cairo_region_t *region); + + extern PyTypeObject PycairoScaledFont_Type; + PyObject *PycairoScaledFont_FromScaledFont (cairo_scaled_font_t *scaled_font); +@@ -153,6 +160,15 @@ int Pycairo_Check_Status (cairo_status_t + if (status != CAIRO_STATUS_SUCCESS) { \ + Pycairo_Check_Status (status); \ + return NULL; \ ++ } \ ++ } while (0) ++ ++#define RETURN_NULL_IF_CAIRO_REGION_ERROR(region) \ ++ do { \ ++ cairo_status_t status = cairo_region_status (region); \ ++ if (status != CAIRO_STATUS_SUCCESS) { \ ++ Pycairo_Check_Status (status); \ ++ return NULL; \ + } \ + } while (0) + +--- py3cairo-1.10.0+dfsg.orig/test/api_test.py ++++ py3cairo-1.10.0+dfsg/test/api_test.py +@@ -84,3 +84,65 @@ def test_surface(): + + def test_text(): + pass ++ ++ ++def test_region(): ++ a = cairo.Region() ++ assert a.is_empty() == True ++ assert a.num_rectangles() == 0 ++ ++ b = cairo.RectangleInt(1, 2, 10, 12) ++ d = cairo.RectangleInt(1, 1, 10, 12) ++ e = cairo.RectangleInt(1, 3, 8, 12) ++ assert (b.x, b.y, b.width, b.height) == (1, 2, 10, 12) ++ c = cairo.Region((b, e)) ++ assert not c.is_empty() ++ assert c.num_rectangles() == 2 ++ assert c.get_rectangle(1).y == 14 ++ ++ ex = c.get_extents() ++ assert ex == cairo.RectangleInt(1, 2, 10, 13) ++ assert c.contains_rectangle(d) == cairo.REGION_OVERLAP_PART ++ ++ c.translate(10, 20) ++ assert c.contains_rectangle(d) == cairo.REGION_OVERLAP_OUT ++ assert c.get_rectangle(1) == cairo.RectangleInt(11, 34, 8, 1) ++ ++ cp = c.copy() ++ assert c.num_rectangles() == cp.num_rectangles() ++ assert c.get_rectangle(0) == cp.get_rectangle(0) ++ assert c == cp ++ assert 3 != c ++ assert c != "test" ++ ++ c = cairo.Region((b, e)) ++ c.intersect(d) ++ assert c.num_rectangles() == 1 ++ assert c.get_rectangle(0) == cairo.RectangleInt(1, 2, 10, 11) ++ ++ c = cairo.Region((b, e)) ++ c.subtract(d) ++ assert c.num_rectangles() == 2 ++ assert c == cairo.Region([ ++ cairo.RectangleInt(1, 13, 10, 1), cairo.RectangleInt(1, 14, 8, 1) ]) ++ ++ d = cairo.Region(d) ++ c = cairo.Region((b, e)) ++ c.subtract(d) ++ assert c.num_rectangles() == 2 ++ assert c.get_rectangle(0) == cairo.RectangleInt(1, 13, 10, 1) ++ ++ c = cairo.Region((b, e)) ++ c.union(d) ++ assert c.num_rectangles() == 2 ++ assert c == cairo.Region([ ++ cairo.RectangleInt(1, 1, 10, 13), cairo.RectangleInt(1, 14, 8, 1) ]) ++ ++ c = cairo.Region((b, e)) ++ c.xor(d) ++ assert c.num_rectangles() == 3 ++ assert c == cairo.Region([ ++ cairo.RectangleInt(1, 1, 10, 1), ++ cairo.RectangleInt(1, 14, 8, 1), ++ cairo.RectangleInt(1, 13, 10, 1), ++ ]) diff --git a/dev-python/pycairo/files/pycairo-1.10.0-10_test-target-py3.patch b/dev-python/pycairo/files/pycairo-1.10.0-10_test-target-py3.patch new file mode 100644 index 0000000..85d27db --- /dev/null +++ b/dev-python/pycairo/files/pycairo-1.10.0-10_test-target-py3.patch @@ -0,0 +1,18 @@ +Description: Use all versions for py.test + This patch changes py.test script to use all versions of Python 3 command + instead of python. +Author: Koichi Akabe <[email protected]> +Last-Update: <2012-04-12> + +--- py3cairo-1.10.0+dfsg.orig/test/examples_test.py ++++ py3cairo-1.10.0+dfsg/test/examples_test.py +@@ -14,7 +14,8 @@ def test_snippets(): + examples/cairo_snippets/snippets/ + ''' + def doSnippets(name): +- retcode = subprocess.call('python %s -s' % name, shell=True) ++ import sys ++ retcode = subprocess.call('PYTHONPATH=../../test python%d.%d %s -s' % (sys.version_info[0], sys.version_info[1], name), shell=True) + assert retcode == 0, 'Error: retcode == {0}'.format(retcode) + + os.chdir(os.path.join(os.path.dirname(__file__), '..', 'examples', diff --git a/dev-python/pycairo/files/pycairo-1.10.0-50_specify-encoding-in-waf.patch b/dev-python/pycairo/files/pycairo-1.10.0-50_specify-encoding-in-waf.patch new file mode 100644 index 0000000..5356554 --- /dev/null +++ b/dev-python/pycairo/files/pycairo-1.10.0-50_specify-encoding-in-waf.patch @@ -0,0 +1,32 @@ +Description: specify encoding in waf + This patch specifies utf-8 as the encoding in waf library, because python 3.3 + doesn't fallback to utf-8 on default. +Author: Matthias Klose <[email protected]> +Origin: http://launchpadlibrarian.net/120606963/py3cairo_1.10.0%2Bdfsg-3~exp2_1.10.0%2Bdfsg-3~exp2ubuntu1.diff.gz +Bug-Debian: http://bugs.debian.org/691241 +Last-Update: 2012-10-28 + +--- py3cairo-1.10.0+dfsg.orig/waflib/Utils.py ++++ py3cairo-1.10.0+dfsg/waflib/Utils.py +@@ -77,8 +77,8 @@ except ImportError: + return value + is_win32=sys.platform=='win32' + indicator=is_win32 and'\x1b[A\x1b[K%s%s%s\r'or'\x1b[K%s%s%s\r' +-def readf(fname,m='r'): +- f=open(fname,m) ++def readf(fname,m='r',enc=None): ++ f=open(fname,m,encoding=enc) + try: + txt=f.read() + finally: +--- py3cairo-1.10.0+dfsg.orig/waflib/Tools/c_preproc.py ++++ py3cairo-1.10.0+dfsg/waflib/Tools/c_preproc.py +@@ -44,7 +44,7 @@ def repl(m): + return' ' + return m.group(3)or'' + def filter_comments(filename): +- code=Utils.readf(filename) ++ code=Utils.readf(filename, enc='utf-8') + if use_trigraphs: + for(a,b)in trig_def:code=code.split(a).join(b) + code=re_nl.sub('',code) diff --git a/dev-python/pycairo/files/pycairo-1.10.0-70_dont-link-libpython.patch b/dev-python/pycairo/files/pycairo-1.10.0-70_dont-link-libpython.patch new file mode 100644 index 0000000..7ea2efd --- /dev/null +++ b/dev-python/pycairo/files/pycairo-1.10.0-70_dont-link-libpython.patch @@ -0,0 +1,29 @@ +Description: don't link libpython + This patch removes dependency to libpython +Author: Matthias Klose <[email protected]> +Origin: http://launchpadlibrarian.net/166876566/py3cairo_1.10.0%2Bdfsg-3build2_1.10.0%2Bdfsg-3ubuntu1.diff.gz +Bug-Debian: http://bugs.debian.org/739607 +Last-Update: 2014-02-20 + +--- py3cairo-1.10.0+dfsg.orig/waflib/Tools/python.py ++++ py3cairo-1.10.0+dfsg/waflib/Tools/python.py +@@ -155,8 +155,10 @@ def check_python_headers(conf): + if result: + break + if result: +- env['LIBPATH_PYEMBED']=path +- env.append_value('LIB_PYEMBED',[name]) ++ # don't link libpython explicitly ++ #env['LIBPATH_PYEMBED']=path ++ #env.append_value('LIB_PYEMBED',[name]) ++ pass + else: + conf.to_log("\n\n### LIB NOT FOUND\n") + if(sys.platform=='win32'or sys.platform.startswith('os2')or sys.platform=='darwin'or dct['Py_ENABLE_SHARED']): +@@ -278,4 +280,4 @@ feature('pyembed')(init_pyembed) + conf(get_python_variables) + conf(check_python_headers) + conf(check_python_version) +-conf(check_python_module) +\ No newline at end of file ++conf(check_python_module) diff --git a/dev-python/pycairo/files/pycairo-1.10.0-80_fix-pickle.patch b/dev-python/pycairo/files/pycairo-1.10.0-80_fix-pickle.patch new file mode 100644 index 0000000..3e0cdc3 --- /dev/null +++ b/dev-python/pycairo/files/pycairo-1.10.0-80_fix-pickle.patch @@ -0,0 +1,30 @@ +Description: During the build process, a Context instance is pickled, or at + least attempted to be. This fails because self.node_class is assigned to a + class which is nested inside the __init__() method. Because Python cannot + find this class at unpickling time (i.e. it cannot be imported), Python + refuses to pickle the Context instance, leading to a FTBFS. Since there's no + obvious reason why the class has to be so nested, moving it to a module + global solves the build failure. +Author: Barry Warsaw <[email protected]> +Bug: https://bugs.freedesktop.org/show_bug.cgi?id=91561 + +--- a/waflib/Context.py ++++ b/waflib/Context.py +@@ -51,6 +51,8 @@ + global classes + classes.insert(0,cls) + ctx=store_context('ctx',(object,),{}) ++class node_class(waflib.Node.Node): ++ pass + class Context(ctx): + errors=Errors + tools={} +@@ -60,8 +62,6 @@ + except KeyError: + global run_dir + rd=run_dir +- class node_class(waflib.Node.Node): +- pass + self.node_class=node_class + self.node_class.__module__="waflib.Node" + self.node_class.__name__="Nod3" diff --git a/dev-python/pycairo/files/pycairo-1.10.0-81_pickling-again.patch b/dev-python/pycairo/files/pycairo-1.10.0-81_pickling-again.patch new file mode 100644 index 0000000..3aad325 --- /dev/null +++ b/dev-python/pycairo/files/pycairo-1.10.0-81_pickling-again.patch @@ -0,0 +1,37 @@ +Description: Follow up to 80_fix-pickle.patch. Just disable pickling + altogether since the previous patch doesn't really fix the problem, and not + storing the pickle seems to have no adverse effects on the build, while + avoiding the observed traceback. +Author: Barry Warsaw <[email protected]> +Forwarded: no + +--- a/waflib/Build.py ++++ b/waflib/Build.py +@@ -151,6 +151,7 @@ + f.close() + self.init_dirs() + def store(self): ++ return + data={} + for x in SAVED_ATTRS: + data[x]=getattr(self,x) +--- a/waflib/Context.py ++++ b/waflib/Context.py +@@ -51,8 +51,6 @@ + global classes + classes.insert(0,cls) + ctx=store_context('ctx',(object,),{}) +-class node_class(waflib.Node.Node): +- pass + class Context(ctx): + errors=Errors + tools={} +@@ -62,6 +60,8 @@ + except KeyError: + global run_dir + rd=run_dir ++ class node_class(waflib.Node.Node): ++ pass + self.node_class=node_class + self.node_class.__module__="waflib.Node" + self.node_class.__name__="Nod3" diff --git a/dev-python/pycairo/pycairo-1.10.0-r5.ebuild b/dev-python/pycairo/pycairo-1.10.0-r5.ebuild new file mode 100644 index 0000000..fb86310 --- /dev/null +++ b/dev-python/pycairo/pycairo-1.10.0-r5.ebuild @@ -0,0 +1,147 @@ +# Copyright 1999-2015 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Id$ + +EAPI="5" + +PYTHON_COMPAT=( python2_7 python3_{3,4,5} ) +PYTHON_REQ_USE='threads(+)' + +inherit eutils python-r1 waf-utils toolchain-funcs + +PYCAIRO_PYTHON2_VERSION="${PV}" +PYCAIRO_PYTHON3_VERSION="${PV}" + +DESCRIPTION="Python bindings for the cairo library" +HOMEPAGE="http://cairographics.org/pycairo/ https://pypi.python.org/pypi/pycairo"; +SRC_URI=" + http://cairographics.org/releases/py2cairo-${PYCAIRO_PYTHON2_VERSION}.tar.bz2 + http://cairographics.org/releases/pycairo-${PYCAIRO_PYTHON3_VERSION}.tar.bz2"; + +# LGPL-3 for pycairo 1.10.0. +# || ( LGPL-2.1 MPL-1.1 ) for pycairo 1.8.10. +LICENSE="LGPL-3 || ( LGPL-2.1 MPL-1.1 )" +SLOT="0" +KEYWORDS="~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos" +IUSE="doc examples +svg test xcb" + +REQUIRED_USE="${PYTHON_REQUIRED_USE}" + +# Note: xpyb is used as the C header, not Python modules +RDEPEND="${PYTHON_DEPS} + >=x11-libs/cairo-1.10.0[svg?,xcb?] + xcb? ( x11-libs/xpyb )" +DEPEND="${RDEPEND} + virtual/pkgconfig + test? ( dev-python/pytest[${PYTHON_USEDEP}] ) +" + +src_prepare() { + pushd "${WORKDIR}/pycairo-${PYCAIRO_PYTHON3_VERSION}" > /dev/null || die + rm -f src/config.h || die + epatch \ + "${FILESDIR}/${PN}-1.10.0-svg_check.patch" \ + "${FILESDIR}/${PN}-1.10.0-xpyb.patch" \ + "${FILESDIR}/${PN}-1.10.0-waf-unpack.patch" \ + "${FILESDIR}"/py2cairo-1.10.0-ppc-darwin.patch \ + "${FILESDIR}"/pycairo-1.10.0-101_pycairo-region.patch + popd > /dev/null + + pushd "${WORKDIR}/py2cairo-${PYCAIRO_PYTHON2_VERSION}" > /dev/null || die + rm -f src/config.h || die + epatch \ + "${FILESDIR}/py2cairo-1.10.0-svg_check.patch" \ + "${FILESDIR}/py2cairo-1.10.0-xpyb.patch" \ + "${FILESDIR}"/py2cairo-1.10.0-ppc-darwin.patch + popd > /dev/null + + preparation() { + if python_is_python3; then + cp -r -l "${WORKDIR}/pycairo-${PYCAIRO_PYTHON3_VERSION}" "${BUILD_DIR}" || die + pushd "${BUILD_DIR}" > /dev/null || die + wafdir="$(./waf unpack)" + pushd "${wafdir}" > /dev/null || die + epatch \ + "${FILESDIR}/${PN}-1.10.0-waf-py3_4.patch" \ + "${FILESDIR}"/pycairo-1.10.0-50_specify-encoding-in-waf.patch \ + "${FILESDIR}"/pycairo-1.10.0-80_fix-pickle.patch \ + "${FILESDIR}"/pycairo-1.10.0-81_pickling-again.patch + + popd > /dev/null + popd > /dev/null + else + cp -r -l "${WORKDIR}/py2cairo-${PYCAIRO_PYTHON2_VERSION}" "${BUILD_DIR}" || die + fi + } + python_foreach_impl preparation +} + +src_configure() { + if ! use svg; then + export PYCAIRO_DISABLE_SVG=1 + fi + + if ! use xcb; then + export PYCAIRO_DISABLE_XPYB=1 + fi + + tc-export PKG_CONFIG + # Also export the var with the slightly diff name that waf uses for no good reason. + export PKGCONFIG=${PKG_CONFIG} + + # Added by grobian: + # If WAF_BINARY is an absolute path, the configure is different and fails to + # find Python.h due to a compiler misconfiguration. If WAF_BINARY is just + # ./waf or python waf, it works fine. Hooray for reinvented buildsystems + + # floppym: + # pycairo and py2cairo bundle different versions of waf (bug 447856) + WAF_BINARY="./waf" + python_foreach_impl run_in_build_dir waf-utils_src_configure --nopyc --nopyo +} + +src_compile() { + python_foreach_impl run_in_build_dir waf-utils_src_compile +} + +src_test() { + test_installation() { + ./waf install --destdir="${T}/tests/${BUILD_DIR}" + PYTHONPATH="${T}/tests/${BUILD_DIR}$(python_get_sitedir)" py.test -v + } + python_foreach_impl run_in_build_dir test_installation +} + +src_install() { + python_foreach_impl run_in_build_dir waf-utils_src_install + + dodoc AUTHORS NEWS README + + if use doc; then + pushd doc/_build/html > /dev/null || die + dohtml -r [a-z]* _static + popd > /dev/null || die + fi + + if use examples; then + insinto /usr/share/doc/${PF}/examples + doins -r examples/* + fi + + if [[ ${CHOST} == *-darwin* ]] ; then + # fix install_names; next to waf producing dylibs (not bundles) and + # calling them .bundle, it also has no idea what it should do to create + # proper ones (dylibs) + fix_darwin_install_names() { + local x="$(python_get_sitedir)/cairo/_cairo.bundle" + install_name_tool -id "${x}" "${ED}${x}" + } + python_foreach_impl fix_darwin_install_names + fi +} + +run_in_build_dir() { + pushd "${BUILD_DIR}" > /dev/null || die + "$@" + popd > /dev/null || die +}
