1/* -*- Mode: C; c-basic-offset: 4 -*-
2 * pygtk- Python bindings for the GTK toolkit.
3 * Copyright (C) 1998-2003  James Henstridge
4 *
5 *   gdkrectangle.override: gtk.gdk.Rectangle overrides
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
20 * USA
21 */
22%%
23override gdk_rectangle_new kwargs
24static int
25_wrap_gdk_rectangle_new(PyGBoxed *self, PyObject *args, PyObject *kwargs)
26{
27    static char *kwlist[] = { "x", "y", "width", "height", NULL };
28    GdkRectangle rect = {0, 0, 0, 0};
29
30    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
31				     "|iiii:GdkRectangle.__init__",
32				     kwlist, &(rect.x), &(rect.y),
33				     &(rect.width), &(rect.height)))
34	return -1;
35
36    self->boxed =  g_boxed_copy(GDK_TYPE_RECTANGLE, &rect);
37    self->free_on_dealloc = TRUE;
38    self->gtype = GDK_TYPE_RECTANGLE;
39
40    return 0;
41}
42%%
43override-slot GdkRectangle.tp_as_sequence
44static Py_ssize_t
45_wrap_gdk_rectangle_length(PyGBoxed *self)
46{
47    return 4;
48}
49static PyObject *
50_wrap_gdk_rectangle_getitem(PyGBoxed *self, Py_ssize_t pos)
51{
52    GdkRectangle *rect;
53
54    if (pos < 0) pos += 4;
55    if (pos < 0 || pos >= 4) {
56        PyErr_SetString(PyExc_IndexError, "index out of range");
57        return NULL;
58    }
59    rect = pyg_boxed_get(self, GdkRectangle);
60    switch (pos) {
61    case 0: return PyInt_FromLong(rect->x);
62    case 1: return PyInt_FromLong(rect->y);
63    case 2: return PyInt_FromLong(rect->width);
64    case 3: return PyInt_FromLong(rect->height);
65    default:
66        g_assert_not_reached();
67        return NULL;
68    }
69}
70static int
71_wrap_gdk_rectangle_setitem(PyGBoxed *self, Py_ssize_t pos, PyObject *value)
72{
73    GdkRectangle *rect;
74    gint val;
75
76    if (pos < 0) pos += 4;
77    if (pos < 0 || pos >= 4) {
78        PyErr_SetString(PyExc_IndexError, "index out of range");
79        return -1;
80    }
81    rect = pyg_boxed_get(self, GdkRectangle);
82    val = PyInt_AsLong(value);
83    if (PyErr_Occurred())
84        return -1;
85    switch(pos) {
86    case 0: rect->x      = val; break;
87    case 1: rect->y      = val; break;
88    case 2: rect->width  = val; break;
89    case 3: rect->height = val; break;
90    default:
91        g_assert_not_reached();
92        return -1;
93    }
94    return 0;
95}
96static PySequenceMethods _wrap_gdk_rectangle_tp_as_sequence = {
97    (lenfunc)_wrap_gdk_rectangle_length,
98    0,
99    0,
100    (ssizeargfunc)_wrap_gdk_rectangle_getitem,
101    0,
102    (ssizeobjargproc)_wrap_gdk_rectangle_setitem,
103    0,
104};
105%%
106override-attr GdkRectangle.x
107static int
108_wrap_gdk_rectangle__set_x(PyGBoxed *self, PyObject *value, void *closure)
109{
110    gint val;
111
112    val = PyInt_AsLong(value);
113    if (PyErr_Occurred())
114        return -1;
115    pyg_boxed_get(self, GdkRectangle)->x = val;
116    return 0;
117}
118%%
119override-attr GdkRectangle.y
120static int
121_wrap_gdk_rectangle__set_y(PyGBoxed *self, PyObject *value, void *closure)
122{
123    gint val;
124
125    val = PyInt_AsLong(value);
126    if (PyErr_Occurred())
127        return -1;
128    pyg_boxed_get(self, GdkRectangle)->y = val;
129    return 0;
130}
131%%
132override-attr GdkRectangle.width
133static int
134_wrap_gdk_rectangle__set_width(PyGBoxed *self, PyObject *value, void *closure)
135{
136    gint val;
137
138    val = PyInt_AsLong(value);
139    if (PyErr_Occurred())
140        return -1;
141    pyg_boxed_get(self, GdkRectangle)->width = val;
142    return 0;
143}
144%%
145override-attr GdkRectangle.height
146static int
147_wrap_gdk_rectangle__set_height(PyGBoxed *self, PyObject *value, void *closure)
148{
149    gint val;
150
151    val = PyInt_AsLong(value);
152    if (PyErr_Occurred())
153        return -1;
154    pyg_boxed_get(self, GdkRectangle)->height = val;
155    return 0;
156}
157%%
158override gdk_rectangle_intersect kwargs
159static PyObject *
160_wrap_gdk_rectangle_intersect(PyGObject *self, PyObject *args,
161			      PyObject *kwargs)
162{
163    static char *kwlist[] = { "src", NULL };
164    PyObject *py_src;
165    GdkRectangle src, dest = {0, 0, 0, 0};
166
167    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GdkRectangle.intersect",
168				     kwlist, &py_src)) {
169        return NULL;
170    }
171
172    if (!pyg_boxed_check(py_src, GDK_TYPE_RECTANGLE)) {
173	if (!pygdk_rectangle_from_pyobject(py_src, &src)) {
174	    PyErr_Clear();
175	    PyErr_SetString(PyExc_TypeError,
176			    "src must be a GdkRectangle or 4-tuple");
177	    return NULL;
178	}
179    } else {
180	src = *pyg_boxed_get(py_src, GdkRectangle);
181    }
182
183    gdk_rectangle_intersect(pyg_boxed_get(self, GdkRectangle), &src, &dest);
184
185    return pyg_boxed_new(GDK_TYPE_RECTANGLE, &dest, TRUE, TRUE);
186}
187%%
188override gdk_rectangle_union kwargs
189static PyObject *
190_wrap_gdk_rectangle_union(PyGObject *self, PyObject *args,
191			  PyObject *kwargs)
192{
193    static char *kwlist[] = { "src", NULL };
194    PyObject *py_src;
195    GdkRectangle src, dest;
196
197    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GdkRectangle.union",
198				     kwlist, &py_src)) {
199        return NULL;
200    }
201
202    if (!pyg_boxed_check(py_src, GDK_TYPE_RECTANGLE)) {
203	if (!pygdk_rectangle_from_pyobject(py_src, &src)) {
204	    PyErr_Clear();
205	    PyErr_SetString(PyExc_TypeError,
206			    "src must be a GdkRectangle or 4-tuple");
207	    return NULL;
208	}
209    } else {
210	src = *pyg_boxed_get(py_src, GdkRectangle);
211    }
212
213    gdk_rectangle_union(pyg_boxed_get(self, GdkRectangle), &src, &dest);
214
215    return pyg_boxed_new(GDK_TYPE_RECTANGLE, &dest, TRUE, TRUE);
216}
217%%
218override-slot GdkRectangle.tp_richcompare
219static PyObject *
220_wrap_gdk_rectangle_tp_richcompare(PyObject *self, PyObject *other, int op)
221{
222    PyObject *result;
223
224    if (PyObject_TypeCheck(self, &PyGdkRectangle_Type)
225        && PyObject_TypeCheck(other, &PyGdkRectangle_Type)) {
226        GdkRectangle *rect1 = pyg_boxed_get(self, GdkRectangle);
227        GdkRectangle *rect2 = pyg_boxed_get(other, GdkRectangle);
228
229        switch (op) {
230        case Py_EQ:
231            result = (rect1->x == rect2->x && rect1->y == rect2->y
232                      && rect1->width == rect2->width && rect1->height == rect2->height
233                      ? Py_True : Py_False);
234            break;
235        case Py_NE:
236            result = (rect1->x != rect2->x || rect1->y != rect2->y
237                      || rect1->width != rect2->width || rect1->height != rect2->height
238                      ? Py_True : Py_False);
239            break;
240        default:
241            result = Py_NotImplemented;
242        }
243    }
244    else
245        result = Py_NotImplemented;
246
247    Py_INCREF(result);
248    return result;
249}
250%%
251override-slot GdkRectangle.tp_repr
252static PyObject *
253_wrap_gdk_rectangle_tp_repr(PyGBoxed *self)
254{
255    GdkRectangle *rect = pyg_boxed_get(self, GdkRectangle);
256    return PyString_FromFormat("%s(%d, %d, %d, %d)", self->ob_type->tp_name,
257                               rect->x, rect->y, rect->width, rect->height);
258}
259