← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gdesklets/jaunty-updates

« back to all changes in this revision

Viewing changes to utils/tiling.c

  • Committer: Bazaar Package Importer
  • Author(s): Deng Xiyue
  • Date: 2008-09-02 22:00:17 UTC
  • mfrom: (2.1.18 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080902220017-m66bj19l0ll8x7yh
Tags: 0.36-5
* Redo 40_dont_update_mime.diff to use a more compact syntax by 
  Loïc Minier's suggestion.  Thanks lool.
* Regenerate 70_relibtoolize.diff accordingly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
utils/tiling.c
11
11
                       PyObject *weakreflist; \
12
12
                       GSList *closures;
13
13
 
14
 
 
15
14
/* type of base class */
16
 
static PyTypeObject *_PyGtkImage_Type;
17
 
#define PyGtkImage_Type (*_PyGtkImage_Type)
 
15
static PyTypeObject *PyGtkImage_Type;
18
16
 
19
17
/* type of TImage */
20
18
typedef struct {
22
20
  guint width;
23
21
  guint height;
24
22
  gboolean invalidated;
25
 
 
26
23
  GdkPixbuf *pbuf;
27
24
} TImage;
28
25
#define TIMAGE(object) ((TImage *) object)
29
26
 
30
27
/* Declare entry point for python */
31
 
PyMODINIT_FUNC inittiling(void);
 
28
PyMODINIT_FUNC inittiling (void);
 
29
 
32
30
 
33
31
static int
34
 
tiling_new (PyObject *self, PyObject *args, PyObject *kwargs)
 
32
tiling_init (PyObject *self, PyObject *args, PyObject *kwargs)
35
33
{
36
 
  if (!PyArg_ParseTuple(args, ""))
 
34
  if (!PyArg_ParseTuple (args, ""))
37
35
    return -1;
38
36
 
39
 
  TIMAGE (self)->obj = (GObject *) gtk_image_new ();
 
37
  TIMAGE (self)->obj = g_object_new (GTK_TYPE_IMAGE, NULL);
40
38
 
41
39
  if (!G_UNLIKELY (TIMAGE (self)->obj)) {
42
40
    PyErr_SetString (PyExc_RuntimeError, "Couldn't create TImage object");
54
52
}
55
53
 
56
54
 
 
55
static void
 
56
tiling_dealloc (TImage *self)
 
57
{
 
58
  GdkPixbuf *pbuf;
 
59
  GObject *obj;
 
60
 
 
61
  obj = TIMAGE (self)->obj;
 
62
  pbuf = TIMAGE (self)->pbuf;
 
63
 
 
64
  if (G_UNLIKELY (obj != NULL)) {
 
65
    g_object_unref (obj);
 
66
    obj = NULL;
 
67
  }
 
68
  if (G_LIKELY (pbuf != NULL)) {
 
69
    g_object_unref (pbuf);
 
70
    pbuf = NULL;
 
71
  }
 
72
 
 
73
  self->ob_type->tp_free ((PyObject *) self);
 
74
}
 
75
 
 
76
 
57
77
static PyObject *
58
78
get_size (PyObject *self)
59
79
{
60
 
  guint width, height;
61
 
 
62
 
  width = gdk_pixbuf_get_width (TIMAGE (self)->pbuf);
63
 
  height = gdk_pixbuf_get_height (TIMAGE (self)->pbuf);
64
 
 
65
 
  return Py_BuildValue ("(ii)", width, height);
 
80
  return Py_BuildValue ("(ii)", gdk_pixbuf_get_width (TIMAGE (self)->pbuf),
 
81
                                gdk_pixbuf_get_height (TIMAGE (self)->pbuf));
66
82
}
67
83
 
68
84
 
79
95
  color = (r << 24) + (g << 16) + (b << 8) + a;
80
96
 
81
97
  /* kill old pixbuf */
82
 
  if (TIMAGE (self)->pbuf)
83
 
    g_object_unref (G_OBJECT (TIMAGE (self)->pbuf));
 
98
  if (G_LIKELY (TIMAGE (self)->pbuf))
 
99
    g_object_unref (TIMAGE (self)->pbuf);
84
100
 
85
101
  /* make new pixbuf */
86
102
  TIMAGE (self)->pbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 320, 32);
97
113
{
98
114
  guint length;
99
115
  guchar *data;
 
116
 
100
117
  GdkPixbufLoader *loader;
101
118
  GdkPixbuf *alphaified;
102
119
  GError *error = NULL;
105
122
    return NULL;
106
123
 
107
124
  /* kill old pixbuf */
108
 
  if (TIMAGE (self)->pbuf)
109
 
    g_object_unref (G_OBJECT (TIMAGE (self)->pbuf));
 
125
  if (G_LIKELY (TIMAGE (self)->pbuf))
 
126
    g_object_unref (TIMAGE (self)->pbuf);
110
127
 
111
128
  /* make new pixbuf */
112
 
  loader = gdk_pixbuf_loader_new ();
 
129
  loader = g_object_new (GDK_TYPE_PIXBUF_LOADER, NULL);
113
130
  if (!gdk_pixbuf_loader_write (loader, data, length, &error)) {
114
 
    PyErr_SetString(PyExc_RuntimeError, "Invalid image format");
 
131
    PyErr_SetString (PyExc_RuntimeError, error->message);
115
132
    g_error_free (error);
116
133
    return NULL;
117
134
  }
118
135
  if (!gdk_pixbuf_loader_close (loader, &error)) {
119
 
    PyErr_SetString(PyExc_RuntimeError, "Couldn't read image");
 
136
    PyErr_SetString (PyExc_RuntimeError, error->message);
120
137
    g_error_free (error);
121
138
    return NULL;
122
139
  }
125
142
 
126
143
  /* we require an alpha channel */
127
144
  alphaified = gdk_pixbuf_add_alpha (TIMAGE (self)->pbuf, FALSE, 0, 0, 0);
128
 
  g_object_unref (G_OBJECT (TIMAGE (self)->pbuf));
 
145
  g_object_unref (TIMAGE (self)->pbuf);
 
146
 
129
147
  TIMAGE (self)->pbuf = alphaified;
130
 
 
131
148
  TIMAGE (self)->invalidated = TRUE;
132
149
 
133
150
  Py_INCREF (Py_None);
143
160
  GError *error = NULL;
144
161
 
145
162
  if (!PyArg_ParseTuple (args, "s", &filename))
146
 
      return NULL;
 
163
    return NULL;
147
164
 
148
165
  /* kill old pixbuf */
149
 
  if (TIMAGE (self)->pbuf)
150
 
    g_object_unref (G_OBJECT (TIMAGE (self)->pbuf));
 
166
  if (G_LIKELY (TIMAGE (self)->pbuf))
 
167
    g_object_unref (TIMAGE (self)->pbuf);
151
168
 
152
169
  /* make new pixbuf */
153
 
  if (!(TIMAGE (self)->pbuf = gdk_pixbuf_new_from_file (filename, &error))) {
154
 
    PyErr_SetString(PyExc_RuntimeError, "Invalid image format");
 
170
  if (!G_UNLIKELY (TIMAGE (self)->pbuf = gdk_pixbuf_new_from_file (filename,
 
171
                                                                   &error)))
 
172
  {
 
173
    PyErr_SetString(PyExc_RuntimeError, error->message);
155
174
    g_error_free (error);
156
175
    return NULL;
157
176
  }
158
177
 
159
178
  /* we require an alpha channel */
160
179
  alphaified = gdk_pixbuf_add_alpha (TIMAGE (self)->pbuf, FALSE, 0, 0, 0);
161
 
  g_object_unref (G_OBJECT (TIMAGE (self)->pbuf));
 
180
  g_object_unref (TIMAGE (self)->pbuf);
 
181
 
162
182
  TIMAGE (self)->pbuf = alphaified;
163
 
 
164
183
  TIMAGE (self)->invalidated = TRUE;
165
184
 
166
185
  Py_INCREF (Py_None);
185
204
    return NULL;
186
205
 
187
206
  /* kill old pixbuf */
188
 
  if (TIMAGE (self)->pbuf)
189
 
    g_object_unref (G_OBJECT (TIMAGE (self)->pbuf));
 
207
  if (G_LIKELY (TIMAGE (self)->pbuf))
 
208
    g_object_unref (TIMAGE (self)->pbuf);
190
209
 
191
210
  /* make new pixbuf */
192
211
  gdk_drawable_get_size (pmap, &width, &height);
195
214
 
196
215
  /* we require an alpha channel */
197
216
  alphaified = gdk_pixbuf_add_alpha (TIMAGE (self)->pbuf, FALSE, 0, 0, 0);
198
 
  g_object_unref (G_OBJECT (TIMAGE (self)->pbuf));
 
217
  g_object_unref (TIMAGE (self)->pbuf);
199
218
 
200
219
  if (restore_alpha) {
201
220
    rowstride = gdk_pixbuf_get_rowstride (alphaified);
217
236
 
218
237
    TIMAGE (self)->pbuf = gdk_pixbuf_new_subpixbuf (alphaified,
219
238
                                                    0, 0, width, height >> 1);
220
 
    g_object_unref (G_OBJECT (alphaified));
 
239
    g_object_unref (alphaified);
221
240
 
222
241
  } else {
223
242
    TIMAGE (self)->pbuf = alphaified;
233
252
static PyObject *
234
253
render (PyObject *self, PyObject *args)
235
254
{
236
 
  guint width, height;
237
 
  gfloat opacity, saturation;
 
255
  const guint width, height;
 
256
  const gfloat opacity, saturation;
238
257
 
239
258
  if (!PyArg_ParseTuple (args, "iiff", &width, &height, &opacity, &saturation))
240
259
    return NULL;
250
269
static PyObject *
251
270
tile (PyObject *self, PyObject *args)
252
271
{
253
 
  guint width, height;
 
272
  const guint width, height;
254
273
  GdkPixbuf *background;
255
274
 
256
275
  if (!PyArg_ParseTuple (args, "ii", &width, &height))
257
276
    return NULL;
258
277
 
259
 
  if (width == 0 || height == 0) {
 
278
  if (G_UNLIKELY (width == 0 || height == 0)) {
260
279
    Py_INCREF (Py_None);
261
280
    return Py_None;
262
281
  }
285
304
static PyObject *
286
305
set_from_background (PyObject *self, PyObject *args)
287
306
{
288
 
  guint x, y, width, height;
289
 
  glong wallpaper_id;
 
307
  const guint x, y, width, height;
 
308
  const glong wallpaper_id;
290
309
 
291
310
  if (!PyArg_ParseTuple (args, "liiii", &wallpaper_id, &x, &y, &width, &height))
292
311
    return NULL;
293
312
 
294
 
  if (width == 0 || height == 0) {
 
313
  if (G_UNLIKELY (width == 0 || height == 0)) {
295
314
    Py_INCREF (Py_None);
296
315
    return Py_None;
297
316
  }
298
317
 
299
318
  /* kill old pixbuf */
300
 
  if (TIMAGE (self)->pbuf)
301
 
    g_object_unref (G_OBJECT (TIMAGE (self)->pbuf));
 
319
  if (G_LIKELY (TIMAGE (self)->pbuf))
 
320
    g_object_unref (TIMAGE (self)->pbuf);
302
321
 
303
322
  /* make new pixbuf */
304
323
  TIMAGE (self)->pbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
315
334
}
316
335
 
317
336
 
318
 
/* empty so far */
319
 
static PyMethodDef tiling_functions[] = {
320
 
  {NULL}
321
 
};
 
337
static PyMethodDef tiling_functions[] = { {NULL} };
322
338
 
323
339
 
324
340
static PyMethodDef tiling_methods[] = {
340
356
  "tiling.Tiling",                             /*tp_name*/
341
357
  sizeof(TImage),                              /*tp_basicsize*/
342
358
  0,                                           /*tp_itemsize*/
343
 
  0,                                           /*tp_dealloc*/
 
359
  (destructor)tiling_dealloc,                  /*tp_dealloc*/
344
360
  0,                                           /*tp_print*/
345
361
  0,                                           /*tp_getattr*/
346
362
  0,                                           /*tp_setattr*/
371
387
  0,                                           /*tp_descr_get*/
372
388
  0,                                           /*tp_descr_set*/
373
389
  offsetof (PyGObject, inst_dict),             /*tp_dictoffset*/
374
 
  tiling_new,                                  /*tp_init*/
375
 
  0,                                           /*tp_alloc*/
376
 
  0,                                           /*tp_new*/
 
390
  tiling_init,                                 /*tp_init*/
 
391
  PyType_GenericAlloc,                         /*tp_alloc*/
 
392
  PyType_GenericNew,                           /*tp_new*/
377
393
  0                                            /*tp_free*/
378
394
};
379
395
 
381
397
static void
382
398
tiling_register_classes (PyObject *obj)
383
399
{
384
 
  PyObject *module;
 
400
  PyObject *module = PyImport_ImportModule ("gtk");
385
401
 
386
 
  if ((module = PyImport_ImportModule ("gtk")) != NULL) {
 
402
  if (G_LIKELY (module != NULL)) {
387
403
    PyObject *moddict = PyModule_GetDict (module);
388
404
 
389
 
    _PyGtkImage_Type = (PyTypeObject *) PyDict_GetItemString (moddict, "Image");
390
 
    if (_PyGtkImage_Type == NULL) {
391
 
      PyErr_SetString (PyExc_ImportError, "cannot import name Image from gtk");
 
405
    PyGtkImage_Type = (PyTypeObject *) PyDict_GetItemString (moddict, "Image");
 
406
    if (G_UNLIKELY (!PyGtkImage_Type)) {
 
407
      PyErr_SetString (PyExc_ImportError, "Can't import name Image from gtk.");
392
408
      return;
393
409
    }
394
410
 
395
411
  } else {
396
 
    PyErr_SetString(PyExc_ImportError, "could not import gtk");
 
412
    PyErr_SetString (PyExc_ImportError, "Can't import gtk.");
397
413
    return;
398
414
  }
399
415
 
400
416
  pygobject_register_class (obj, "Tiling", GTK_TYPE_IMAGE, &t_tiling,
401
 
                            Py_BuildValue ("(O)", &PyGtkImage_Type));
 
417
                            Py_BuildValue ("(O)", PyGtkImage_Type));
402
418
}
403
419
 
404
420
 
415
431
  tiling_register_classes (dict);
416
432
 
417
433
  if (PyErr_Occurred ())
418
 
    Py_FatalError ("can't initialise module tiling");
 
434
    Py_FatalError ("Can't initialise module tiling.");
419
435
}
420
436