static void
asset_created_cb (GObject * source, GAsyncResult * res, gpointer udata)
{
GList *tracks, *tmp;
GESAsset *asset;
GESLayer *layer;
GESUriClip *tlfs;
GError *error = NULL;
asset = ges_asset_request_finish (res, &error);
ASSERT_OBJECT_REFCOUNT (asset, "1 for us + for the cache + 1 taken "
"by g_simple_async_result_complete_in_idle", 3);
fail_unless (error == NULL);
fail_if (asset == NULL);
fail_if (g_strcmp0 (ges_asset_get_id (asset), av_uri));
layer = GES_LAYER (g_async_result_get_user_data (res));
tlfs = GES_URI_CLIP (ges_layer_add_asset (layer,
asset, 0, 0, GST_CLOCK_TIME_NONE, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_URI_CLIP (tlfs));
fail_if (g_strcmp0 (ges_uri_clip_get_uri (tlfs), av_uri));
assert_equals_uint64 (_DURATION (tlfs), GST_SECOND);
fail_unless (ges_clip_get_supported_formats
(GES_CLIP (tlfs)) & GES_TRACK_TYPE_VIDEO);
fail_unless (ges_clip_get_supported_formats
(GES_CLIP (tlfs)) & GES_TRACK_TYPE_AUDIO);
tracks = ges_timeline_get_tracks (ges_layer_get_timeline (layer));
for (tmp = tracks; tmp; tmp = tmp->next) {
GList *trackelements = ges_track_get_elements (GES_TRACK (tmp->data));
assert_equals_int (g_list_length (trackelements), 1);
fail_unless (GES_IS_VIDEO_URI_SOURCE (trackelements->data)
|| GES_IS_AUDIO_URI_SOURCE (trackelements->data));
g_list_free_full (trackelements, gst_object_unref);
}
g_list_free_full (tracks, gst_object_unref);
gst_object_unref (asset);
g_main_loop_quit (mainloop);
}
static void
write_screenshot_thread (GSimpleAsyncResult *result,
GObject *object,
GCancellable *cancellable)
{
cairo_status_t status;
GOutputStream *stream;
_screenshot_data *screenshot_data = g_async_result_get_user_data (G_ASYNC_RESULT (result));
g_assert (screenshot_data != NULL);
stream = prepare_write_stream (screenshot_data->filename,
&screenshot_data->filename_used);
if (stream == NULL)
status = CAIRO_STATUS_FILE_NOT_FOUND;
else
{
GdkPixbuf *pixbuf;
pixbuf = gdk_pixbuf_get_from_surface (screenshot_data->image,
0, 0,
cairo_image_surface_get_width (screenshot_data->image),
cairo_image_surface_get_height (screenshot_data->image));
if (gdk_pixbuf_save_to_stream (pixbuf, stream, "png", NULL, NULL,
"tEXt::Software", "gnome-screenshot", NULL))
status = CAIRO_STATUS_SUCCESS;
else
status = CAIRO_STATUS_WRITE_ERROR;
g_object_unref (pixbuf);
}
g_simple_async_result_set_op_res_gboolean (result, status == CAIRO_STATUS_SUCCESS);
g_clear_object (&stream);
}
/**
* tmp_picasaweb_upload_async:
*
* Temporary solution to provide asynchronous uploading and stop
* blocking the UI until gdata_picasaweb_service_upload_file_async()
* becomes available (bgo #600262). This method does the synchronous
* file upload, but is run asynchronously via
* g_simple_async_result_run_in_thread().
*
* This sets up a minimal #GDataPicasaWebFile entry, using the
* basename of the filepath for the file's title (which is not the
* caption, but might be something we would consider doing). The
* image file and the minimal entry are then uploaded to PicasaWeb's
* default album of "Drop Box". In the future, we might consider
* adding an Album Chooser to the Preferences/login window, but only
* if there's demand.
**/
static void
tmp_picasaweb_upload_async (GSimpleAsyncResult *result, GObject *source_object, GCancellable *cancellable)
{
GDataPicasaWebFile *new_file = NULL;
XviewerPostasaPlugin *plugin = XVIEWER_POSTASA_PLUGIN (source_object);
GDataPicasaWebService *service = plugin->priv->service;
GDataPicasaWebFile *file_entry;
PicasaWebUploadFileAsyncData *data;
#ifdef HAVE_LIBGDATA_0_8
GDataUploadStream *upload_stream;
GFileInputStream *in_stream;
GFileInfo *file_info;
#endif
gchar *filename;
GError *error = NULL;
data = (PicasaWebUploadFileAsyncData*)g_async_result_get_user_data (G_ASYNC_RESULT (result));
/* get filename to set image title */
file_entry = gdata_picasaweb_file_new (NULL);
filename = g_file_get_basename (data->imgfile);
gdata_entry_set_title (GDATA_ENTRY (file_entry), filename);
g_free (filename);
#ifdef HAVE_LIBGDATA_0_8
file_info = g_file_query_info (data->imgfile,
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE, cancellable,
&error);
if (file_info == NULL)
goto got_err;
upload_stream = gdata_picasaweb_service_upload_file (service,
NULL /* Upload to Dropbox */, file_entry,
g_file_info_get_display_name (file_info),
g_file_info_get_content_type (file_info),
cancellable, &error);
g_object_unref (file_info);
if (upload_stream == NULL)
goto got_err;
in_stream = g_file_read (data->imgfile, cancellable, &error);
if (in_stream == NULL) {
g_object_unref (upload_stream);
goto got_err;
}
if (g_output_stream_splice (G_OUTPUT_STREAM (upload_stream),
G_INPUT_STREAM (in_stream),
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
cancellable, &error) == -1)
{
g_object_unref (upload_stream);
g_object_unref (in_stream);
goto got_err;
}
new_file = gdata_picasaweb_service_finish_file_upload (service,
upload_stream,
&error);
g_object_unref (upload_stream);
g_object_unref (in_stream);
got_err:
/* Jump here if any GIO/GData call doesn't return successfully.
* Error handling happens below. */
#else
/* libgdata-0.6 */
new_file = gdata_picasaweb_service_upload_file (service,
NULL /* Uploading to Drop Box */,
file_entry, data->imgfile,
cancellable, &error);
#endif
g_object_unref (file_entry);
if (new_file == NULL || error) {
if (g_cancellable_is_cancelled (cancellable) == FALSE) {
g_simple_async_result_set_from_error (result, error);
}
/* Clear errors always as cancelling creates errors too */
g_clear_error (&error);
} else {
g_simple_async_result_set_op_res_gboolean (result, TRUE);
}
if (new_file != NULL)
g_object_unref (new_file);
}
