Wrap gio.File.enumerate_children_async, add tests, docstring and an

        * examples/gio/directory-async.py:
        * gio/gfile.override:
        * gio/gfileenumerator.override:
        * gio/gio.defs:
        * tests/test_gio.py:
        Wrap gio.File.enumerate_children_async, add tests, docstring
        and an example.
        Also document gio.File.enumerate while we're at it.


svn path=/trunk/; revision=828

3 files changed, 102 insertions, 4 deletions

diff --git a/gio/gfile.override b/gio/gfile.override
index 2d299ab..4a12e0d 100644
--- a/gio/gfile.override
+++ b/gio/gfile.override
@@ -200,9 +200,9 @@ _wrap_g_file_load_contents_async(PyGObject *self,
         return NULL;
 
     g_file_load_contents_async(G_FILE(self->obj),
-                            cancellable,
-                            (GAsyncReadyCallback)async_result_callback_marshal,
-                            notify);
+			       cancellable,
+			       (GAsyncReadyCallback)async_result_callback_marshal,
+			       notify);
 
     Py_INCREF(Py_None);
     return Py_None;
@@ -242,9 +242,67 @@ _wrap_g_file_load_contents_finish(PyGObject *self,
         return Py_None;      
     }
 }
+%%
+override g_file_enumerate_children_async kwargs
+static PyObject *
+_wrap_g_file_enumerate_children_async(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "attributes", "flags", "callback",
+			      "io_priority", "cancellable", "user_data", NULL };
+    PyGAsyncRequestNotify *notify;
+    char *attributes;
+    PyObject *py_flags = NULL;
+    int io_priority = G_PRIORITY_DEFAULT;
+    GFileQueryInfoFlags flags = G_FILE_QUERY_INFO_NONE;
+    GCancellable *cancellable = NULL;
+    PyGObject *py_cancellable = NULL;
+
+    notify = g_slice_new0(PyGAsyncRequestNotify);
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "sO|OiOO:GFile.enumerate_children_async",
+				     kwlist,
+				     &attributes,
+				     &notify->callback,
+				     &py_flags,
+				     &io_priority,
+				     &py_cancellable,
+				     &notify->data))
+    {
+      g_slice_free(PyGAsyncRequestNotify, notify);
+      return NULL;
+    }
+
+    if (!PyCallable_Check(notify->callback))
+    {
+	PyErr_SetString(PyExc_TypeError, "callback argument not callable");
+	g_slice_free(PyGAsyncRequestNotify, notify);
+	return NULL;
+    }
+    Py_INCREF(notify->callback);
+    Py_XINCREF(notify->data);
+  
+    if (py_flags && pyg_flags_get_value(G_TYPE_FILE_QUERY_INFO_FLAGS,
+					py_flags, (gpointer)&flags))
+        return NULL;
+
+    if (!pygio_check_cancellable(py_cancellable, &cancellable))
+	return NULL;
+    
+    g_file_enumerate_children_async(G_FILE(self->obj),
+				    attributes,
+				    flags,
+				    io_priority,
+				    (GCancellable *) cancellable,
+				    (GAsyncReadyCallback)async_result_callback_marshal,
+				    notify);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
 /* GFile.append_to_async */
 /* GFile.create_async */
-/* GFile.enumerate_children_async */
 /* GFile.eject_mountable */
 /* GFile.find_enclosing_mount_async */
 /* GFile.mount_enclosing_volume */
diff --git a/gio/gfileenumerator.override b/gio/gfileenumerator.override
index 0dc9b11..8263cdb 100644
--- a/gio/gfileenumerator.override
+++ b/gio/gfileenumerator.override
@@ -24,6 +24,7 @@ override-slot GFileEnumerator.tp_iter
 static PyObject*
 _wrap_g_file_enumerator_tp_iter(PyGObject *self)
 {
+    Py_INCREF (self);
     return (PyObject *) self;
 }
 %%
@@ -34,12 +35,18 @@ _wrap_g_file_enumerator_tp_iternext(PyGObject *iter)
     GFileInfo *file_info;
     GError *error = NULL;
 
+    if (!iter->obj) {
+	PyErr_SetNone(PyExc_StopIteration);
+	return NULL;
+    }
+
     file_info = g_file_enumerator_next_file(G_FILE_ENUMERATOR(iter->obj),
 					    NULL,
 					    &error);
     if (pyg_error_check(&error)) {
         return NULL;
     }
+    
     if (!file_info) {
 	PyErr_SetNone(PyExc_StopIteration);
 	return NULL;
diff --git a/gio/gio.defs b/gio/gio.defs
index 49fc12b..25b8aa9 100644
--- a/gio/gio.defs
+++ b/gio/gio.defs
@@ -1499,6 +1499,27 @@
 )
 
 (define-method enumerate_children
+  (docstring 
+"F.enumerate_children(attributes, [flags, cancellable]) -> enumerator\n"
+"Gets the requested information about the files in a directory.\n" 
+"The result is a gio.FileEnumerator object that will give out gio.FileInfo\n"
+"objects for all the files in the directory.\n"
+"The attribute value is a string that specifies the file attributes that\n"
+"should be gathered. It is not an error if it's not possible to read a \n"
+"particular requested attribute from a file - it just won't be set.\n"
+"attribute should be a comma-separated list of attribute or attribute\n"
+"wildcards. The wildcard \"*\" means all attributes, and a wildcard like\n"
+"\"standard::*\" means all attributes in the standard namespace.\n"
+"An example attribute query be \"standard::*,owner::user\". The standard\n"
+"attributes are available as defines, like gio.FILE_ATTRIBUTE_STANDARD_NAME.\n"
+"\n"
+"If cancellable is not None, then the operation can be cancelled by\n"
+"triggering the cancellable object from another thread. If the operation was\n"
+"cancelled, the error gio.ERROR_CANCELLED will be returned.\n"
+"\n"
+"If the file does not exist, the gio.ERROR_NOT_FOUND error will be returned.\n"
+"If the file is not a directory, the gio.FILE_ERROR_NOTDIR error will\n"
+"be returned. Other errors are possible too.")
   (of-object "GFile")
   (c-name "g_file_enumerate_children")
   (return-type "GFileEnumerator*")
@@ -1511,6 +1532,18 @@
 )
 
 (define-method enumerate_children_async
+  (docstring 
+"F.enumerate_children_async(attributes, callback,\n"
+"                           [flags, io_priority, cancellable, user_data])\n"
+"Asynchronously gets the requested information about the files in a directory.\n"
+"The result is a GFileEnumerator object that will give out GFileInfo objects\n"
+"for all the files in the directory.\n"
+"\n"
+"For more details, see gio.File.enumerate_children() which is the synchronous\n"
+"version of this call.\n"
+"\n"
+"When the operation is finished, callback will be called. You can then call\n"
+"gio.File.enumerate_children_finish() to get the result of the operation.")
   (of-object "GFile")
   (c-name "g_file_enumerate_children_async")
   (return-type "none")