/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

/*

 * GData Client

 * Copyright (C) Joe Cortes 2010 <escozzia@gmail.com>

 *

 * GData Client 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.

 *

 * GData Client 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 GData Client.  If not, see <http://www.gnu.org/licenses/>.

 */

/*

 * This is an extremely simple example program to query youtube videos

 * and picasa pictures and add them to a grid.

 * It was coded as part of the 2010 Google Code-In.

 * Click on Properties to change the window's title, or authenticate

 * yourself (it's assumed that your google and picasa ids are the same)

 * It's also possible to upload files to picasa.

 * Since this is only an example, intended to serve as documentation,

 * it's probably full of bugs and a couple of awful programming practices.

 * The program itself is of no practical use, but it does what it is

 * meant to do and doesn't segfault randomly (I hope so :p).

 */

#include "scrapbook.h"

static void

open_in_web_browser (GtkWidget *widget, gchar *uri) /* quicky wrapper for gtk_show_uri */

{

	gtk_show_uri_on_window (GTK_WINDOW (gtk_widget_get_toplevel (widget)), uri, GDK_CURRENT_TIME, NULL);

}

static void

picture_selected (GtkTreeView *tree, GtkTreePath *path, GtkTreeViewColumn *column, ScrapPicSearch *self)

{

	GtkTreeModel 	*model;

	GtkTreeIter		iter;

	GDataEntry		*pic;

	GdkPixbuf		*thumbnail;

	GtkWidget		*button;

	GtkWidget		*image;

	pic = g_slice_new				(GDataEntry);

	model = gtk_tree_view_get_model	(tree);

	gtk_tree_model_get_iter			(model, &iter, path);

	gtk_tree_model_get				(model, &iter, COL_PIXBUF, &(thumbnail), P_COL_PIC, &(pic), -1);

	gtk_widget_destroy				(self->search_data->window);

	gtk_list_store_append (self->main_data->lStore, &iter);

	gtk_list_store_set (self->main_data->lStore, &iter,

									 ORIG_COL_PIXBUF, 	thumbnail,

									 ORIG_COL_TITLE,	gdata_entry_get_title (pic),

									 ORIG_COL_ENTRY, 	pic, -1);

	if (self->main_data->currentRow[self->main_data->currentCol] > self->main_data->max_rows) {

		self->main_data->currentCol++;

		self->main_data->currentRow[self->main_data->currentCol] = 0;

	}

	image 	= gtk_image_new_from_pixbuf (thumbnail);

	button	= gtk_button_new			();

	self->file	= GDATA_PICASAWEB_FILE  (pic);

	gtk_widget_show 					(image);

	gtk_container_add 					(GTK_CONTAINER (button), image);

	/*g_signal_connect 					(button, "clicked", G_CALLBACK (open_in_web_browser), gdata_entry_get_id (pic));

	 * commented out, I can't seem to find anything that will give me a picture's URI */

	gtk_grid_attach (GTK_GRID (self->main_data->grid), button,

	                 self->main_data->currentCol,

	                 self->main_data->currentRow[self->main_data->currentCol],

	                 1, 1);

	gtk_widget_show (button);

	self->main_data->currentRow[self->main_data->currentCol]++;

}

static void

video_selected (GtkTreeView *tree, GtkTreePath *path, GtkTreeViewColumn *column, ScrapYTSearch *self)

{

	GtkTreeModel *model;

	GtkTreeIter  iter;

	GDataEntry   *video;

	GdkPixbuf	 *thumbnail;

	GtkWidget	 *button;

	GtkWidget	 *image;

	video = g_slice_new 			(GDataEntry);

	model = gtk_tree_view_get_model (tree);

	gtk_tree_model_get_iter 		(model, &iter, path);

	gtk_tree_model_get 				(model, &iter, COL_PIXBUF, &(thumbnail), COL_VIDEO, &(video), -1);

	gtk_widget_destroy 				(self->window);

	gtk_list_store_append (self->main_data->lStore, &iter);

	gtk_list_store_set (self->main_data->lStore, &iter,

									 ORIG_COL_PIXBUF, thumbnail,

									 ORIG_COL_TITLE, gdata_entry_get_title (video),

									 ORIG_COL_ENTRY, video, -1);

	if (self->main_data->currentRow[self->main_data->currentCol] > self->main_data->max_rows) {

		self->main_data->currentCol++;

		self->main_data->currentRow[self->main_data->currentCol] = 0;

	}

	image 	= gtk_image_new_from_pixbuf (thumbnail);

	button 	= gtk_button_new ();

	gtk_widget_show 	(image);

	gtk_container_add 	(GTK_CONTAINER (button), image);

	g_signal_connect (button, "clicked", G_CALLBACK (open_in_web_browser),

	                  (gpointer) gdata_youtube_video_get_player_uri (GDATA_YOUTUBE_VIDEO (video)));

	gtk_grid_attach (GTK_GRID (self->main_data->grid), button,

	                 self->main_data->currentCol,

	                 self->main_data->currentRow[self->main_data->currentCol],

	                 1, 1);

	gtk_widget_show (button);

	self->main_data->currentRow[self->main_data->currentCol]++;

}

static void

p_display_tree (ScrapPicSearch *self)

{

	GtkCellRenderer 	*renderer;

	GtkWidget			*scrollWin;

	scrollWin = gtk_scrolled_window_new 		(NULL, NULL);

	gtk_scrolled_window_set_policy 				(GTK_SCROLLED_WINDOW(scrollWin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);

	renderer = gtk_cell_renderer_pixbuf_new 	();

	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (self->tView), -1,

												 "", renderer, "pixbuf",

												 P_COL_PIXBUF, NULL);

	renderer = gtk_cell_renderer_text_new		();

	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (self->tView), -1,

												 "", renderer, "text",

												 P_COL_USER, NULL);

	renderer = gtk_cell_renderer_text_new		();

	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (self->tView), -1,

												 "", renderer, "text",

												 P_COL_TITLE, NULL);

	gtk_tree_view_set_model						(GTK_TREE_VIEW (self->tView), GTK_TREE_MODEL (self->lStore));

	gtk_container_add 							(GTK_CONTAINER (scrollWin), self->tView);

	g_signal_connect							(self->tView, "row-activated", G_CALLBACK (picture_selected), self);

	gtk_widget_show 							(self->tView);

	gtk_widget_show								(scrollWin);

	gtk_box_pack_start							(GTK_BOX(self->search_data->box1), scrollWin, TRUE, TRUE, 2);

}

static void

yt_display_tree (ScrapYTSearch *self)

{

	GtkCellRenderer 	*renderer;

	GtkWidget			*scrollWin;

	scrollWin = gtk_scrolled_window_new 		(NULL, NULL);

	gtk_scrolled_window_set_policy 				(GTK_SCROLLED_WINDOW(scrollWin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);

	renderer = gtk_cell_renderer_pixbuf_new 	();

	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (self->tView), -1,

												 "", renderer, "pixbuf",

												 COL_PIXBUF, NULL);

	renderer = gtk_cell_renderer_text_new		();

	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (self->tView), -1,

												 "", renderer, "text",

												 COL_TITLE, NULL);

	gtk_tree_view_set_model						(GTK_TREE_VIEW (self->tView), GTK_TREE_MODEL (self->lStore));

	gtk_container_add 							(GTK_CONTAINER (scrollWin), self->tView);

	g_signal_connect							(self->tView, "row-activated", G_CALLBACK (video_selected), self);

	gtk_widget_show 							(self->tView);

	gtk_widget_show								(scrollWin);

	gtk_box_pack_start							(GTK_BOX(self->box1), scrollWin, TRUE, TRUE, 2);

}

GDataMediaThumbnail *

choose_best_thumbnail (GList *thumbnails, gint ideal_size)

{

	gint delta = G_MININT;

	GDataMediaThumbnail *thumbnail = NULL;

	for (; thumbnails != NULL; thumbnails = thumbnails->next) {

		gint new_delta;

		GDataMediaThumbnail *current = (GDataMediaThumbnail *) thumbnails->data;

		new_delta = gdata_media_thumbnail_get_width (current) - ideal_size;

		if (delta == 0) {

			break;

		} else if ((delta == G_MININT)

		|| (delta < 0 && new_delta > delta)

		|| (delta > 0 && new_delta < delta)) {

			delta = new_delta;

			thumbnail = current;

		}

	}

	return thumbnail;

}

static void

find_pictures  (GDataEntry *entry, guint entry_key, guint entry_count, ScrapPicSearch *self)

{

	GtkTreeIter iter;

	GList 				*thumbnails;

	GDataMediaThumbnail	*thumbnail;

	GFileInputStream	*input_stream;

	gtk_list_store_append (self->lStore, &iter);

	gtk_list_store_set (self->lStore, &iter,

							 P_COL_PIXBUF, NULL,

							 P_COL_TITLE,  self->title,

							 P_COL_USER,   self->user,

							 P_COL_PIC,	   entry, -1);

	thumbnails		= gdata_picasaweb_file_get_thumbnails (GDATA_PICASAWEB_FILE (entry));

	thumbnail		= choose_best_thumbnail (thumbnails, THUMBNAIL_WIDTH);

	if (thumbnail != NULL) {

		GFile *thumbnail_file;

		thumbnail_file 	= g_file_new_for_uri 					(gdata_media_thumbnail_get_uri (thumbnail));

		input_stream   	= g_file_read							(thumbnail_file, NULL, NULL);

		self->thumbnail	= gdk_pixbuf_new_from_stream_at_scale 	(G_INPUT_STREAM (input_stream), THUMBNAIL_WIDTH, -1,

																 TRUE, NULL, NULL);

		gtk_list_store_set (self->lStore, &iter, P_COL_PIXBUF, self->thumbnail, -1); /* we can now set the thumbnail ;) */

		g_object_unref		(thumbnail_file);

	}

	gdata_query_set_q (self->query, NULL);

}

static void

p_query_element (GDataEntry *entry, guint entry_key, guint entry_count, ScrapPSearch *self)

{

	GError				*error=NULL;

	ScrapPicSearch		*picture;

	GDataFeed *feed;

	picture = self->pic;

	picture->title				= gdata_entry_get_title	(entry);

	picture->query 				= picture->search_data->query;

	picture->user				= self->user;

	gdata_query_set_q 					(picture->query, picture->title);

	feed = gdata_picasaweb_service_query_files (self->main_data->picasaweb_service, GDATA_PICASAWEB_ALBUM (entry), picture->query, NULL,

	                                            (GDataQueryProgressCallback) find_pictures, picture, &error);

	if (error != NULL) {

		g_print ("whoops, somebody raised an error!\n%s", error->message);

		g_error_free (error);

	}

	if (feed != NULL) {

		g_object_unref (feed);

	}

}

static void

p_text_callback (GtkWidget *widget, ScrapPSearch *self)

{

	GError *error 	= NULL;

	GDataFeed *feed;

	self->user		= gtk_entry_get_text 			(GTK_ENTRY (self->user_entry));

	self->pic->tView	= gtk_tree_view_new ();

	feed = gdata_picasaweb_service_query_all_albums (self->main_data->picasaweb_service, self->query, self->user, NULL,

	                                                 (GDataQueryProgressCallback) p_query_element, self, &error);

	if (error != NULL) {

		g_print ("someone raised an error\n%s\n",error->message);

		g_error_free (error);

	}

	if (feed != NULL) {

		g_object_unref (feed);

	}

	p_display_tree (self->pic);

}

/* ran as a callback for each individual element queried

 * it takes the video found, a unique entry_key and entry_count and the data structure as arguments

 * parts of this function were inspired (or simply taken) from the totem youtube plugin */

static void

yt_query_element (GDataEntry *entry, guint entry_key, guint entry_count, ScrapYTSearch *self)

{

	GtkTreeIter iter;

	GList 				*thumbnails;

	GDataMediaThumbnail *thumbnail;

	const gchar *title; /* the video's title */

	const gchar *uri; /* the video's URI */

	GFileInputStream	*input_stream; /* this will be used to make a pixbuf to store the thumbnail */

	title	= gdata_entry_get_title 				(entry); /* self-explanatory, I hope */

	uri		= gdata_youtube_video_get_player_uri	(GDATA_YOUTUBE_VIDEO (entry)); /* ditto */

	g_print ("%s %s", title, uri);

	gtk_list_store_append (self->lStore, &iter); /* make a new entry for this vid */

	gtk_list_store_set (self->lStore, &iter,

						   COL_PIXBUF, NULL, /* this will be set in a few moments */

						   COL_TITLE, title,

						   COL_VIDEO, entry,

						   -1);

	/* get a GList of thumbnails for the vid */

	thumbnails = gdata_youtube_video_get_thumbnails (GDATA_YOUTUBE_VIDEO (entry));

	thumbnail  = choose_best_thumbnail (thumbnails, THUMBNAIL_WIDTH);

	if (thumbnail != NULL) {

		GFile *thumbnail_file;

		thumbnail_file 	= g_file_new_for_uri 					(gdata_media_thumbnail_get_uri (thumbnail));

		input_stream   	= g_file_read							(thumbnail_file, NULL, NULL);

		self->thumbnail	= gdk_pixbuf_new_from_stream_at_scale 	(G_INPUT_STREAM (input_stream), THUMBNAIL_WIDTH, -1,

																 TRUE, NULL, NULL);

		gtk_list_store_set (self->lStore, &iter, COL_PIXBUF, self->thumbnail, -1); /* we can now set the thumbnail ;) */

		g_object_unref		(thumbnail_file);

	}

}

static void

yt_text_callback (GtkWidget *widget, ScrapYTSearch *self)

{

	GDataFeed *feed;

	self->txt = gtk_entry_get_text (GTK_ENTRY (self->txt_entry));

	gdata_query_set_q	 				(self->query, self->txt);	/* set the string we'll be searching for in youtube */

	/* do the actual query, running yt_query_element for each object found */

	feed = gdata_youtube_service_query_videos (self->main_data->youtube_service, self->query, NULL, (GDataQueryProgressCallback) yt_query_element,

	                                           self, NULL);

	if (feed != NULL) {

		g_object_unref (feed);

	}

	yt_display_tree (self); /* run yt_display_tree to show the results */

}

static void

start_new_picasa_search (GtkWidget *widget, ScrapData *first)

{

	ScrapPSearch 				*self;

	ScrapPicSearch				*picture;

	GtkWidget *button, *box2;

	self = first->p_search;

	picture 					= first->pic_search;

	picture->search_data 		= self;

	picture->search_data->pic	= picture;

	picture->main_data			= self->main_data;

	g_assert (GDATA_IS_PICASAWEB_SERVICE (first->picasaweb_service));

	gtk_list_store_clear (self->pic->lStore);

	self->window = gtk_window_new 	(GTK_WINDOW_TOPLEVEL);

	gtk_window_resize				(GTK_WINDOW (self->window), 400, 400);

	g_signal_connect 				(self->window, "destroy", G_CALLBACK (gtk_widget_destroy), NULL);

	g_signal_connect_swapped 		(self->window, "delete-event", G_CALLBACK (gtk_widget_destroy), NULL);

	/* our two boxes */

	self->box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); /* this box contains everything in our window */

	gtk_container_add 				(GTK_CONTAINER (self->window), self->box1);

	box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);

	/* search bar */

	self->user_entry = gtk_entry_new ();

	gtk_entry_set_text 				(GTK_ENTRY (self->user_entry), "User to search for");

	g_signal_connect (self->user_entry, "activate", (GCallback) p_text_callback, self);

	gtk_box_pack_start (GTK_BOX(box2), self->user_entry, TRUE, TRUE, 0);

	gtk_widget_show    				(self->user_entry);

	/* Search button */

	button = gtk_button_new_with_mnemonic ("_Search");

	g_signal_connect (button, "clicked", (GCallback) p_text_callback, self);

	gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);

	gtk_widget_show (button);

	gtk_box_pack_end (GTK_BOX (self->box1), box2, FALSE, FALSE, 0); /* pack the box with the button and search bar */

	gtk_widget_show (box2);

	gtk_widget_show (self->box1);

	gtk_widget_show (self->window);

}

static void

start_new_youtube_search (GtkWidget *widget, ScrapData *first) /* *first is a pointer we use to talk to the main window */

{

	ScrapYTSearch *self; /* this struct will be used for all the data in the search, if there's time I'll make it into a GObject */

	GtkWidget *button, *box2;

	self = first->yt_search;

	gtk_list_store_clear 				(self->lStore); /* clear it out */

	self->tView  = gtk_tree_view_new 	();

	/* window stuff */

	self->window = gtk_window_new	(GTK_WINDOW_TOPLEVEL);

	gtk_window_resize				(GTK_WINDOW (self->window), 400, 400);

	g_signal_connect 				(self->window, "destroy", G_CALLBACK (gtk_widget_destroy), NULL);

	g_signal_connect_swapped 		(self->window, "delete-event", G_CALLBACK (gtk_widget_destroy), NULL);

	/* our two boxes */

	self->box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); /* this box contains everything in our window */

	gtk_container_add 				(GTK_CONTAINER (self->window), self->box1);

	box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);

	/* search bar */

	self->txt_entry = gtk_entry_new ();

	g_signal_connect 				(self->txt_entry, "activate", G_CALLBACK (yt_text_callback), self);

	gtk_box_pack_start (GTK_BOX (box2), self->txt_entry, TRUE, TRUE, 0);

	gtk_widget_show    				(self->txt_entry);

	/* Search button */

	button = gtk_button_new_with_mnemonic ("_Search");

	g_signal_connect (button, "clicked", (GCallback) yt_text_callback, self);

	gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

	gtk_widget_show (button);

	gtk_box_pack_end (GTK_BOX (self->box1), box2, FALSE, FALSE, 0); /* pack the box with the button and search bar */

	gtk_widget_show (box2);

	gtk_widget_show (self->box1);

	gtk_widget_show (self->window);

	/* everything else is implemented somewhere else */

}

static void

properties_set (GtkWidget *widget, ScrapProps *self)

{

	GDataClientLoginAuthorizer *authorizer;

	GList *domains = NULL; /* list of GDataAuthorizationDomains */

	GError *error = NULL;

	/* Get the username and password to use */

	self->main_data->username = g_strdup (gtk_entry_get_text (GTK_ENTRY (self->username_entry)));

	self->main_data->password = g_strdup (gtk_entry_get_text (GTK_ENTRY (self->password_entry)));

	/* Domains we need to be authorised for */

	domains = g_list_prepend (domains, gdata_youtube_service_get_primary_authorization_domain ());

	domains = g_list_prepend (domains, gdata_picasaweb_service_get_primary_authorization_domain ());

	/* Authenticate */

	authorizer = gdata_client_login_authorizer_new_for_authorization_domains (CLIENT_ID, domains);

	gdata_client_login_authorizer_authenticate (authorizer, self->main_data->username, self->main_data->password, NULL, &error);

	if (error != NULL) { /* we show this to the user in case they mistyped their password */

		GtkWidget *label;

		label = gtk_label_new (error->message);

		gtk_widget_show (label);

		gtk_box_pack_end (GTK_BOX (self->box1), label, FALSE, FALSE, 0);

		g_print ("error\n%s\n", error->message);

		g_error_free (error);

	}

	gdata_service_set_authorizer (GDATA_SERVICE (self->main_data->youtube_service), GDATA_AUTHORIZER (authorizer));

	gdata_service_set_authorizer (GDATA_SERVICE (self->main_data->picasaweb_service), GDATA_AUTHORIZER (authorizer));

	gtk_widget_destroy (self->window);

	g_object_unref (authorizer);

}

static void

properties_show (GtkWidget *widget, ScrapData *first)

{

	ScrapProps	*self;

	GtkWidget *label, *button, *box2;

	self			= g_slice_new (struct _ScrapProps);

	self->main_data	= first;

	self->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

	g_signal_connect (self->window, "destroy", G_CALLBACK (gtk_widget_destroy), NULL);

	g_signal_connect (self->window, "delete-event", G_CALLBACK (gtk_widget_destroy), NULL);

	self->box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);

	/* Username/Password labels box */

	box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);

	label = gtk_label_new ("Username");

	gtk_widget_show (label);

	gtk_box_pack_start (GTK_BOX (box2), label, TRUE, TRUE, 0);

	label = gtk_label_new ("Password");

	gtk_widget_show (label);

	gtk_box_pack_start (GTK_BOX (box2), label, TRUE, TRUE, 0);

	gtk_widget_show (box2);

	gtk_box_pack_start (GTK_BOX (self->box1), box2, FALSE, FALSE, 0);

	/* Username/Password entries box */

	box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);

	self->username_entry = gtk_entry_new ();

	if (self->main_data->username != NULL)

		gtk_entry_set_text (GTK_ENTRY(self->username_entry), self->main_data->username);

	gtk_widget_show	   (self->username_entry);

	gtk_box_pack_start (GTK_BOX (box2), self->username_entry, TRUE, TRUE, 0);

	self->password_entry = gtk_entry_new ();

	gtk_entry_set_visibility (GTK_ENTRY (self->password_entry), FALSE);

	if (self->main_data->password != NULL)

		gtk_entry_set_text (GTK_ENTRY(self->password_entry), self->main_data->password);

	gtk_widget_show	   (self->password_entry);

	gtk_box_pack_start (GTK_BOX (box2), self->password_entry, TRUE, TRUE, 0);

	gtk_box_pack_start (GTK_BOX (self->box1), box2, FALSE, FALSE, 0);

	gtk_widget_show (box2);

	/* OK button */

	button = gtk_button_new_with_label ("_OK");

	g_signal_connect (button, "clicked", (GCallback) properties_set, self);

	gtk_widget_show (button);

	gtk_box_pack_start (GTK_BOX (self->box1), button, FALSE, FALSE, 0);

	gtk_widget_show		(self->box1);

	gtk_container_add	(GTK_CONTAINER (self->window), self->box1);

	gtk_widget_show		(self->window);

}

static void

select_file (ScrapPUpload *self, GtkFileChooser *file_chooser)

{

	GFile *file;

	GError *error = NULL;

	GFileInfo *file_info;

	GDataUploadStream *upload_stream;

	GFileInputStream *file_stream;

	file = gtk_file_chooser_get_file (file_chooser);

	file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,

	                               G_FILE_QUERY_INFO_NONE, NULL, NULL);

	/* upload our file, using the service we've set up, and metadata

	 * set up in upload ()

	 * no album is specified, but that should be easy to add */

	upload_stream = gdata_picasaweb_service_upload_file (self->main_data->picasaweb_service, NULL /* for now uploading to drop box */,

	                                                     self->file, g_file_info_get_display_name (file_info),

	                                                     g_file_info_get_content_type (file_info), NULL, &error);

	g_object_unref (file_info);

	g_object_unref (self->file);

	self->file = NULL;

	if (error != NULL) {

		g_print ("Error: %s\n", error->message);

		g_error_free (error);

		g_object_unref (file);

		return;

	}

	file_stream = g_file_read (file, NULL, NULL);

	g_object_unref (file);

	g_output_stream_splice (G_OUTPUT_STREAM (upload_stream), G_INPUT_STREAM (file_stream),

	                        G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, NULL);

	self->file = gdata_picasaweb_service_finish_file_upload (self->main_data->picasaweb_service, upload_stream, NULL);

	g_object_unref (file_stream);

	g_object_unref (upload_stream);

}

static void

got_name (GtkWidget *widget, ScrapData *scrap_data)

{

	ScrapPUpload *self;

	GtkWidget *file_dialog;

	self = scrap_data->p_upload;

	gdata_entry_set_title 	(GDATA_ENTRY (self->file),

							 gtk_entry_get_text (GTK_ENTRY (self->name)));

	gdata_entry_set_summary	(GDATA_ENTRY (self->file),

							 gtk_entry_get_text (GTK_ENTRY (self->description)));

	gtk_widget_destroy 	(self->dialog);

	file_dialog = gtk_file_chooser_dialog_new ("Upload Photo", GTK_WINDOW (scrap_data->window), GTK_FILE_CHOOSER_ACTION_SAVE,

	                                           "_Cancel", GTK_RESPONSE_CANCEL,

	                                           "_Open", GTK_RESPONSE_ACCEPT,

	                                           NULL);

	if (gtk_dialog_run (GTK_DIALOG (file_dialog)) == GTK_RESPONSE_ACCEPT) {

		select_file (self, GTK_FILE_CHOOSER (file_dialog));

	}

	/* since the upload blocks, it's safe to assume the widget won't

	 * be destroyed until we're done */

	gtk_widget_destroy (file_dialog);

}

static void

upload (GtkWidget *widget, ScrapData *first)

{

	ScrapPUpload 	*self;

	GtkWidget *label, *content_area;

	label = gtk_label_new ("Enter photo name and description");

	self = first->p_upload;

	/* we make a new file, without an id (it will be assigned automatically later on) */

	self->file  = gdata_picasaweb_file_new (NULL);

	/* dialog to get the file's name and description */

	self->dialog = gtk_dialog_new();

	content_area = gtk_dialog_get_content_area (GTK_DIALOG (self->dialog));

	gtk_widget_show (label);

	gtk_box_pack_start (GTK_BOX (content_area), label, FALSE, FALSE, 0);

	self->name	= gtk_entry_new ();

	g_signal_connect 	(self->name, "activate", G_CALLBACK (got_name), self);

	gtk_widget_show  	(self->name);

	gtk_box_pack_start (GTK_BOX (content_area), self->name, TRUE, TRUE, 0);

	self->description = gtk_entry_new ();

	g_signal_connect 	(self->description, "activate", G_CALLBACK (got_name), first);

	gtk_widget_show  	(self->description);

	gtk_box_pack_start (GTK_BOX (content_area), self->description, TRUE, TRUE, 0);

	gtk_widget_show		(self->dialog);

}

int

main(int argc, char **argv)

{

	ScrapData 		*scrapbook;

	ScrapPSearch 	*picasaSearch;

	ScrapYTSearch	*youtubeSearch;

	ScrapPicSearch	*photoSearch;

	ScrapPUpload	*fUpload;

	GtkWidget *button;

	GtkWidget *vbox;

	scrapbook = g_slice_new (struct _ScrapData);

	scrapbook->max_rows			= 5;

	gtk_init	(&argc, &argv);

	scrapbook->currentCol 							= 0;

	scrapbook->currentRow[scrapbook->currentCol]	= 0;

	scrapbook->lStore   = gtk_list_store_new (ORIG_N_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, GDATA_TYPE_ENTRY);

	scrapbook->window 	= gtk_window_new 	(GTK_WINDOW_TOPLEVEL);

	gtk_window_set_title (GTK_WINDOW (scrapbook->window), "Scrapbook");

	g_signal_connect (scrapbook->window, "destroy", G_CALLBACK (gtk_main_quit), NULL);

	g_signal_connect (scrapbook->window, "delete-event", G_CALLBACK (gtk_main_quit), NULL);

	youtubeSearch 				= g_slice_new (struct _ScrapYTSearch); /* get some memory for the structure */

	youtubeSearch->txt	 		= NULL;

	scrapbook->yt_search 		= youtubeSearch;

	youtubeSearch->main_data 	= scrapbook;

	/* create a new query, without any search text, starting at 0, and search only MAX_RESULTS results */

	youtubeSearch->query = gdata_query_new_with_limits (NULL, 0, MAX_RESULTS);

	/* create a new youtube service, giving it our developer key; google no longer uses client ids so we send in an empty string (NULL gives an error) */

	scrapbook->youtube_service = gdata_youtube_service_new (DEVELOPER_KEY, NULL);

	/* create a new list store and tree to show the user the results

	 * it has three columns (two of which are displayed): a pixbuf for the thumbnail, the title, and the video data itself (as a gdata generic entry) */

	youtubeSearch->lStore = gtk_list_store_new 	(N_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, GDATA_TYPE_ENTRY);

	picasaSearch 				= g_slice_new (struct _ScrapPSearch);

	scrapbook->p_search 		= picasaSearch;

	picasaSearch->main_data 	= scrapbook;

	picasaSearch->query 		= gdata_query_new_with_limits (NULL, 0, MAX_RESULTS);

	scrapbook->picasaweb_service = gdata_picasaweb_service_new (NULL);

	photoSearch					= g_slice_new (struct _ScrapPicSearch);

	scrapbook->p_search->pic	= photoSearch;

	scrapbook->pic_search		= photoSearch;

	photoSearch->lStore = gtk_list_store_new (P_N_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, GDATA_TYPE_ENTRY);

	fUpload						= g_slice_new (struct _ScrapPUpload);

	scrapbook->p_upload			= fUpload;

	fUpload->main_data			= scrapbook;

	scrapbook->box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

	scrapbook->grid = gtk_grid_new ();

	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);

	/* Add buttons to the main window */

	button = gtk_button_new_with_mnemonic ("Add YouTube _Video");

	g_signal_connect (button, "clicked", (GCallback) start_new_youtube_search, scrapbook);

	gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

	gtk_widget_show (button);

	button = gtk_button_new_with_mnemonic ("Add PicasaWeb _Photo");

	g_signal_connect (button, "clicked", (GCallback) start_new_picasa_search, scrapbook);

	gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

	gtk_widget_show (button);

	button = gtk_button_new_with_mnemonic ("P_roperties");

	g_signal_connect (button, "clicked", (GCallback) properties_show, scrapbook);

	gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

	gtk_widget_show (button);

	button = gtk_button_new_with_mnemonic ("_Upload Photo to PicasaWeb");

	g_signal_connect (button, "clicked", (GCallback) upload, scrapbook);

	gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

	gtk_widget_show (button);

	gtk_widget_show (vbox);

	gtk_box_pack_start (GTK_BOX (scrapbook->box1), vbox, FALSE, FALSE, 5);

	gtk_box_pack_start (GTK_BOX (scrapbook->box1), scrapbook->grid, TRUE, TRUE, 0);

	gtk_widget_show (scrapbook->grid);

	gtk_widget_show		(scrapbook->box1);

	gtk_container_add	(GTK_CONTAINER (scrapbook->window), scrapbook->box1);

	gtk_widget_show		(scrapbook->window);

	gtk_main			();

	return 0;

}