From 94fc81e4161ab6701177a1deb5d79c18542501be Mon Sep 17 00:00:00 2001 From: Gian Mario Tagliaretti Date: Sat, 25 Apr 2009 13:24:57 +0200 Subject: Complete the docs for the gio.File class --- docs/reference/pygio-file.xml | 1717 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1717 insertions(+) (limited to 'docs/reference') diff --git a/docs/reference/pygio-file.xml b/docs/reference/pygio-file.xml index 9c58199..9c3cf87 100644 --- a/docs/reference/pygio-file.xml +++ b/docs/reference/pygio-file.xml @@ -604,6 +604,46 @@ + + Constructor + + + gio.File + commandline + pathNone + uriNone + + + + commandline : + a command line string. + + + + path : + a string containing a relative or absolute path. + + + + uri : + a string containing a URI. + + + + Returns : + a new + gio.File. + + + + + + Creates a new gio.File either from a commandline, + a path or an uri. + + + + Methods @@ -2813,5 +2853,1682 @@ URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] are possible too, and depend on what kind of filesystem the file is on. + + + gio.File.query_filesystem_info_async + + + query_filesystem_info_async + attributes + callback + io_priorityglib.PRIORITY_DEFAULT + cancellableNone + user_dataNone + + + + + attributes : + an attribute query string. + + + + callback : + a GAsyncReadyCallback to call when the request is satisfied. + + + + io_priority : + the + + of the request. + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + user_data : + the data to pass to callback function. + + + + + + The query_filesystem_info_async() method asynchronously + gets the requested information about the filesystem that the specified file is on. + The result is a GFileInfo object that contains key-value attributes + (such as type or size for the file). + + + For more details, see + query_filesystem_info() + which is the synchronous version of this call. + + + When the operation is finished, callback will be called. You can then call + gio.File.query_filesystem_info_finish() + to get the result of the operation. + + + + + gio.File.query_filesystem_info_finish + + + query_filesystem_info_finish + result + + + + + result : + a gio.AsyncResult. + + + + Returns : + a gio.FileInfo + or None if an error occurred. + + + + + + The query_filesystem_info_finish() method finishes an asynchronous + copy operation started with + gio.File.query_filesystem_info_async(). + + + + + gio.File.query_filesystem_info + + + query_info + attributes + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + attributes : + an attribute query string. + + + + flags : + + a + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + a gio.FileInfo + for the given file or None if there was an error. + + + + + + The query_info() method gets the requested + information about specified file. The result is a + gio.FileInfo + object that contains key-value attributes (such as the type or size of the file). + + + The attribute value is a string that specifies the file attributes that should + be gathered. It is not an error if it's not possible to read a particular + requested attribute from a file - it just won't be set. attribute should be + a comma-separated list of attribute or attribute wildcards. The wildcard "*" + means all attributes, and a wildcard like "standard::*" means all attributes + in the standard namespace. An example attribute query be "standard::*,owner::user". + The standard attributes are available as defines, like gio.FILE_ATTRIBUTE_STANDARD_NAME. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + For symlinks, normally the information about the target of the symlink is returned, + rather than information about the symlink itself. However if you pass + gio.FILE_QUERY_INFO_NOFOLLOW_SYMLINKS in flags the information about + the symlink itself will be returned. Also, for symlinks that point to non-existing + files the information about the symlink itself will be returned. + + + If the file does not exist, the gio.IO_ERROR_NOT_FOUND error will be + returned. Other errors are possible too, and depend on what kind of + filesystem the file is on. + + + + + gio.File.query_info_async + + + query_info_async + callback + attributes + flagsgio.FILE_QUERY_INFO_NONE + io_priorityglib.PRIORITY_DEFAULT + cancellableNone + user_dataNone + + + + + callback : + a GAsyncReadyCallback to call when the request is satisfied. + + + + attributes : + an attribute query string. + + + + flags : + + a + + + + io_priority : + the + + of the request. + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + user_data : + the data to pass to callback function. + + + + + + The query_info_async() method Asynchronously gets the + requested information about specified file. The result is a + gio.FileInfo + object that contains key-value attributes (such as type or size for the file). + + + For more details, see + query_info() + which is the synchronous version of this call. + + + When the operation is finished, callback will be called. You can then call + gio.File.query_info_finish() + to get the result of the operation. + + + + + gio.File.query_info_finish + + + query_info_finish + result + + + + + result : + a gio.AsyncResult. + + + + Returns : + a gio.FileInfo + for the given file or None if an error occurred. + + + + + + The query_info_finish() method finishes an asynchronous + copy operation started with + gio.File.query_info_async(). + + + + + gio.File.query_settable_attributes + + + query_settable_attributes + cancellableNone + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + a list of + gio.FileAttributeInfo + describing the settable attributes. + + + + + + The query_settable_attributes() method obtain the + list of settable attributes for the file. + + + Returns the type and full attribute name of all the attributes that can be + set on this file. This doesn't mean setting it will always succeed though, + you might get an access failure, or some specific file may not support a specific attribute. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.query_writable_namespace + + + query_writable_namespace + cancellableNone + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + a list of + gio.FileAttributeInfo + describing the writable namespaces. + + + + + + The query_writable_namespace() method obtain the + list of attribute namespaces where new attributes can be created by a user. + An example of this is extended attributes (in the "xattr" namespace). + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.read + + + read + cancellableNone + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + a + gio.FileInputStream + or None on error. + + + + + + The read() method opens a file for reading. The result + is a gio.FileInputStream + that can be used to read the contents of the file. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + If the file does not exist, the gio.IO_ERROR_NOT_FOUND error will be returned. + If the file is a directory, the gio.IO_ERROR_IS_DIRECTORY error will be returned. + Other errors are possible too, and depend on what kind of filesystem the file is on. + + + + + gio.File.read_async + + + read_async + callback + io_priorityglib.PRIORITY_DEFAULT + cancellableNone + user_dataNone + + + + + callback : + a GAsyncReadyCallback to call when the request is satisfied. + + + + io_priority : + the + + of the request. + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + user_data : + the data to pass to callback function. + + + + + + The read_async() method asynchronously opens file for reading. + + + For more details, see + read() + which is the synchronous version of this call. + + + When the operation is finished, callback will be called. You can then call + gio.File.read_finish() + to get the result of the operation. + + + + + gio.File.read_finish + + + read_finish + result + + + + + result : + a gio.AsyncResult. + + + + Returns : + a gio.FileInputStream + file or None if an error occurred. + + + + + + The read_finish() method finishes an asynchronous + copy operation started with + gio.File.read_async(). + + + + + gio.File.replace + + + replace + etag + make_backup + flagsgio.FILE_CREATE_NONE + cancellableNone + + + + + etag : + an optional entity tag for the current + gio.File, + or None to ignore. + + + + make_backup : + True if a backup should be created. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + a + gio.FileOutputStream + or None on error. + + + + + + The replace() method returns an output stream for + overwriting the file, possibly creating a backup copy of the file first. + If the file doesn't exist, it will be created. + + + This will try to replace the file in the safest way possible so that any + errors during the writing will not affect an already existing copy of the file. + For instance, for local files it may write to a temporary file and then atomically + rename over the destination when the stream is closed. + + + By default files created are generally readable by everyone, but if you pass + gio.FILE_CREATE_PRIVATE in flags the file will be made readable only to + the current user, to the level that is supported on the target filesystem. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + If you pass in a non-None etag value, then this value is compared + to the current entity tag of the file, and if they differ an gio.IO_ERROR_WRONG_ETAG error + is returned. This generally means that the file has been changed since you last read it. + You can get the new etag from + gio.FileOutputStream.get_etag() + after you've finished writing and closed the GFileOutputStream. When you load a new file you can use + gio.FileInputStream.query_info() + to get the etag of the file. + + + If make_backup is True, this function will attempt to make a backup + of the current file before overwriting it. If this fails a gio.IO_ERROR_CANT_CREATE_BACKUP + error will be returned. If you want to replace anyway, try again + with make_backup set to False. + + + If the file is a directory the gio.IO_ERROR_IS_DIRECTORY error will be returned, and + if the file is some other form of non-regular file then a gio.IO_ERROR_NOT_REGULAR_FILE + error will be returned. Some file systems don't allow all file names, and may return an + gio.IO_ERROR_INVALID_FILENAME error, and if the name is to long gio.IO_ERROR_FILENAME_TOO_LONG + will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on. + + + + + gio.File.replace_async + + + replace_async + callback + etagNone + make_backupTrue + flagsgio.FILE_CREATE_NONE + io_priorityglib.PRIORITY_DEFAULT + cancellableNone + user_dataNone + + + + + callback : + a GAsyncReadyCallback to call when the request is satisfied. + + + + etag : + an optional entity tag for the current + gio.File, + or None to ignore. + + + + make_backup : + True if a backup should be created. + + + + flags : + a set of + + + + + io_priority : + the + + of the request. + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + user_data : + the data to pass to callback function. + + + + + + The replace_async() method asynchronously overwrites the file, + replacing the contents, possibly creating a backup copy of the file first. + + + For more details, see + replace() + which is the synchronous version of this call. + + + When the operation is finished, callback will be called. You can then call + gio.File.replace_finish() + to get the result of the operation. + + + + + gio.File.replace_contents + + + replace_contents + contents + etag + make_backup + flagsgio.FILE_CREATE_NONE + cancellableNone + + + + + contents : + a string containing the new contents for file. + + + + etag : + the old entity tag for the document + or None to ignore. + + + + make_backup : + True if a backup should be created. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + the new entity tag for the document. + + + + + + The replace_contents() method replaces the contents + of file with contents of length bytes. If etag is specified (not NULL) any existing + file must have that etag, or the error gio.IO_ERROR_WRONG_ETAG will be returned. + + + If make_backup is True, this function will attempt to make a backup of file. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + The returned etag can be used to verify that the file hasn't changed the next time it is saved over. + + + + + gio.File.replace_contents_async + + + replace_contents_async + contents + callback + etagNone + make_backupTrue + flagsgio.FILE_CREATE_NONE + io_priorityglib.PRIORITY_DEFAULT + cancellableNone + user_dataNone + + + + + contents : + a string containing the new contents for file. + + + + callback : + a GAsyncReadyCallback to call when the request is satisfied. + + + + etag : + an optional entity tag for the current + gio.File, + or None to ignore. + + + + make_backup : + True if a backup should be created. + + + + flags : + a set of + + + + + io_priority : + the + + of the request. + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + user_data : + the data to pass to callback function. + + + + + + The replace_contents_async() method starts an asynchronous + replacement of file with the given contents of length bytes. etag will + replace the document's current entity tag. + + + For more details, see + replace_contents() + which is the synchronous version of this call. + + + When the operation is finished, callback will be called. You can then call + gio.File.replace_contents_finish() + to get the result of the operation. + + + + + gio.File.replace_contents_finish + + + replace_contents_finish + result + + + + + result : + a gio.AsyncResult. + + + + Returns : + the new entity tag for the document. + + + + + + The replace_contents_finish() method finishes an asynchronous + copy operation started with + gio.File.replace_contents_async(). + + + + + gio.File.replace_finish + + + replace_finish + result + + + + + result : + a gio.AsyncResult. + + + + Returns : + a gio.FileOutputStream + or None if an error occurred. + + + + + + The replace_finish() method finishes an asynchronous + copy operation started with + gio.File.replace_async(). + + + + + gio.File.resolve_relative_path + + + resolve_relative_path + relative_path + + + + + relative_path : + a given relative path string. + + + + Returns : + a gio.File + to the resolved path. None if relative_path is None + or if file is invalid. + + + + + + The resolve_relative_path() method resolves a + relative path for file to an absolute path. + + + This call does no blocking i/o. + + + + + gio.File.set_attribute + + + set_attribute + attribute + type + value_p + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + attribute : + a string containing the attribute's name. + + + + type : + the type of the attribute . + + + + value_p : + the value. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True if the attribute was set, + False otherwise. + + + + + + The set_attribute() method sets an attribute in + the file with attribute name attribute to value. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_attribute_byte_string + + + set_attribute_byte_string + attribute + value + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + attribute : + a string containing the attribute's name. + + + + value : + a string containing the attribute's new value. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True if the attribute was set, + False otherwise. + + + + + + The set_attribute_byte_string() method Sets attribute of type + gio.FILE_ATTRIBUTE_TYPE_BYTE_STRING to value. If attribute is of a different type, + this operation will fail, returning False. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_attribute_int32 + + + set_attribute_int32 + attribute + value + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + attribute : + a string containing the attribute's name. + + + + value : + an int containing the attribute's new value. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True if the attribute was set, + False otherwise. + + + + + + The set_attribute_int32() method sets attribute of type + gio.FILE_ATTRIBUTE_TYPE_INT32 to value. If attribute is of a different type, + this operation will fail. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_attribute_int64 + + + set_attribute_int64 + attribute + value + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + attribute : + a string containing the attribute's name. + + + + value : + a long containing the attribute's new value. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True if the attribute was set, + False otherwise. + + + + + + The set_attribute_int64() method sets attribute of type + gio.FILE_ATTRIBUTE_TYPE_INT64 to value. If attribute is of a different type, + this operation will fail. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_attribute_string + + + set_attribute_string + attribute + value + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + attribute : + a string containing the attribute's name. + + + + value : + a string containing the attribute's new value. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True if the attribute was set, + False otherwise. + + + + + + The set_attribute_string() method sets attribute of type + gio.FILE_ATTRIBUTE_TYPE_STRING to value. If attribute is of a different type, + this operation will fail. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_attribute_uint32 + + + set_attribute_uint32 + attribute + value + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + attribute : + a string containing the attribute's name. + + + + value : + an int containing the attribute's new value. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True if the attribute was set, + False otherwise. + + + + + + The set_attribute_uint32() method sets attribute of type + gio.FILE_ATTRIBUTE_TYPE_UINT32 to value. If attribute is of a different type, + this operation will fail. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_attribute_uint64 + + + set_attribute_uint64 + attribute + value + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + attribute : + a string containing the attribute's name. + + + + value : + a long containing the attribute's new value. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True if the attribute was set, + False otherwise. + + + + + + The set_attribute_uint64() method sets attribute of type + gio.FILE_ATTRIBUTE_TYPE_UINT64 to value. If attribute is of a different type, + this operation will fail. + + + If cancellable is not None, then the operation can be cancelled by triggering + the cancellable object from another thread. If the operation was cancelled, the error + gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_attributes_async + + + set_attributes_async + info + callback + flagsgio.FILE_QUERY_INFO_NONE + io_priorityglib.PRIORITY_DEFAULT + cancellableNone + user_dataNone + + + + + info : + a gio.FileInfo + + + + callback : + a GAsyncReadyCallback to call when the request is satisfied. + + + + flags : + a set of + + + + + io_priority : + the + + of the request. + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + user_data : + the data to pass to callback function. + + + + + + The set_attributes_async() method asynchronously + sets the attributes of file with info. + + + For more details, see + set_attributes_from_info() + which is the synchronous version of this call. + + + When the operation is finished, callback will be called. You can then call + gio.File.set_attributes_finish() + to get the result of the operation. + + + + + gio.File.set_attributes_finish + + + set_attributes_finish + result + + + + + result : + a gio.AsyncResult. + + + + Returns : + True if the attributes were set correctly, + False otherwise. + + + + + + The set_attributes_finish() method finishes an asynchronous + copy operation started with + gio.File.set_attributes_async(). + + + + + gio.File.set_attributes_from_info + + + set_attributes_from_info + info + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + + + + + info : + a gio.FileInfo + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True if the attributes were set correctly, + False otherwise. + + + + + + The set_attributes_from_info() method tries to set + all attributes in the GFileInfo on the target values, not stopping on the first error. + + If there is any error during this operation then error will be set to the + first error. Error on particular fields are flagged by setting the "status" + field in the attribute value to gio.FILE_ATTRIBUTE_STATUS_ERROR_SETTING, + which means you can also detect further errors. + + + + If cancellable is not None, then the operation can be cancelled + by triggering the cancellable object from another thread. If the operation was cancelled, + the error gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_display_name + + + set_display_name + display_name + cancellableNone + + + + + display_name : + a string conaining the name to display. + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + a gio.File + specifying what file was renamed to, or None if there was an error. + + + + + + The set_display_name() method renames file to + the specified display name. + + + The display name is converted from UTF8 to the correct encoding for the + target filesystem if possible and the file is renamed to this. + + + If you want to implement a rename operation in the user interface the + edit name (gio.FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the + initial value in the rename widget, and then the result after editing + should be passed to + gio.File.set_dispay_name(). + + + On success the resulting converted filename is returned. + + + If cancellable is not None, then the operation can be cancelled + by triggering the cancellable object from another thread. If the operation was cancelled, + the error gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.set_display_name_async + + + set_display_name_async + display_name + callback + io_priorityglib.PRIORITY_DEFAULT + cancellableNone + user_dataNone + + + + + display_name : + a string conaining the name to display. + + + + callback : + a GAsyncReadyCallback to call when the request is satisfied. + + + + io_priority : + the + + of the request. + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + user_data : + the data to pass to callback function. + + + + + + The set_display_name_async() method asynchronously + sets the display name for a given GFile. + + + For more details, see + set_display_name() + which is the synchronous version of this call. + + + When the operation is finished, callback will be called. You can then call + gio.File.set_display_name_finish() + to get the result of the operation. + + + + + gio.File.set_display_name_finish + + + set_display_name_finish + result + + + + + result : + a gio.AsyncResult. + + + + Returns : + a gio.File + or None on error. + + + + + + The set_display_name_finish() method finishes an asynchronous + copy operation started with + gio.File.set_display_name_async(). + + + + + gio.File.trash + + + trash + cancellableNone + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + Returns : + True on successful trash, False otherwise. + + + + + + The trash() method sends file to the "Trashcan", if possible. + This is similar to deleting it, but the user can recover it before emptying the trashcan. + Not all file systems support trashing, so this call can return the gio.IO_ERROR_NOT_SUPPORTED error. + + + If cancellable is not None, then the operation can be cancelled + by triggering the cancellable object from another thread. If the operation was cancelled, + the error gio.IO_ERROR_CANCELLED will be returned. + + + + + gio.File.unmount_mountable + + + unmount_mountable + callback + flagsgio.FILE_QUERY_INFO_NONE + cancellableNone + user_dataNone + + + + + callback : + a GAsyncReadyCallback to call when the request is satisfied. + + + + flags : + a set of + + + + + cancellable : + optional + gio.Cancellable + object, None to ignore. + + + user_data : + the data to pass to callback function. + + + + + + The unmount_mountable() method unmounts a file of type gio.FILE_TYPE_MOUNTABLE. + + + If cancellable is not None, then the operation can be cancelled + by triggering the cancellable object from another thread. If the operation was cancelled, + the error gio.IO_ERROR_CANCELLED will be returned. + + + When the operation is finished, callback will be called. You can then call + gio.File.unmount_mountable_finish() + to get the result of the operation. + + + + + gio.File.unmount_mountable_finish + + + unmount_mountable_finish + result + + + + + result : + a gio.AsyncResult. + + + + Returns : + True if the operation finished successfully, + False otherwise. + + + + + + The unmount_mountable_finish() method finishes an asynchronous + copy operation started with + gio.File.unmount_mountable(). + + + + + + Functions + + + gio.file_parse_name + + + file_parse_name + parse_name + + + + + parse_name : + a file name or path to be parsed. + + + + Returns : + a new gio.File. + + + + + + The parse_name() function constructs a + gio.File + with the given parse_name (i.e. something given by g_file_get_parse_name()). + This operation never fails, but the returned object might not support any I/O + operation if the parse_name cannot be parsed. + + -- cgit