1 /* -*- Mode: C; c-set-style: python; c-basic-offset: 4 -*-
2 * pyglib - Python bindings for GLib toolkit.
3 * Copyright (C) 1998-2003 James Henstridge
4 * 2004-2008 Johan Dahlin
6 * glibmodule.c: wrapper for the glib library.
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
31 #include "pyglib-private.h"
32 #include "pygiochannel.h"
33 #include "pygmaincontext.h"
34 #include "pygmainloop.h"
35 #include "pygoptioncontext.h"
36 #include "pygoptiongroup.h"
37 #include "pygsource.h"
40 #define PYGLIB_MAJOR_VERSION PYGOBJECT_MAJOR_VERSION
41 #define PYGLIB_MINOR_VERSION PYGOBJECT_MINOR_VERSION
42 #define PYGLIB_MICRO_VERSION PYGOBJECT_MICRO_VERSION
45 /* ---------------- glib module functions -------------------- */
47 struct _PyGChildData {
53 get_handler_priority(gint *priority, PyObject *kwargs)
58 /* no keyword args? leave as default */
59 if (kwargs == NULL) return 0;
61 len = PyDict_Size(kwargs);
62 if (len == 0) return 0;
65 PyErr_SetString(PyExc_TypeError,
66 "expecting at most one keyword argument");
70 PyDict_Next(kwargs, &pos, &key, &val);
71 if (!PYGLIB_PyUnicode_Check(key)) {
72 PyErr_SetString(PyExc_TypeError,
73 "keyword argument name is not a string");
77 if (strcmp(PYGLIB_PyUnicode_AsString(key), "priority") != 0) {
78 PyErr_SetString(PyExc_TypeError,
79 "only 'priority' keyword argument accepted");
83 *priority = PYGLIB_PyLong_AsLong(val);
84 if (PyErr_Occurred()) {
86 PyErr_SetString(PyExc_ValueError, "could not get priority value");
93 pyglib_threads_init(PyObject *unused, PyObject *args, PyObject *kwargs)
95 if (!pyglib_enable_threads())
103 pyglib_idle_add(PyObject *self, PyObject *args, PyObject *kwargs)
105 PyObject *first, *callback, *cbargs = NULL, *data;
106 gint len, priority = G_PRIORITY_DEFAULT_IDLE;
109 len = PyTuple_Size(args);
111 PyErr_SetString(PyExc_TypeError,
112 "idle_add requires at least 1 argument");
115 first = PySequence_GetSlice(args, 0, 1);
116 if (!PyArg_ParseTuple(first, "O:idle_add", &callback)) {
121 if (!PyCallable_Check(callback)) {
122 PyErr_SetString(PyExc_TypeError, "first argument not callable");
125 if (get_handler_priority(&priority, kwargs) < 0)
128 cbargs = PySequence_GetSlice(args, 1, len);
132 data = Py_BuildValue("(ON)", callback, cbargs);
135 handler_id = g_idle_add_full(priority,
136 _pyglib_handler_marshal, data,
137 _pyglib_destroy_notify);
138 return PYGLIB_PyLong_FromLong(handler_id);
143 pyglib_timeout_add(PyObject *self, PyObject *args, PyObject *kwargs)
145 PyObject *first, *callback, *cbargs = NULL, *data;
146 gint len, priority = G_PRIORITY_DEFAULT;
147 guint interval, handler_id;
149 len = PyTuple_Size(args);
151 PyErr_SetString(PyExc_TypeError,
152 "timeout_add requires at least 2 args");
155 first = PySequence_GetSlice(args, 0, 2);
156 if (!PyArg_ParseTuple(first, "IO:timeout_add", &interval, &callback)) {
161 if (!PyCallable_Check(callback)) {
162 PyErr_SetString(PyExc_TypeError, "second argument not callable");
165 if (get_handler_priority(&priority, kwargs) < 0)
168 cbargs = PySequence_GetSlice(args, 2, len);
172 data = Py_BuildValue("(ON)", callback, cbargs);
175 handler_id = g_timeout_add_full(priority, interval,
176 _pyglib_handler_marshal, data,
177 _pyglib_destroy_notify);
178 return PYGLIB_PyLong_FromLong(handler_id);
182 pyglib_timeout_add_seconds(PyObject *self, PyObject *args, PyObject *kwargs)
184 PyObject *first, *callback, *cbargs = NULL, *data;
185 gint len, priority = G_PRIORITY_DEFAULT;
186 guint interval, handler_id;
188 len = PyTuple_Size(args);
190 PyErr_SetString(PyExc_TypeError,
191 "timeout_add_seconds requires at least 2 args");
194 first = PySequence_GetSlice(args, 0, 2);
195 if (!PyArg_ParseTuple(first, "IO:timeout_add_seconds", &interval, &callback)) {
200 if (!PyCallable_Check(callback)) {
201 PyErr_SetString(PyExc_TypeError, "second argument not callable");
204 if (get_handler_priority(&priority, kwargs) < 0)
207 cbargs = PySequence_GetSlice(args, 2, len);
211 data = Py_BuildValue("(ON)", callback, cbargs);
214 handler_id = g_timeout_add_seconds_full(priority, interval,
215 _pyglib_handler_marshal, data,
216 _pyglib_destroy_notify);
217 return PYGLIB_PyLong_FromLong(handler_id);
221 iowatch_marshal(GIOChannel *source,
222 GIOCondition condition,
225 PyGILState_STATE state;
226 PyObject *tuple, *func, *firstargs, *args, *ret;
229 g_return_val_if_fail(user_data != NULL, FALSE);
231 state = pyglib_gil_state_ensure();
233 tuple = (PyObject *)user_data;
234 func = PyTuple_GetItem(tuple, 0);
236 /* arg vector is (fd, condtion, *args) */
237 firstargs = Py_BuildValue("(Oi)", PyTuple_GetItem(tuple, 1), condition);
238 args = PySequence_Concat(firstargs, PyTuple_GetItem(tuple, 2));
239 Py_DECREF(firstargs);
241 ret = PyObject_CallObject(func, args);
247 if (ret == Py_None) {
248 if (PyErr_Warn(PyExc_Warning,
249 "_glib.io_add_watch callback returned None; "
250 "should return True/False")) {
254 res = PyObject_IsTrue(ret);
258 pyglib_gil_state_release(state);
264 pyglib_io_add_watch(PyObject *self, PyObject *args, PyObject *kwargs)
266 PyObject *first, *pyfd, *callback, *cbargs = NULL, *data;
267 gint fd, priority = G_PRIORITY_DEFAULT, condition;
269 GIOChannel *iochannel;
272 len = PyTuple_Size(args);
274 PyErr_SetString(PyExc_TypeError,
275 "io_add_watch requires at least 3 args");
278 first = PySequence_GetSlice(args, 0, 3);
279 if (!PyArg_ParseTuple(first, "OiO:io_add_watch", &pyfd, &condition,
285 fd = PyObject_AsFileDescriptor(pyfd);
289 if (!PyCallable_Check(callback)) {
290 PyErr_SetString(PyExc_TypeError, "third argument not callable");
293 if (get_handler_priority(&priority, kwargs) < 0)
296 cbargs = PySequence_GetSlice(args, 3, len);
299 data = Py_BuildValue("(OON)", callback, pyfd, cbargs);
302 iochannel = g_io_channel_unix_new(fd);
303 handler_id = g_io_add_watch_full(iochannel, priority, condition,
304 iowatch_marshal, data,
305 (GDestroyNotify)_pyglib_destroy_notify);
306 g_io_channel_unref(iochannel);
308 return PYGLIB_PyLong_FromLong(handler_id);
312 pyglib_source_remove(PyObject *self, PyObject *args)
316 if (!PyArg_ParseTuple(args, "i:source_remove", &tag))
319 return PyBool_FromLong(g_source_remove(tag));
323 pyglib_main_context_default(PyObject *unused)
325 return pyglib_main_context_new(g_main_context_default());
329 child_watch_func(GPid pid, gint status, gpointer data)
331 struct _PyGChildData *child_data = (struct _PyGChildData *) data;
333 PyGILState_STATE gil;
335 gil = pyglib_gil_state_ensure();
336 if (child_data->data)
337 retval = PyObject_CallFunction(child_data->func, "iiO", pid, status,
340 retval = PyObject_CallFunction(child_data->func, "ii", pid, status);
347 pyglib_gil_state_release(gil);
351 child_watch_dnotify(gpointer data)
353 struct _PyGChildData *child_data = (struct _PyGChildData *) data;
354 Py_DECREF(child_data->func);
355 Py_XDECREF(child_data->data);
356 g_slice_free(struct _PyGChildData, child_data);
361 pyglib_child_watch_add(PyObject *unused, PyObject *args, PyObject *kwargs)
363 static char *kwlist[] = { "pid", "function", "data", "priority", NULL };
365 gint priority = G_PRIORITY_DEFAULT;
367 PyObject *func, *user_data = NULL;
368 struct _PyGChildData *child_data;
370 if (!PyArg_ParseTupleAndKeywords(args, kwargs,
371 "iO|Oi:glib.child_watch_add", kwlist,
372 &pid, &func, &user_data, &priority))
374 if (!PyCallable_Check(func)) {
375 PyErr_SetString(PyExc_TypeError,
376 "_glib.child_watch_add: second argument must be callable");
380 child_data = g_slice_new(struct _PyGChildData);
381 child_data->func = func;
382 child_data->data = user_data;
383 Py_INCREF(child_data->func);
384 if (child_data->data)
385 Py_INCREF(child_data->data);
386 id = g_child_watch_add_full(priority, pid, child_watch_func,
387 child_data, child_watch_dnotify);
388 return PYGLIB_PyLong_FromLong(id);
392 pyglib_markup_escape_text(PyObject *unused, PyObject *args, PyObject *kwargs)
394 static char *kwlist[] = { "text", NULL };
395 char *text_in, *text_out;
396 Py_ssize_t text_size;
399 if (!PyArg_ParseTupleAndKeywords(args, kwargs,
400 "s#:glib.markup_escape_text", kwlist,
401 &text_in, &text_size))
404 text_out = g_markup_escape_text(text_in, text_size);
405 retval = PYGLIB_PyUnicode_FromString(text_out);
411 pyglib_get_current_time(PyObject *unused)
415 g_get_current_time(&timeval);
416 return pyglib_float_from_timeval(timeval);
420 get_user_dir(const char *path)
423 return PYGLIB_PyUnicode_FromString(path);
431 pyglib_get_user_config_dir(PyObject *self)
433 return get_user_dir(g_get_user_config_dir());
437 pyglib_get_user_cache_dir(PyObject *self)
439 return get_user_dir(g_get_user_cache_dir());
443 pyglib_get_user_data_dir(PyObject *self)
445 return get_user_dir(g_get_user_data_dir());
449 pyglib_get_user_special_dir(PyObject *unused, PyObject *args, PyObject *kwargs)
451 static char *kwlist[] = { "directory", NULL };
455 if (!PyArg_ParseTupleAndKeywords(args, kwargs,
456 "i:glib.get_user_special_dir", kwlist,
460 path = g_get_user_special_dir(directory);
462 return PYGLIB_PyUnicode_FromString(path);
470 pyglib_main_depth(PyObject *unused)
472 return PYGLIB_PyLong_FromLong(g_main_depth());
476 pyglib_filename_display_name(PyObject *self, PyObject *args)
478 PyObject *py_display_name;
479 char *filename, *display_name;
481 if (!PyArg_ParseTuple(args, "s:glib.filename_display_name",
485 display_name = g_filename_display_name(filename);
486 py_display_name = PyUnicode_DecodeUTF8(display_name,
487 strlen(display_name), NULL);
488 g_free(display_name);
489 return py_display_name;
493 pyglib_filename_display_basename(PyObject *self, PyObject *args)
495 PyObject *py_display_basename;
496 char *filename, *display_basename;
498 if (!PyArg_ParseTuple(args, "s:glib.filename_display_basename",
502 display_basename = g_filename_display_basename(filename);
503 py_display_basename = PyUnicode_DecodeUTF8(display_basename,
504 strlen(display_basename), NULL);
505 g_free(display_basename);
506 return py_display_basename;
510 pyglib_filename_from_utf8(PyObject *self, PyObject *args)
512 char *filename, *utf8string;
513 Py_ssize_t utf8string_len;
515 GError *error = NULL;
516 PyObject *py_filename;
518 if (!PyArg_ParseTuple(args, "s#:glib.filename_from_utf8",
519 &utf8string, &utf8string_len))
522 filename = g_filename_from_utf8(utf8string, utf8string_len,
523 NULL, &bytes_written, &error);
524 if (pyglib_error_check(&error)) {
528 py_filename = PYGLIB_PyUnicode_FromStringAndSize(filename, bytes_written);
535 pyglib_get_application_name(PyObject *self)
539 name = g_get_application_name();
544 return PYGLIB_PyUnicode_FromString(name);
548 pyglib_set_application_name(PyObject *self, PyObject *arg)
550 if (!PYGLIB_PyUnicode_Check(arg)) {
551 PyErr_Format(PyExc_TypeError,
552 "first argument must be a string, not '%s'",
553 PYGLIB_PyUnicode_AsString(PyObject_Repr(arg)));
556 g_set_application_name(PYGLIB_PyUnicode_AsString(arg));
562 pyglib_get_prgname(PyObject *self)
566 name = g_get_prgname();
571 return PYGLIB_PyUnicode_FromString(name);
575 pyglib_set_prgname(PyObject *self, PyObject *arg)
577 if (!PYGLIB_PyUnicode_Check(arg)) {
578 PyErr_Format(PyExc_TypeError,
579 "first argument must be a string, not '%s'",
580 PYGLIB_PyUnicode_AsString(PyObject_Repr(arg)));
583 g_set_prgname(PYGLIB_PyUnicode_AsString(arg));
589 pyglib_find_program_in_path(PyObject *unused, PyObject *args, PyObject *kwargs)
591 static char *kwlist[] = { "program", NULL };
595 if (!PyArg_ParseTupleAndKeywords(args, kwargs,
596 "s:glib.find_program_in_path", kwlist,
600 ret = g_find_program_in_path(program);
601 retval = PYGLIB_PyUnicode_FromString(ret);
607 pyglib_uri_list_extract_uris(PyObject *self, PyObject *args, PyObject *kwargs)
609 static char *kwlist[] = { "uri_list", NULL };
615 if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:uri_list_extract_uris", kwlist, &uri_list))
618 uris = (char **)g_uri_list_extract_uris(uri_list);
628 ret = PyTuple_New(i);
629 for (j = 0; j < i; j++)
630 PyTuple_SetItem(ret, j, PYGLIB_PyUnicode_FromString(uris[j]));
637 /* FIXME: we should use strv_to_pylist (in pygio-utils.h) here, but that
638 * function should be moved into pyglib first. See
639 * https://bugzilla.gnome.org/show_bug.cgi?id=630508
642 tuple_of_strings_from_dirs(const gchar* const *dirs)
657 ret = PyTuple_New(i);
658 for (j = 0; j < i; j++)
659 PyTuple_SetItem(ret, j, PYGLIB_PyUnicode_FromString(dirs[j]));
665 pyglib_get_system_config_dirs(PyObject *self)
667 return tuple_of_strings_from_dirs(g_get_system_config_dirs());
671 pyglib_get_system_data_dirs(PyObject *self)
673 return tuple_of_strings_from_dirs(g_get_system_data_dirs());
676 static PyMethodDef _glib_functions[] = {
678 (PyCFunction) pyglib_threads_init, METH_NOARGS,
680 "Initialize GLib for use from multiple threads. If you also use GTK+\n"
681 "itself (i.e. GUI, not just PyGObject), use gtk.gdk.threads_init()\n"
684 (PyCFunction)pyglib_idle_add, METH_VARARGS|METH_KEYWORDS,
685 "idle_add(callable, user_data=None, priority=None) -> source id\n"
686 " callable receives (user_data)\n"
687 "Adds a callable to be called whenever there are no higher priority\n"
688 "events pending to the default main loop." },
690 (PyCFunction)pyglib_timeout_add, METH_VARARGS|METH_KEYWORDS,
691 "timeout_add(interval, callable, user_data=None,\n"
692 " priority=None) -> source id\n"
693 " callable receives (user_data)\n"
694 "Sets a callable be called repeatedly until it returns False." },
695 { "timeout_add_seconds",
696 (PyCFunction)pyglib_timeout_add_seconds, METH_VARARGS|METH_KEYWORDS,
697 "timeout_add(interval, callable, user_data=None,\n"
698 " priority=None) -> source_id\n"
699 " callable receives (user_data)\n"
700 "Sets a callable be called repeatedly until it returns False.\n"
701 "Use this if you want to have a timer in the \"seconds\" range\n"
702 "and do not care about the exact time of the first call of the\n"
703 "timer, use this for more efficient system power usage." },
705 (PyCFunction)pyglib_io_add_watch, METH_VARARGS|METH_KEYWORDS,
706 "io_add_watch(fd, condition, callback, user_data=None) -> source id\n"
707 " callable receives (fd, condition, user_data)\n"
708 "Arranges for the fd to be monitored by the main loop for the\n"
709 "specified condition. Condition is a combination of glib.IO_IN,\n"
710 "glib.IO_OUT, glib.IO_PRI, gio.IO_ERR and gio.IO_HUB.\n" },
712 (PyCFunction)pyglib_child_watch_add, METH_VARARGS|METH_KEYWORDS,
713 "child_watch_add(pid, callable, user_data=None,\n"
714 "priority=None) -> source id\n"
715 " callable receives (pid, condition, user_data)\n"
716 "Sets the function specified by function to be called with the user\n"
717 "data specified by data when the child indicated by pid exits.\n"
718 "Condition is a combination of glib.IO_IN, glib.IO_OUT, glib.IO_PRI,\n"
719 "gio.IO_ERR and gio.IO_HUB." },
721 (PyCFunction)pyglib_source_remove, METH_VARARGS,
722 "source_remove(source_id) -> True if removed\n"
723 "Removes the event source specified by source id as returned by the\n"
724 "glib.idle_add(), glib.timeout_add() or glib.io_add_watch()\n"
727 (PyCFunction)pyglib_spawn_async, METH_VARARGS|METH_KEYWORDS,
728 "spawn_async(argv, envp=None, working_directory=None,\n"
729 " flags=0, child_setup=None, user_data=None,\n"
730 " standard_input=None, standard_output=None,\n"
731 " standard_error=None) -> (pid, stdin, stdout, stderr)\n"
732 "Execute a child program asynchronously within a glib.MainLoop()\n"
733 "See the reference manual for a complete reference." },
734 { "main_context_default",
735 (PyCFunction)pyglib_main_context_default, METH_NOARGS,
736 "main_context_default() -> a main context\n"
737 "Returns the default main context. This is the main context used\n"
738 "for main loop functions when a main loop is not explicitly specified." },
740 (PyCFunction)pyglib_main_depth, METH_NOARGS,
741 "main_depth() -> stack depth\n"
742 "Returns the depth of the stack of calls in the main context." },
743 { "filename_display_name",
744 (PyCFunction)pyglib_filename_display_name, METH_VARARGS },
745 { "filename_display_basename",
746 (PyCFunction)pyglib_filename_display_basename, METH_VARARGS },
747 { "filename_from_utf8",
748 (PyCFunction)pyglib_filename_from_utf8, METH_VARARGS },
749 { "get_application_name",
750 (PyCFunction)pyglib_get_application_name, METH_NOARGS },
751 { "set_application_name",
752 (PyCFunction)pyglib_set_application_name, METH_O },
754 (PyCFunction)pyglib_get_prgname, METH_NOARGS },
756 (PyCFunction)pyglib_set_prgname, METH_O },
757 { "get_current_time",
758 (PyCFunction)pyglib_get_current_time, METH_NOARGS },
759 { "get_user_cache_dir",
760 (PyCFunction)pyglib_get_user_cache_dir, METH_NOARGS },
761 { "get_user_config_dir",
762 (PyCFunction)pyglib_get_user_config_dir, METH_NOARGS },
763 { "get_user_data_dir",
764 (PyCFunction)pyglib_get_user_data_dir, METH_NOARGS },
765 { "get_user_special_dir",
766 (PyCFunction)pyglib_get_user_special_dir, METH_VARARGS|METH_KEYWORDS },
767 { "markup_escape_text",
768 (PyCFunction)pyglib_markup_escape_text, METH_VARARGS|METH_KEYWORDS },
769 { "find_program_in_path",
770 (PyCFunction)pyglib_find_program_in_path, METH_VARARGS|METH_KEYWORDS },
771 { "uri_list_extract_uris",
772 (PyCFunction)pyglib_uri_list_extract_uris, METH_VARARGS|METH_KEYWORDS,
773 "uri_list_extract_uris(uri_list) -> tuple of strings holding URIs\n"
774 "Splits an string containing an URI list conforming to the \n"
775 "text/uri-list mime type defined in RFC 2483 into individual URIs, \n"
776 "discarding any comments. The URIs are not validated." },
777 { "get_system_config_dirs",
778 (PyCFunction)pyglib_get_system_config_dirs, METH_NOARGS },
779 { "get_system_data_dirs",
780 (PyCFunction)pyglib_get_system_data_dirs, METH_NOARGS },
784 /* ----------------- glib module initialisation -------------- */
786 static struct _PyGLib_Functions pyglib_api = {
787 FALSE, /* threads_enabled */
788 NULL, /* gerror_exception */
789 NULL, /* block_threads */
790 NULL, /* unblock_threads */
791 pyg_main_context_new,
792 pyg_option_context_new,
793 pyg_option_group_new,
797 pyglib_register_api(PyObject *d)
801 /* for addon libraries ... */
802 PyDict_SetItemString(d, "_PyGLib_API",
803 o=PYGLIB_CPointer_WrapPointer(&pyglib_api,"gi._glib._PyGLib_API"));
806 pyglib_init_internal(o);
810 pyglib_register_error(PyObject *d)
813 PyObject *gerror_class;
815 /* This is a hack to work around the deprecation warning of
816 * BaseException.message in Python 2.6+.
817 * GError has also an "message" attribute.
819 PyDict_SetItemString(dict, "message", Py_None);
820 gerror_class = PyErr_NewException("gi._glib.GError", PyExc_RuntimeError, dict);
823 PyDict_SetItemString(d, "GError", gerror_class);
824 pyglib_api.gerror_exception = gerror_class;
828 pyglib_register_version_tuples(PyObject *d)
833 o = Py_BuildValue("(iii)", glib_major_version, glib_minor_version,
835 PyDict_SetItemString(d, "glib_version", o);
839 o = Py_BuildValue("(iii)",
840 PYGLIB_MAJOR_VERSION,
841 PYGLIB_MINOR_VERSION,
842 PYGLIB_MICRO_VERSION);
843 PyDict_SetItemString(d, "pyglib_version", o);
848 pyglib_register_constants(PyObject *m)
850 PyModule_AddIntConstant(m, "SPAWN_LEAVE_DESCRIPTORS_OPEN",
851 G_SPAWN_LEAVE_DESCRIPTORS_OPEN);
852 PyModule_AddIntConstant(m, "SPAWN_DO_NOT_REAP_CHILD",
853 G_SPAWN_DO_NOT_REAP_CHILD);
854 PyModule_AddIntConstant(m, "SPAWN_SEARCH_PATH",
855 G_SPAWN_SEARCH_PATH);
856 PyModule_AddIntConstant(m, "SPAWN_STDOUT_TO_DEV_NULL",
857 G_SPAWN_STDOUT_TO_DEV_NULL);
858 PyModule_AddIntConstant(m, "SPAWN_STDERR_TO_DEV_NULL",
859 G_SPAWN_STDERR_TO_DEV_NULL);
860 PyModule_AddIntConstant(m, "SPAWN_CHILD_INHERITS_STDIN",
861 G_SPAWN_CHILD_INHERITS_STDIN);
862 PyModule_AddIntConstant(m, "SPAWN_FILE_AND_ARGV_ZERO",
863 G_SPAWN_FILE_AND_ARGV_ZERO);
865 PyModule_AddIntConstant(m, "PRIORITY_HIGH",
867 PyModule_AddIntConstant(m, "PRIORITY_DEFAULT",
869 PyModule_AddIntConstant(m, "PRIORITY_HIGH_IDLE",
870 G_PRIORITY_HIGH_IDLE);
871 PyModule_AddIntConstant(m, "PRIORITY_DEFAULT_IDLE",
872 G_PRIORITY_DEFAULT_IDLE);
873 PyModule_AddIntConstant(m, "PRIORITY_LOW",
876 PyModule_AddIntConstant(m, "IO_IN", G_IO_IN);
877 PyModule_AddIntConstant(m, "IO_OUT", G_IO_OUT);
878 PyModule_AddIntConstant(m, "IO_PRI", G_IO_PRI);
879 PyModule_AddIntConstant(m, "IO_ERR", G_IO_ERR);
880 PyModule_AddIntConstant(m, "IO_HUP", G_IO_HUP);
881 PyModule_AddIntConstant(m, "IO_NVAL", G_IO_NVAL);
883 PyModule_AddIntConstant(m, "IO_STATUS_ERROR",
885 PyModule_AddIntConstant(m, "IO_STATUS_NORMAL",
887 PyModule_AddIntConstant(m, "IO_STATUS_EOF",
889 PyModule_AddIntConstant(m, "IO_STATUS_AGAIN",
891 PyModule_AddIntConstant(m, "IO_FLAG_APPEND",
893 PyModule_AddIntConstant(m, "IO_FLAG_NONBLOCK",
895 PyModule_AddIntConstant(m, "IO_FLAG_IS_READABLE",
896 G_IO_FLAG_IS_READABLE);
897 PyModule_AddIntConstant(m, "IO_FLAG_IS_WRITEABLE",
898 G_IO_FLAG_IS_WRITEABLE);
899 PyModule_AddIntConstant(m, "IO_FLAG_IS_SEEKABLE",
900 G_IO_FLAG_IS_SEEKABLE);
901 PyModule_AddIntConstant(m, "IO_FLAG_MASK",
903 PyModule_AddIntConstant(m, "IO_FLAG_GET_MASK",
905 PyModule_AddIntConstant(m, "IO_FLAG_SET_MASK",
908 PyModule_AddIntConstant(m, "OPTION_FLAG_HIDDEN",
909 G_OPTION_FLAG_HIDDEN);
910 PyModule_AddIntConstant(m, "OPTION_FLAG_IN_MAIN",
911 G_OPTION_FLAG_IN_MAIN);
912 PyModule_AddIntConstant(m, "OPTION_FLAG_REVERSE",
913 G_OPTION_FLAG_REVERSE);
914 PyModule_AddIntConstant(m, "OPTION_FLAG_NO_ARG",
915 G_OPTION_FLAG_NO_ARG);
916 PyModule_AddIntConstant(m, "OPTION_FLAG_FILENAME",
917 G_OPTION_FLAG_FILENAME);
918 PyModule_AddIntConstant(m, "OPTION_FLAG_OPTIONAL_ARG",
919 G_OPTION_FLAG_OPTIONAL_ARG);
920 PyModule_AddIntConstant(m, "OPTION_FLAG_NOALIAS",
921 G_OPTION_FLAG_NOALIAS);
923 PyModule_AddIntConstant(m, "OPTION_ERROR_UNKNOWN_OPTION",
924 G_OPTION_ERROR_UNKNOWN_OPTION);
925 PyModule_AddIntConstant(m, "OPTION_ERROR_BAD_VALUE",
926 G_OPTION_ERROR_BAD_VALUE);
927 PyModule_AddIntConstant(m, "OPTION_ERROR_FAILED",
928 G_OPTION_ERROR_FAILED);
930 PyModule_AddIntConstant(m, "USER_DIRECTORY_DESKTOP",
931 G_USER_DIRECTORY_DESKTOP);
932 PyModule_AddIntConstant(m, "USER_DIRECTORY_DOCUMENTS",
933 G_USER_DIRECTORY_DOCUMENTS);
934 PyModule_AddIntConstant(m, "USER_DIRECTORY_DOWNLOAD",
935 G_USER_DIRECTORY_DOWNLOAD);
936 PyModule_AddIntConstant(m, "USER_DIRECTORY_MUSIC",
937 G_USER_DIRECTORY_MUSIC);
938 PyModule_AddIntConstant(m, "USER_DIRECTORY_PICTURES",
939 G_USER_DIRECTORY_PICTURES);
940 PyModule_AddIntConstant(m, "USER_DIRECTORY_PUBLIC_SHARE",
941 G_USER_DIRECTORY_PUBLIC_SHARE);
942 PyModule_AddIntConstant(m, "USER_DIRECTORY_TEMPLATES",
943 G_USER_DIRECTORY_TEMPLATES);
944 PyModule_AddIntConstant(m, "USER_DIRECTORY_VIDEOS",
945 G_USER_DIRECTORY_VIDEOS);
947 PyModule_AddStringConstant(m, "OPTION_REMAINING",
949 PyModule_AddStringConstant(m, "OPTION_ERROR",
950 (char*) g_quark_to_string(G_OPTION_ERROR));
953 PYGLIB_MODULE_START(_glib, "_glib")
955 PyObject *d = PyModule_GetDict(module);
957 pyglib_register_constants(module);
958 pyglib_register_api(d);
959 pyglib_register_error(d);
960 pyglib_register_version_tuples(d);
961 pyglib_iochannel_register_types(d);
962 pyglib_mainloop_register_types(d);
963 pyglib_maincontext_register_types(d);
964 pyglib_source_register_types(d);
965 pyglib_spawn_register_types(d);
966 pyglib_option_context_register_types(d);
967 pyglib_option_group_register_types(d);