gdata_documents_service_new ()

GDataDocumentsService *
gdata_documents_service_new (GDataAuthorizer *authorizer);

Creates a new GDataDocumentsService using the given GDataAuthorizer. If authorizer is NULL, all requests are made as an unauthenticated user.

Since: 0.9.0

gdata_documents_service_get_primary_authorization_domain ()

GDataAuthorizationDomain *
gdata_documents_service_get_primary_authorization_domain
                               (void);

The primary GDataAuthorizationDomain for interacting with Google Documents. This will not normally need to be used, as it's used internally by the GDataDocumentsService methods. However, if using the plain GDataService methods to implement custom queries or requests which libgdata does not support natively, then this domain may be needed to authorize the requests.

The domain never changes, and is interned so that pointer comparison can be used to differentiate it from other authorization domains.

Since: 0.9.0

gdata_documents_service_get_spreadsheet_authorization_domain ()

GDataAuthorizationDomain *
gdata_documents_service_get_spreadsheet_authorization_domain
                               (void);

The GDataAuthorizationDomain for interacting with spreadsheet data. This will not normally need to be used, as it's automatically used internally by the GDataDocumentsService methods. However, if using the plain GDataService methods to implement custom queries or requests which libgdata does not support natively, then this domain may be needed to authorize the requests which pertain to the Google Spreadsheets Data API, such as requests to download or upload spreadsheet documents.

The domain never changes, and is interned so that pointer comparison can be used to differentiate it from other authorization domains.

Since: 0.9.0

gdata_documents_service_get_metadata ()

GDataDocumentsMetadata *
gdata_documents_service_get_metadata (GDataDocumentsService *self,
                                      GCancellable *cancellable,
                                      GError **error);

Gets a GDataDocumentsMetadata object containing metadata about the documents service itself, like how large the user quota is.

Since: 0.17.9

gdata_documents_service_get_metadata_async ()

void
gdata_documents_service_get_metadata_async
                               (GDataDocumentsService *self,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Gets a GDataDocumentsMetadata object containing metadata about the documents service itself, like how large the user quota is.

For more details, see gdata_documents_service_get_metadata(), which is the synchronous version of this function.

When the operation is finished, callback will be called. You can then call gdata_documents_service_get_metadata_finish() to get the results of the operation.

Since: 0.17.9

gdata_documents_service_get_metadata_finish ()

GDataDocumentsMetadata *
gdata_documents_service_get_metadata_finish
                               (GDataDocumentsService *self,
                                GAsyncResult *async_result,
                                GError **error);

Finish an asynchronous operation to get a GDataDocumentsMetadata started with gdata_documents_service_get_metadata_async().

Since: 0.17.9

gdata_documents_service_query_documents ()

GDataDocumentsFeed *
gdata_documents_service_query_documents
                               (GDataDocumentsService *self,
                                GDataDocumentsQuery *query,
                                GCancellable *cancellable,
                                GDataQueryProgressCallback progress_callback,
                                gpointer progress_user_data,
                                GError **error);

Queries the service to return a list of documents matching the given query . Note that query has to be a GDataDocumentsQuery, rather than just a GDataQuery, as it uses the folder ID specified in “folder-id”.

For more details, see gdata_service_query().

Since: 0.4.0

gdata_documents_service_query_documents_async ()

void
gdata_documents_service_query_documents_async
                               (GDataDocumentsService *self,
                                GDataDocumentsQuery *query,
                                GCancellable *cancellable,
                                GDataQueryProgressCallback progress_callback,
                                gpointer progress_user_data,
                                GDestroyNotify destroy_progress_user_data,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Queries the service to return a list of documents matching the given query . self and query are both reffed when this function is called, so can safely be unreffed after this function returns.

For more details, see gdata_documents_service_query_documents(), which is the synchronous version of this function, and gdata_service_query_async(), which is the base asynchronous query function.

Since: 0.9.1

gdata_documents_service_upload_document ()

GDataUploadStream *
gdata_documents_service_upload_document
                               (GDataDocumentsService *self,
                                GDataDocumentsDocument *document,
                                const gchar *slug,
                                const gchar *content_type,
                                GDataDocumentsFolder *folder,
                                GCancellable *cancellable,
                                GError **error);

Uploads a document to Google Documents, using the properties from document and the document data written to the resulting GDataUploadStream. If the document data does not need to be provided at the moment, just the metadata, use gdata_service_insert_entry() instead (e.g. in the case of creating a new, empty file to be edited at a later date).

This performs a non-resumable upload, unlike gdata_documents_service_upload_document(). This means that errors during transmission will cause the upload to fail, and the entire document will have to be re-uploaded. It is recommended that gdata_documents_service_upload_document_resumable() be used instead.

If document is NULL, only the document data will be uploaded. The new document entry will be named using slug , and will have default metadata.

The stream returned by this function should be written to using the standard GOutputStream methods, asychronously or synchronously. Once the stream is closed (using g_output_stream_close()), gdata_documents_service_finish_upload() should be called on it to parse and return the updated GDataDocumentsDocument for the document. This must be done, as document isn't updated in-place.

In order to cancel the upload, a GCancellable passed in to cancellable must be cancelled using g_cancellable_cancel(). Cancelling the individual GOutputStream operations on the GDataUploadStream will not cancel the entire upload; merely the write or close operation in question. See the “cancellable” for more details.

Any upload errors will be thrown by the stream methods, and may come from the GDataServiceError domain.

Since: 0.8.0

gdata_documents_service_upload_document_resumable ()

GDataUploadStream *
gdata_documents_service_upload_document_resumable
                               (GDataDocumentsService *self,
                                GDataDocumentsDocument *document,
                                const gchar *slug,
                                const gchar *content_type,
                                goffset content_length,
                                GDataDocumentsUploadQuery *query,
                                GCancellable *cancellable,
                                GError **error);

Uploads a document to Google Documents, using the properties from document and the document data written to the resulting GDataUploadStream. If the document data does not need to be provided at the moment, just the metadata, use gdata_service_insert_entry() instead (e.g. in the case of creating a new, empty file to be edited at a later date).

Unlike gdata_documents_service_upload_document(), this method performs a

transmission errors without re-uploading the entire file. Use of this method is preferred over gdata_documents_service_upload_document().

If document is NULL, only the document data will be uploaded. The new document entry will be named using slug , and will have default metadata.

If non-NULL, the query specifies parameters for the upload, such as a GDataDocumentsFolder to upload the document into; and whether to treat the document as an opaque file, or convert it to a standard format. If query is NULL, the document will be uploaded into the root folder, and automatically converted to a standard format. No OCR or automatic language translation will be performed by default.

If query is non-NULL and “convert” is FALSE, document must be an instance of GDataDocumentsDocument. Otherwise, document must be a subclass of it, such as GDataDocumentsPresentation.

The stream returned by this function should be written to using the standard GOutputStream methods, asychronously or synchronously. Once the stream is closed (using g_output_stream_close()), gdata_documents_service_finish_upload() should be called on it to parse and return the updated GDataDocumentsDocument for the document. This must be done, as document isn't updated in-place.

In order to cancel the upload, a GCancellable passed in to cancellable must be cancelled using g_cancellable_cancel(). Cancelling the individual GOutputStream operations on the GDataUploadStream will not cancel the entire upload; merely the write or close operation in question. See the “cancellable” for more details.

Any upload errors will be thrown by the stream methods, and may come from the GDataServiceError domain.

Since: 0.13.0

gdata_documents_service_update_document ()

GDataUploadStream *
gdata_documents_service_update_document
                               (GDataDocumentsService *self,
                                GDataDocumentsDocument *document,
                                const gchar *slug,
                                const gchar *content_type,
                                GCancellable *cancellable,
                                GError **error);

Update the document using the properties from document and the document data written to the resulting GDataUploadStream. If the document data does not need to be changed, just the metadata, use gdata_service_update_entry() instead.

This performs a non-resumable upload, unlike gdata_documents_service_update_document(). This means that errors during transmission will cause the upload to fail, and the entire document will have to be re-uploaded. It is recommended that gdata_documents_service_update_document_resumable() be used instead.

The stream returned by this function should be written to using the standard GOutputStream methods, asychronously or synchronously. Once the stream is closed (using g_output_stream_close()), gdata_documents_service_finish_upload() should be called on it to parse and return the updated GDataDocumentsDocument for the document. This must be done, as document isn't updated in-place.

In order to cancel the update, a GCancellable passed in to cancellable must be cancelled using g_cancellable_cancel(). Cancelling the individual GOutputStream operations on the GDataUploadStream will not cancel the entire update; merely the write or close operation in question. See the “cancellable” for more details.

Any upload errors will be thrown by the stream methods, and may come from the GDataServiceError domain.

For more information, see gdata_service_update_entry().

Since: 0.8.0

gdata_documents_service_update_document_resumable ()

GDataUploadStream *
gdata_documents_service_update_document_resumable
                               (GDataDocumentsService *self,
                                GDataDocumentsDocument *document,
                                const gchar *slug,
                                const gchar *content_type,
                                goffset content_length,
                                GCancellable *cancellable,
                                GError **error);

Update the document using the properties from document and the document data written to the resulting GDataUploadStream. If the document data does not need to be changed, just the metadata, use gdata_service_update_entry() instead.

Unlike gdata_documents_service_update_document(), this method performs a

transmission errors without re-uploading the entire file. Use of this method is preferred over gdata_documents_service_update_document().

The stream returned by this function should be written to using the standard GOutputStream methods, asychronously or synchronously. Once the stream is closed (using g_output_stream_close()), gdata_documents_service_finish_upload() should be called on it to parse and return the updated GDataDocumentsDocument for the document. This must be done, as document isn't updated in-place.

In order to cancel the update, a GCancellable passed in to cancellable must be cancelled using g_cancellable_cancel(). Cancelling the individual GOutputStream operations on the GDataUploadStream will not cancel the entire update; merely the write or close operation in question. See the “cancellable” for more details.

Any upload errors will be thrown by the stream methods, and may come from the GDataServiceError domain.

For more information, see gdata_service_update_entry().

Since: 0.13.0

gdata_documents_service_finish_upload ()

GDataDocumentsDocument *
gdata_documents_service_finish_upload (GDataDocumentsService *self,
                                       GDataUploadStream *upload_stream,
                                       GError **error);

Finish off a document upload or update operation started by gdata_documents_service_upload_document() or gdata_documents_service_update_document(), parsing the result and returning the new or updated GDataDocumentsDocument.

If an error occurred during the upload or update operation, it will have been returned during the operation (e.g. by g_output_stream_splice() or one of the other stream methods). In such a case, NULL will be returned but error will remain unset. error is only set in the case that the server indicates that the operation was successful, but an error is encountered in parsing the result sent by the server.

In the case that no GDataDocumentsDocument was passed (to gdata_documents_service_upload_document() or gdata_documents_service_update_document()) when starting the operation, GDATA_DOCUMENTS_SERVICE_ERROR_INVALID_CONTENT_TYPE will be thrown in error if the content type of the uploaded data could not be mapped to a document type with which to interpret the response from the server.

Since: 0.8.0

gdata_documents_service_copy_document ()

GDataDocumentsDocument *
gdata_documents_service_copy_document (GDataDocumentsService *self,
                                       GDataDocumentsDocument *document,
                                       GCancellable *cancellable,
                                       GError **error);

Copy the given document , producing a duplicate document in the same folder and returning its GDataDocumentsDocument.

Errors from GDataServiceError can be returned for exceptional conditions, as determined by the server.

Since: 0.13.1

gdata_documents_service_copy_document_async ()

void
gdata_documents_service_copy_document_async
                               (GDataDocumentsService *self,
                                GDataDocumentsDocument *document,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Copy the given document , producing a duplicate document in the same folder and returning its GDataDocumentsDocument. self and document are both reffed when this function is called, so can safely be unreffed after this function returns.

For more details, see gdata_documents_service_copy_document(), which is the synchronous version of this function.

When the operation is finished, callback will be called. You can then call gdata_documents_service_copy_document_finish() to get the results of the operation.

Since: 0.13.1

gdata_documents_service_copy_document_finish ()

GDataDocumentsDocument *
gdata_documents_service_copy_document_finish
                               (GDataDocumentsService *self,
                                GAsyncResult *async_result,
                                GError **error);

Finish an asynchronous operation to copy a GDataDocumentsDocument started with gdata_documents_service_copy_document_async().

Since: 0.13.1

gdata_documents_service_add_entry_to_folder ()

GDataDocumentsEntry *
gdata_documents_service_add_entry_to_folder
                               (GDataDocumentsService *self,
                                GDataDocumentsEntry *entry,
                                GDataDocumentsFolder *folder,
                                GCancellable *cancellable,
                                GError **error);

Add the given entry to the specified folder , and return an updated GDataDocumentsEntry for entry . If the entry is already in another folder, a copy will be added to the new folder. The copy and original will have different IDs. Note that entry can't be a GDataDocumentsFolder that already exists on the server. It can be a new GDataDocumentsFolder, or a GDataDocumentsDocument that is either new or already present on the server.

Errors from GDataServiceError can be returned for exceptional conditions, as determined by the server.

Since: 0.8.0

gdata_documents_service_add_entry_to_folder_async ()

void
gdata_documents_service_add_entry_to_folder_async
                               (GDataDocumentsService *self,
                                GDataDocumentsEntry *entry,
                                GDataDocumentsFolder *folder,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Add the given entry to the specified folder . self , entry and folder are all reffed when this function is called, so can safely be unreffed after this function returns.

For more details, see gdata_documents_service_add_entry_to_folder(), which is the synchronous version of this function.

When the operation is finished, callback will be called. You can then call gdata_documents_service_add_entry_to_folder_finish() to get the results of the operation.

Since: 0.8.0

gdata_documents_service_add_entry_to_folder_finish ()

GDataDocumentsEntry *
gdata_documents_service_add_entry_to_folder_finish
                               (GDataDocumentsService *self,
                                GAsyncResult *async_result,
                                GError **error);

Finish an asynchronous operation to add a GDataDocumentsEntry to a folder started with gdata_documents_service_add_entry_to_folder_async().

Since: 0.8.0

gdata_documents_service_remove_entry_from_folder ()

GDataDocumentsEntry *
gdata_documents_service_remove_entry_from_folder
                               (GDataDocumentsService *self,
                                GDataDocumentsEntry *entry,
                                GDataDocumentsFolder *folder,
                                GCancellable *cancellable,
                                GError **error);

Remove the given entry from folder , and return an updated GDataDocumentsEntry for entry . entry will remain a member of any other folders it's currently in. Note that entry can be either a GDataDocumentsDocument or a GDataDocumentsFolder.

Errors from GDataServiceError can be returned for exceptional conditions, as determined by the server.

Since: 0.8.0

gdata_documents_service_remove_entry_from_folder_async ()

void
gdata_documents_service_remove_entry_from_folder_async
                               (GDataDocumentsService *self,
                                GDataDocumentsEntry *entry,
                                GDataDocumentsFolder *folder,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Remove the given entry from the specified folder . self , entry and folder are all reffed when this function is called, so can safely be unreffed after this function returns.

For more details, see gdata_documents_service_remove_entry_from_folder(), which is the synchronous version of this function.

When the operation is finished, callback will be called. You can then call gdata_documents_service_remove_entry_from_folder_finish() to get the results of the operation.

Since: 0.8.0

gdata_documents_service_remove_entry_from_folder_finish ()

GDataDocumentsEntry *
gdata_documents_service_remove_entry_from_folder_finish
                               (GDataDocumentsService *self,
                                GAsyncResult *async_result,
                                GError **error);

Finish an asynchronous operation to remove a GDataDocumentsEntry from a folder started with gdata_documents_service_remove_entry_from_folder_async().

Since: 0.8.0

gdata_documents_service_get_upload_uri ()

gchar *
gdata_documents_service_get_upload_uri
                               (GDataDocumentsFolder *folder);

Gets the upload URI for documents for the service.

If folder is NULL, the URI will be the one to upload documents to the "root" folder.

Since: 0.5.0

GDataDocumentsService

typedef struct _GDataDocumentsService GDataDocumentsService;

All the fields in the GDataDocumentsService structure are private and should never be accessed directly.

Since: 0.4.0

GDataDocumentsServiceClass

typedef struct {
} GDataDocumentsServiceClass;

All the fields in the GDataDocumentsServiceClass structure are private and should never be accessed directly.

Since: 0.4.0

enum GDataDocumentsServiceError

Error codes for GDataDocumentsService operations.

Since: 0.4.0