File: sizeobject.cpp

package info (click to toggle)
gamera 1:3.4.3-1
  • links: PTS, VCS
  • area: main
  • in suites: buster, sid
  • size: 15,912 kB
  • sloc: xml: 122,324; cpp: 50,730; python: 35,044; ansic: 258; makefile: 114; sh: 101
file content (153 lines) | stat: -rw-r--r-- 5,017 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/*
 *
 * Copyright (C) 2001-2005 Ichiro Fujinaga, Michael Droettboom, and Karl MacMillan
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#define GAMERACORE_INTERNAL
#include "gameramodule.hpp"

using namespace Gamera;

extern "C" {
  static PyObject* size_new(PyTypeObject* pytype, PyObject* args,
			    PyObject* kwds);
  static void size_dealloc(PyObject* self);
  static PyObject* size_get_width(PyObject* self);
  static int size_set_width(PyObject* self, PyObject* value);
  static PyObject* size_get_height(PyObject* self);
  static int size_set_height(PyObject* self, PyObject* value);
  static PyObject* size_richcompare(PyObject* a, PyObject* b, int op);
  static PyObject* size_repr(PyObject* self);
}

static PyTypeObject SizeType = {
  PyObject_HEAD_INIT(NULL)
  0,
};

static PyGetSetDef size_getset[] = {
  { (char *)"width", (getter)size_get_width, (setter)size_set_width,
    (char *)"(int property)\n\nThe width of an object is the right boundary minus the left. This is the same as the number of columns *minus one.*", 0 },
  { (char *)"height", (getter)size_get_height, (setter)size_set_height,
    (char *)"(int property)\n\nThe height of an object is the lower boundary minus the upper boundary (remember that *y* is counted in the negative direction). This is the same as the number of rows *minus one*.", 0 },
  { NULL }
};

PyTypeObject* get_SizeType() {
  return &SizeType;
}

static PyObject* size_new(PyTypeObject* pytype, PyObject* args,
			  PyObject* kwds) {
  int width, height;
  if (PyArg_ParseTuple(args, CHAR_PTR_CAST "ii:Size.__init__", &width, &height) <= 0)
    return 0;
  SizeObject* so;
  so = (SizeObject*)pytype->tp_alloc(pytype, 0);
  so->m_x = new Size((size_t)width, (size_t)height);
  return (PyObject*)so;
}

static void size_dealloc(PyObject* self) {
  SizeObject* x = (SizeObject*)self;
  delete x->m_x;
  self->ob_type->tp_free(self);
}

#define CREATE_GET_FUNC(name) static PyObject* size_get_##name(PyObject* self) {\
  Size* x = ((SizeObject*)self)->m_x; \
  return Py_BuildValue(CHAR_PTR_CAST "i", (int)x->name()); \
}

#define CREATE_SET_FUNC(name) static int size_set_##name(PyObject* self, PyObject* value) {\
  Size* x = ((SizeObject*)self)->m_x; \
  x->name((size_t)PyInt_AS_LONG(value)); \
  return 0; \
}

CREATE_GET_FUNC(width)
CREATE_SET_FUNC(width)
CREATE_GET_FUNC(height)
CREATE_SET_FUNC(height)

static PyObject* size_richcompare(PyObject* a, PyObject* b, int op) {
  if (!is_SizeObject(a) || !is_SizeObject(b)) {
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  }

  Size& as = *((SizeObject*)a)->m_x;
  Size& bs = *((SizeObject*)b)->m_x;

  /*
    Only equality and inequality make sense.
  */
  bool cmp;
  switch (op) {
  case Py_LT:
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  case Py_LE:
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  case Py_EQ:
    cmp = as == bs;
    break;
  case Py_NE:
    cmp = as != bs;
    break;
  case Py_GT:
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  case Py_GE:
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  default:
    return 0; // cannot happen
  }
  if (cmp) {
    Py_INCREF(Py_True);
    return Py_True;
  } else {
    Py_INCREF(Py_False);
    return Py_False;
  }
}

static PyObject* size_repr(PyObject* self) {
  Size* x = ((SizeObject*)self)->m_x;
  return PyString_FromFormat("Size(%i, %i)",
			     (int)x->width(), (int)x->height());
}

void init_SizeType(PyObject* module_dict) {
  SizeType.ob_type = &PyType_Type;
  SizeType.tp_name = CHAR_PTR_CAST "gameracore.Size";
  SizeType.tp_basicsize = sizeof(SizeObject);
  SizeType.tp_dealloc = size_dealloc;
  SizeType.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
  SizeType.tp_getset = size_getset;
  SizeType.tp_new = size_new;
  SizeType.tp_getattro = PyObject_GenericGetAttr;
  SizeType.tp_alloc = NULL; // PyType_GenericAlloc;
  SizeType.tp_richcompare = size_richcompare;
  SizeType.tp_free = NULL; // _PyObject_Del;
  SizeType.tp_repr = size_repr;
  SizeType.tp_doc = CHAR_PTR_CAST "Size stores a size (*width*, *height*). This is almost the same as ``Dim``, but stores the number of columns/rows minus one:\n\n  *width* == *ncols* - 1\n\n  *height* == *nrows* - 1";
  PyType_Ready(&SizeType);
  PyDict_SetItemString(module_dict, "Size", (PyObject*)&SizeType);
}