/* -*- Mode: C; c-basic-offset: 4 -*- * pygobject - Python bindings for GObject * Copyright (C) 2008 Johan Dahlin * Copyright (C) 2009 Gian Mario Tagliaretti * * gdrive.override: module overrides for GDrive and related types * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * USA */ %% override g_drive_get_volumes noargs static PyObject * _wrap_g_drive_get_volumes (PyGObject *self) { GList *list, *l; PyObject *ret; pyg_begin_allow_threads; list = g_drive_get_volumes (G_DRIVE (self->obj)); pyg_end_allow_threads; ret = PyList_New(0); for (l = list; l; l = l->next) { GVolume *volume = l->data; PyObject *item = pygobject_new((GObject *)volume); PyList_Append(ret, item); Py_DECREF(item); g_object_unref(volume); } g_list_free(list); return ret; } %% override g_drive_eject kwargs static PyObject * _wrap_g_drive_eject(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "callback", "flags", "cancellable", "user_data", NULL }; PyGIONotify *notify; PyObject *py_flags = NULL; GMountUnmountFlags flags = G_MOUNT_UNMOUNT_NONE; PyGObject *py_cancellable = NULL; GCancellable *cancellable; notify = pygio_notify_new(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:gio.Drive.eject", kwlist, ¬ify->callback, &py_flags, &py_cancellable, ¬ify->data)) goto error; if (PyErr_Warn(PyExc_DeprecationWarning, "gio.Drive.ejectis deprecated, \ use gtk.Drive.eject_with_operation instead") < 0) return NULL; if (!pygio_notify_callback_is_valid(notify)) goto error; if (py_flags && pyg_flags_get_value(G_TYPE_MOUNT_UNMOUNT_FLAGS, py_flags, (gpointer) &flags)) goto error; if (!pygio_check_cancellable(py_cancellable, &cancellable)) goto error; pygio_notify_reference_callback(notify); g_drive_eject(G_DRIVE(self->obj), flags, cancellable, (GAsyncReadyCallback) async_result_callback_marshal, notify); Py_INCREF(Py_None); return Py_None; error: pygio_notify_free(notify); return NULL; } %% override g_drive_poll_for_media kwargs static PyObject * _wrap_g_drive_poll_for_media(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "callback", "cancellable", "user_data", NULL }; PyGIONotify *notify; PyGObject *py_cancellable = NULL; GCancellable *cancellable; notify = pygio_notify_new(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:gio.Drive.eject", kwlist, ¬ify->callback, &py_cancellable, ¬ify->data)) goto error; if (!pygio_notify_callback_is_valid(notify)) goto error; if (!pygio_check_cancellable(py_cancellable, &cancellable)) goto error; pygio_notify_reference_callback(notify); pyg_begin_allow_threads; g_drive_poll_for_media(G_DRIVE(self->obj), cancellable, (GAsyncReadyCallback) async_result_callback_marshal, notify); pyg_end_allow_threads; Py_INCREF(Py_None); return Py_None; error: pygio_notify_free(notify); return NULL; } %% override-slot GDrive.tp_repr static PyObject * _wrap_g_drive_tp_repr(PyGObject *self) { char *name = g_drive_get_name(G_DRIVE(self->obj)); gchar *representation; PyObject *result; if (name) { representation = g_strdup_printf("<%s at %p: %s>", Py_TYPE(self)->tp_name, self, name); g_free(name); } else representation = g_strdup_printf("<%s at %p: UNKNOWN NAME>", Py_TYPE(self)->tp_name, self); result = _PyUnicode_FromString(representation); g_free(representation); return result; } %% override g_drive_enumerate_identifiers noargs static PyObject * _wrap_g_drive_enumerate_identifiers (PyGObject *self) { char **ids; PyObject *ret; pyg_begin_allow_threads; ids = g_drive_enumerate_identifiers(G_DRIVE (self->obj)); pyg_end_allow_threads; if (ids && ids[0] != NULL) { ret = strv_to_pylist(ids); g_strfreev (ids); } else { ret = Py_None; Py_INCREF(ret); } return ret; } %% override g_drive_eject_with_operation kwargs static PyObject * _wrap_g_drive_eject_with_operation(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "callback", "flags", "mount_operation", "cancellable", "user_data", NULL }; PyGIONotify *notify; PyObject *py_flags = NULL; PyGObject *mount_operation; GMountUnmountFlags flags = G_MOUNT_UNMOUNT_NONE; PyGObject *py_cancellable = NULL; GCancellable *cancellable; notify = pygio_notify_new(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:gio.Drive.eject_with_operation", kwlist, ¬ify->callback, &py_flags, &mount_operation, &py_cancellable, ¬ify->data)) goto error; if (!pygio_notify_callback_is_valid(notify)) goto error; if (py_flags && pyg_flags_get_value(G_TYPE_MOUNT_UNMOUNT_FLAGS, py_flags, (gpointer) &flags)) goto error; if (!pygio_check_cancellable(py_cancellable, &cancellable)) goto error; pygio_notify_reference_callback(notify); g_drive_eject_with_operation(G_DRIVE(self->obj), flags, G_MOUNT_OPERATION(mount_operation->obj), cancellable, (GAsyncReadyCallback) async_result_callback_marshal, notify); Py_INCREF(Py_None); return Py_None; error: pygio_notify_free(notify); return NULL; } %% override g_drive_start kwargs static PyObject * _wrap_g_drive_start(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "callback", "flags", "mount_operation", "cancellable", "user_data", NULL }; PyGIONotify *notify; PyObject *py_flags = NULL; PyGObject *mount_operation; GDriveStartFlags flags = G_DRIVE_START_NONE; PyGObject *py_cancellable = NULL; GCancellable *cancellable; notify = pygio_notify_new(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:gio.Drive.start", kwlist, ¬ify->callback, &py_flags, &mount_operation, &py_cancellable, ¬ify->data)) goto error; if (!pygio_notify_callback_is_valid(notify)) goto error; if (py_flags && pyg_flags_get_value(G_TYPE_DRIVE_START_FLAGS, py_flags, (gpointer) &flags)) goto error; if (!pygio_check_cancellable(py_cancellable, &cancellable)) goto error; pygio_notify_reference_callback(notify); g_drive_start(G_DRIVE(self->obj), flags, G_MOUNT_OPERATION(mount_operation->obj), cancellable, (GAsyncReadyCallback) async_result_callback_marshal, notify); Py_INCREF(Py_None); return Py_None; error: pygio_notify_free(notify); return NULL; } %% override g_drive_stop kwargs static PyObject * _wrap_g_drive_stop(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "callback", "flags", "mount_operation", "cancellable", "user_data", NULL }; PyGIONotify *notify; PyObject *py_flags = NULL; PyGObject *mount_operation; GMountUnmountFlags flags = G_MOUNT_UNMOUNT_NONE; PyGObject *py_cancellable = NULL; GCancellable *cancellable; notify = pygio_notify_new(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:gio.Drive.stop", kwlist, ¬ify->callback, &py_flags, &mount_operation, &py_cancellable, ¬ify->data)) goto error; if (!pygio_notify_callback_is_valid(notify)) goto error; if (py_flags && pyg_flags_get_value(G_TYPE_MOUNT_UNMOUNT_FLAGS, py_flags, (gpointer) &flags)) goto error; if (!pygio_check_cancellable(py_cancellable, &cancellable)) goto error; pygio_notify_reference_callback(notify); g_drive_stop(G_DRIVE(self->obj), flags, G_MOUNT_OPERATION(mount_operation->obj), cancellable, (GAsyncReadyCallback) async_result_callback_marshal, notify); Py_INCREF(Py_None); return Py_None; error: pygio_notify_free(notify); return NULL; }