static void
peacock_file_load_async_open_cb (GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer data)
{
PeacockFile *file = PEACOCK_FILE (data);
#ifdef PEACOCK_FILE_DEBUG
g_warning ("peacock_file_load_async_open_cb(): Error opening file to read: %s.\n", gnome_vfs_result_to_string (result));
#endif
if (result != GNOME_VFS_OK) {
/*
* Display UI error dialog.
*/
gchar *err_msg = g_strdup_printf (_("Error opening file to load.\nReason - %s.\n"), gnome_vfs_result_to_string (result));
peacock_file_util_show_ui_error (err_msg);
g_free (err_msg);
/*
* Cleanup. Destructor peacock_file_finalize handles
* PeacockFile related memory.
*/
g_object_unref (file);
return;
} else {
gchar *buffer = g_malloc (PEACOCK_FILE_READ_WRITE_BUF_SIZE);
gtk_source_buffer_begin_not_undoable_action (GTK_SOURCE_BUFFER (file));
gnome_vfs_async_read (handle, buffer,
PEACOCK_FILE_READ_WRITE_BUF_SIZE,
peacock_file_load_async_read_cb, data);
}
}
/* Start reading a chunk. */
static void
test_read_file_read_chunk (GnomeVFSAsyncHandle *handle)
{
gnome_vfs_async_read (handle,
buffer,
10,
test_read_file_read_callback,
handle);
}
static void
peacock_file_load_async_read_cb (GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer buffer,
GnomeVFSFileSize bytes_requested,
GnomeVFSFileSize bytes_read,
gpointer data)
{
PeacockFile *file = PEACOCK_FILE (data);
#ifdef PEACOCK_FILE_DEBUG
g_warning ("peacock_file_load_async_read_cb (): %s\n", gnome_vfs_result_to_string (result));
#endif
if (result != GNOME_VFS_OK && result != GNOME_VFS_ERROR_EOF) {
/*
* Read error. We destroy our PeacockFile object. Not adding
* it to the MDI is handled by peacock_mdi_add_file () called
* by the close callback.
*/
g_free (buffer);
g_object_unref (data);
data = NULL;
gnome_vfs_async_close (handle, peacock_file_load_async_close_cb, data);
} else {
/*
* File has been loaded. Close up and go back.
*/
if (result == GNOME_VFS_ERROR_EOF) {
gnome_vfs_async_close (handle, peacock_file_load_async_close_cb, data);
return;
}
/*
* If we read bytes, append them to the buffer.
*/
if (bytes_read > 0) {
GtkTextIter iter;
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (file),
&iter);
gtk_text_buffer_insert (GTK_TEXT_BUFFER (file),
&iter, buffer, bytes_read);
}
gnome_vfs_async_read (handle, buffer,
PEACOCK_FILE_READ_WRITE_BUF_SIZE,
peacock_file_load_async_read_cb, data);
}
}
static void
text_read_callback (GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer buffer,
GnomeVFSFileSize bytes_requested,
GnomeVFSFileSize bytes_read,
gpointer cdata)
{
GtkTextIter iter;
GtkTextBuffer *text_buffer;
g_return_if_fail (buffer != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER(cdata));
text_buffer = GTK_TEXT_BUFFER(cdata);
if (result != GNOME_VFS_OK) {
gchar *message;
message = g_strdup_printf ("\n<<Error: %s>>", gnome_vfs_result_to_string (result));
g_return_if_fail (message != NULL);
gtk_text_buffer_set_text (text_buffer, message, -1);
g_free (message);
}
gtk_text_buffer_get_end_iter (text_buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (text_buffer, &iter, (gchar *)buffer, bytes_read, "default-tag", NULL);
if (bytes_requested == bytes_read)
gnome_vfs_async_read (handle, buffer, TEXT_BUFFER_SIZE, text_read_callback, cdata);
else {
g_free (buffer);
gnome_vfs_async_close (handle, text_close_callback, cdata);
}
}
static void
text_open_callback (GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer cdata)
{
gchar *buffer;
g_return_if_fail (GTK_IS_TEXT_BUFFER (cdata));
if (result != GNOME_VFS_OK) {
gchar *message;
message = g_strdup_printf ("Error: %s", gnome_vfs_result_to_string (result));
g_return_if_fail (message != NULL);
gtk_text_buffer_set_text (GTK_TEXT_BUFFER(cdata), message, -1);
g_free (message);
}
buffer = g_new (gchar, TEXT_BUFFER_SIZE);
g_return_if_fail (buffer != NULL);
gtk_text_buffer_create_tag (GTK_TEXT_BUFFER(cdata), "default-tag", "font", "terminal 10", NULL);
gnome_vfs_async_read (handle, buffer, TEXT_BUFFER_SIZE, text_read_callback, cdata);
}
/*--------------------------------------------------------------------------*/
static void
read_remote_file_callback( GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer buffer,
GnomeVFSFileSize bytes_requested,
GnomeVFSFileSize bytes_read,
gpointer callback_data )
{
DownloadCallbackData *data = (DownloadCallbackData *)callback_data;
GnomeVFSFileSize bytes_written;
gb_debug (DEBUG_UPDATE, "START");
if ( update_cancel_flag ) {
gnome_vfs_async_close( handle, close_remote_file_callback, data );
gb_debug (DEBUG_UPDATE, "END -- CANCEL");
return;
}
switch (result) {
case GNOME_VFS_OK:
if ( bytes_read > 0 ) {
data->total_bytes_read += bytes_read;
data->file_bytes_read += bytes_read;
update_progress_bar (GTK_PROGRESS_BAR(file_progress),
data->file_bytes_read,
data->file_bytes);
update_progress_bar (GTK_PROGRESS_BAR(total_progress),
data->total_bytes_read,
data->total_bytes);
gnome_vfs_write( data->local_handle,
buffer, bytes_read, &bytes_written );
if ( bytes_written != bytes_read ) {
g_warning( "Write failed: %d bytes written != %d bytes read",
(gint)bytes_written, (gint)bytes_read );
}
gnome_vfs_async_read( handle, data->buffer, data->buffer_length,
read_remote_file_callback, data );
}
else {
gnome_vfs_async_close( handle, close_remote_file_callback, data );
gb_debug (DEBUG_UPDATE, "0 length read");
}
break;
case GNOME_VFS_ERROR_EOF:
gb_debug (DEBUG_UPDATE, "EOF -- %" GNOME_VFS_OFFSET_FORMAT_STR,
bytes_read);
gnome_vfs_async_close( handle, close_remote_file_callback, data );
break;
default:
g_warning( "Read failed: %s", gnome_vfs_result_to_string(result) );
break;
}
gb_debug (DEBUG_UPDATE, "END");
}
/*--------------------------------------------------------------------------*/
static void open_remote_file_callback( GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer callback_data )
{
DownloadCallbackData *data = (DownloadCallbackData *)callback_data;
GnomeVFSFileInfo *info = (GnomeVFSFileInfo *)data->p->data;
gchar *local_path, *local_text_uri, *local_name;
GnomeVFSHandle *local_handle;
gchar *status_string;
GnomeVFSResult ret;
gb_debug (DEBUG_UPDATE, "START");
if ( update_cancel_flag ) {
gnome_vfs_async_close( handle, close_remote_file_callback, data );
gb_debug (DEBUG_UPDATE, "END -- CANCEL");
return;
}
switch (result) {
case GNOME_VFS_OK:
data->file_bytes_read = 0;
data->file_bytes = info->size;
status_string = g_strdup_printf( _("File: \"%s\" (%d of %d)"),
info->name, (data->i+1), data->n );
gtk_label_set_text( GTK_LABEL(file_label), status_string );
g_free( status_string );
update_progress_bar (GTK_PROGRESS_BAR(file_progress),
0,
data->file_bytes);
update_progress_bar (GTK_PROGRESS_BAR(total_progress),
data->total_bytes_read,
data->total_bytes);
local_name = hash_filename( info->name );
local_path = g_build_filename (gb_util_get_home_data_dir(),
local_name,
NULL);
local_text_uri = gnome_vfs_get_uri_from_local_path( local_path );
ret = gnome_vfs_create( &local_handle, local_text_uri,
GNOME_VFS_OPEN_WRITE, FALSE, 0664 );
if ( ret != GNOME_VFS_OK ) {
g_warning( "error opening local file %s, %s\n", local_path,
gnome_vfs_result_to_string(ret) );
}
else {
data->local_handle = local_handle;
gnome_vfs_async_read( handle, data->buffer, data->buffer_length,
read_remote_file_callback, data );
}
g_free( local_name );
g_free( local_path );
g_free( local_text_uri );
break;
default:
g_warning( "Open failed: %s.\n", gnome_vfs_result_to_string(result) );
break;
}
gb_debug (DEBUG_UPDATE, "END");
}
