evolution/shell/e-shell-offline-handler.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* e-shell-offline-handler.c
 *
 * Copyright (C) 2001  Ximian, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Author: Ettore Perazzoli <ettore@ximian.com>
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#undef G_DISABLE_DEPRECATED	/* FIXME */
#undef GTK_DISABLE_DEPRECATED	/* FIXME */

#include "e-shell-offline-handler.h"

#include "e-shell-marshal.h"

#include <gtk/gtkcellrenderertext.h>
#include <gtk/gtkclist.h>
#include <gtk/gtkdialog.h>
#include <gtk/gtklabel.h>
#include <gtk/gtksignal.h>
#include <gtk/gtkliststore.h>
#include <gtk/gtktreeview.h>
#include <gtk/gtktypeutils.h>
#include <gtk/gtkwidget.h>

#include <libgnome/gnome-i18n.h>

#include <glade/glade-xml.h>

#include <bonobo/bonobo-main.h>
#include <bonobo/bonobo-exception.h>


#define GLADE_DIALOG_FILE_NAME EVOLUTION_GLADEDIR "/e-active-connection-dialog.glade"


/* Private part.  */

struct _OfflineProgressListenerServant {
	POA_GNOME_Evolution_OfflineProgressListener servant;
	EShellOfflineHandler *offline_handler;
	char *component_id;
};
typedef struct _OfflineProgressListenerServant OfflineProgressListenerServant;

struct _ComponentInfo {
	/* Component ID.  */
	char *id;

	/* The `Evolution::Offline' interface for this component (cached just
	   to avoid going through the EComponentRegistry all the time).  */
	GNOME_Evolution_Offline offline_interface;

	/* The interface and servant for the
 	   `Evolution::OfflineProgressListener' we have to implement to get
 	   notifications about progress of the off-line process.  */
	GNOME_Evolution_OfflineProgressListener progress_listener_interface;
	OfflineProgressListenerServant *progress_listener_servant;

	/* The current active connections for this component.  This is updated
	   by the component itself through the `::ProgressListener' interface;
	   when the count reaches zero, the off-line process is considered to
	   be complete.  */
	GNOME_Evolution_ConnectionList *active_connection_list;
};
typedef struct _ComponentInfo ComponentInfo;

struct _EShellOfflineHandlerPrivate {
	EShell *shell;

	int num_total_connections;
	GHashTable *id_to_component_info;

	int procedure_in_progress : 1;
	int finished : 1;
};


/* Signals.   */

enum {
	OFFLINE_PROCEDURE_STARTED,
	OFFLINE_PROCEDURE_FINISHED,
	LAST_SIGNAL
};

static guint signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE (EShellOfflineHandler, e_shell_offline_handler, GTK_TYPE_OBJECT)

/* Forward declarations for the dialog handling.  */

static void update_dialog_clist (EShellOfflineHandler *offline_handler);


/* Implementation for the OfflineProgressListener interface.  */

static PortableServer_ServantBase__epv OfflineProgressListener_base_epv;
static POA_GNOME_Evolution_OfflineProgressListener__epv OfflineProgressListener_epv;
static POA_GNOME_Evolution_OfflineProgressListener__vepv OfflineProgressListener_vepv;

static OfflineProgressListenerServant *
progress_listener_servant_new (EShellOfflineHandler *offline_handler,
			       const char *id)
{
	OfflineProgressListenerServant *servant;

	servant = g_new0 (OfflineProgressListenerServant, 1);

	servant->servant.vepv    = &OfflineProgressListener_vepv;
	servant->offline_handler = offline_handler;
	servant->component_id    = g_strdup (id);

	return servant;
}

static void
progress_listener_servant_free (OfflineProgressListenerServant *servant)
{
	CORBA_Environment ev;
	PortableServer_ObjectId *oid;

	CORBA_exception_init (&ev);

	oid = PortableServer_POA_servant_to_id (bonobo_poa (), servant, &ev);
	PortableServer_POA_deactivate_object (bonobo_poa (), oid, &ev);
	CORBA_free (oid);

	CORBA_exception_free (&ev);

	g_free (servant->component_id);
	g_free (servant);
}

static GNOME_Evolution_ConnectionList *
duplicate_connection_list (const GNOME_Evolution_ConnectionList *source)
{
	GNOME_Evolution_ConnectionList *copy;
	int i;

	copy = GNOME_Evolution_ConnectionList__alloc ();

	copy->_length  = source->_length;
	copy->_maximum = source->_length;

	copy->_buffer  = CORBA_sequence_GNOME_Evolution_Connection_allocbuf (copy->_maximum);

	for (i = 0; i < source->_length; i++) {
		copy->_buffer[i].hostName = CORBA_string_dup (source->_buffer[i].hostName);
		copy->_buffer[i].type     = CORBA_string_dup (source->_buffer[i].type);
	}

	CORBA_sequence_set_release (copy, TRUE);

	return copy;
}

static void
impl_OfflineProgressListener_updateProgress (PortableServer_Servant servant,
					     const GNOME_Evolution_ConnectionList *current_active_connections,
					     CORBA_Environment *ev)
{
	EShellOfflineHandler *offline_handler;
	EShellOfflineHandlerPrivate *priv;
	ComponentInfo *component_info;
	int connection_delta;
	const char *component_id;

	component_id = ((OfflineProgressListenerServant *) servant)->component_id;

	offline_handler = ((OfflineProgressListenerServant *) servant)->offline_handler;
	priv = offline_handler->priv;

	component_info = g_hash_table_lookup (priv->id_to_component_info, component_id);
	g_assert (component_info != NULL);

	connection_delta = component_info->active_connection_list->_length - current_active_connections->_length;
	if (connection_delta < 0) {
		/* FIXME: Should raise an exception or something?  */
		g_warning ("Weird, buggy component increased number of connection when going off-line -- %s",
			   component_id);
	}

	g_assert (priv->num_total_connections >= connection_delta);
	priv->num_total_connections -= connection_delta;

	CORBA_free (component_info->active_connection_list);
	component_info->active_connection_list = duplicate_connection_list (current_active_connections);

	if (priv->num_total_connections == 0 && ! priv->finished) {
		priv->finished = TRUE;
		g_signal_emit (offline_handler, signals[OFFLINE_PROCEDURE_FINISHED], 0, TRUE);
	}
}

static gboolean
create_progress_listener (EShellOfflineHandler *offline_handler,
			  const char *component_id,
			  GNOME_Evolution_OfflineProgressListener *objref_return,
			  OfflineProgressListenerServant **servant_return)
{
	OfflineProgressListenerServant *servant;
	CORBA_Environment ev;

	*servant_return = NULL;
	*objref_return  = CORBA_OBJECT_NIL;

	OfflineProgressListener_base_epv._private    = NULL;
	OfflineProgressListener_base_epv.finalize    = NULL;
	OfflineProgressListener_base_epv.default_POA = NULL;

	OfflineProgressListener_epv.updateProgress = impl_OfflineProgressListener_updateProgress;

	OfflineProgressListener_vepv._base_epv                                   = &OfflineProgressListener_base_epv;
	OfflineProgressListener_vepv.GNOME_Evolution_OfflineProgressListener_epv = &OfflineProgressListener_epv;

	servant = progress_listener_servant_new (offline_handler, component_id);

	CORBA_exception_init (&ev);

	POA_GNOME_Evolution_OfflineProgressListener__init ((PortableServer_Servant) servant, &ev);
	if (ev._major != CORBA_NO_EXCEPTION) {
		g_warning ("Cannot initialize GNOME::Evolution::Offline::ProgressListener");
		progress_listener_servant_free (servant);
		CORBA_exception_free (&ev);
		return FALSE;
	}

	CORBA_free (PortableServer_POA_activate_object (bonobo_poa (), servant, &ev));

	if (ev._major != CORBA_NO_EXCEPTION) {
		g_warning ("Cannot activate GNOME::Evolution::Offline::ProgressListener");
		progress_listener_servant_free (servant);
		CORBA_exception_free (&ev);
		return FALSE;
	}

	*servant_return = servant;
	*objref_return  = PortableServer_POA_servant_to_reference (bonobo_poa (), servant, &ev);

	CORBA_exception_free (&ev);

	return TRUE;
}


/* ComponentInfo handling.  */

static ComponentInfo *
component_info_new (const char *id,
		    const GNOME_Evolution_Offline offline_interface,
		    GNOME_Evolution_OfflineProgressListener progress_listener_interface,
		    OfflineProgressListenerServant *progress_listener_servant,
		    GNOME_Evolution_ConnectionList *active_connection_list)
{
	ComponentInfo *new;
	CORBA_Environment ev;

	CORBA_exception_init (&ev);

	new = g_new (ComponentInfo, 1);
	new->id                          = g_strdup (id);
	new->offline_interface           = CORBA_Object_duplicate (offline_interface, &ev);
	new->progress_listener_interface = progress_listener_interface;
	new->progress_listener_servant   = progress_listener_servant;
	new->active_connection_list      = active_connection_list;

	CORBA_exception_free (&ev);

	return new;
}

static void
component_info_free (ComponentInfo *component_info)
{
	CORBA_Environment ev;

	CORBA_exception_init (&ev);

	g_free (component_info->id);

	progress_listener_servant_free (component_info->progress_listener_servant);
	CORBA_Object_release (component_info->progress_listener_interface, &ev);

	CORBA_Object_release (component_info->offline_interface, &ev);

	CORBA_free (component_info->active_connection_list);

	g_free (component_info);

	CORBA_exception_free (&ev);
}


/* Utility functions.  */

static void
hash_foreach_free_component_info (void *key,
				   void *value,
				   void *user_data)
{
	ComponentInfo *component_info;

	component_info = (ComponentInfo *) value;
	component_info_free (component_info);
}


static GNOME_Evolution_Offline
get_offline_interface (GNOME_Evolution_Component objref)
{
	GNOME_Evolution_Offline interface;
	CORBA_Environment ev;

	CORBA_exception_init (&ev);

	interface = Bonobo_Unknown_queryInterface (objref, "IDL:GNOME/Evolution/Offline:1.0", &ev);

	if (ev._major != CORBA_NO_EXCEPTION)
		interface = CORBA_OBJECT_NIL;

	CORBA_exception_free (&ev);
	return interface;
}


/* Cancelling the off-line procedure.  */

static void
cancel_offline (EShellOfflineHandler *offline_handler)
{
	EShellOfflineHandlerPrivate *priv;
	EComponentRegistry *component_registry;
	GSList *component_infos;
	GSList *p;

	priv = offline_handler->priv;

	component_registry = e_shell_peek_component_registry (priv->shell);
	component_infos = e_component_registry_peek_list (component_registry);

	for (p = component_infos; p != NULL; p = p->next) {
		EComponentInfo *info = p->data;
		GNOME_Evolution_Offline offline_interface;
		CORBA_Environment ev;

		offline_interface = get_offline_interface (info->iface);
		if (offline_interface == CORBA_OBJECT_NIL)
			continue;

		CORBA_exception_init (&ev);

		GNOME_Evolution_Offline_goOnline (offline_interface, &ev);
		if (ev._major != CORBA_NO_EXCEPTION)
 			g_warning ("Error putting component `%s' on-line.", info->id);

		CORBA_exception_free (&ev);
	}

	priv->num_total_connections = 0;

	if (! priv->finished) {
		priv->finished = TRUE;
		g_signal_emit (offline_handler, signals[OFFLINE_PROCEDURE_FINISHED], 0, FALSE);
	}
}


/* Preparing the off-line procedure.  */

static gboolean
prepare_for_offline (EShellOfflineHandler *offline_handler)
{
	EComponentRegistry *component_registry;
	EShellOfflineHandlerPrivate *priv;
	GSList *component_infos;
	GSList *p;
	gboolean error;

	priv = offline_handler->priv;
	component_registry = e_shell_peek_component_registry (priv->shell);
	component_infos = e_component_registry_peek_list (component_registry);

	error = FALSE;
	for (p = component_infos; p != NULL; p = p->next) {
		EComponentInfo *info = p->data;
		GNOME_Evolution_Offline offline_interface;
		GNOME_Evolution_OfflineProgressListener progress_listener_interface;
		GNOME_Evolution_ConnectionList *active_connection_list;
		OfflineProgressListenerServant *progress_listener_servant;
		ComponentInfo *component_info;
		CORBA_Environment ev;

		offline_interface = get_offline_interface (info->iface);
		if (offline_interface == CORBA_OBJECT_NIL)
			continue;

		if (! create_progress_listener (offline_handler, info->id,
						&progress_listener_interface,
						&progress_listener_servant)) {
			g_warning ("Cannot create the Evolution::OfflineProgressListener interface for `%s'", info->id);
			continue;
		}

		CORBA_exception_init (&ev);

		GNOME_Evolution_Offline_prepareForOffline (offline_interface, &active_connection_list, &ev);
		if (ev._major != CORBA_NO_EXCEPTION) {
			g_warning ("Cannot prepare component component to go offline -- %s [%s]",
				   info->id, BONOBO_EX_REPOID (&ev));

			progress_listener_servant_free (progress_listener_servant);
			
			CORBA_Object_release (progress_listener_interface, &ev);

			CORBA_exception_free (&ev);

			error = TRUE;
			break;
		}

		CORBA_exception_free (&ev);

		priv->num_total_connections += active_connection_list->_length;

		component_info = component_info_new (info->id,
						     offline_interface,
						     progress_listener_interface,
						     progress_listener_servant,
						     active_connection_list);

		g_assert (g_hash_table_lookup (priv->id_to_component_info, component_info->id) == NULL);
		g_hash_table_insert (priv->id_to_component_info, component_info->id, component_info);
	}

	/* If an error occurred while preparing, just put all the components
	   on-line again.  */
	if (error)
		cancel_offline (offline_handler);

	return ! error;
}


/* Finalizing the off-line procedure.  */

static void
finalize_offline_hash_foreach (void *key,
			       void *value,
			       void *user_data)
{
	EShellOfflineHandler *offline_handler;
	EShellOfflineHandlerPrivate *priv;
	ComponentInfo *component_info;
	CORBA_Environment ev;

	offline_handler = E_SHELL_OFFLINE_HANDLER (user_data);
	priv = offline_handler->priv;

	component_info = (ComponentInfo *) value;

	CORBA_exception_init (&ev);

	GNOME_Evolution_Offline_goOffline (component_info->offline_interface,
					   component_info->progress_listener_interface,
					   &ev);

	if (ev._major != CORBA_NO_EXCEPTION) {
		/* FIXME: Should detect an error and put all the components
		   on-line again.  */
		g_warning ("Error putting component off-line -- %s", component_info->id);
	}

	CORBA_exception_free (&ev);
}

static void
finalize_offline (EShellOfflineHandler *offline_handler)
{
	EShellOfflineHandlerPrivate *priv;

	priv = offline_handler->priv;

	g_object_ref (offline_handler);

	g_hash_table_foreach (priv->id_to_component_info, finalize_offline_hash_foreach, offline_handler);

	if (priv->num_total_connections == 0 && ! priv->finished) {
		/* Nothing else to do, we are all set.  */
		priv->finished = TRUE;
		g_signal_emit (offline_handler, signals[OFFLINE_PROCEDURE_FINISHED], 0, TRUE);
	}

	g_object_unref (offline_handler);
}


/* The confirmation dialog.  */

static void
update_dialog_tree_view_hash_foreach (void *key,
				      void *data,
				      void *user_data)
{
	ComponentInfo *component_info;
	const GNOME_Evolution_Connection *p;
	GtkTreeModel *model = GTK_TREE_MODEL (user_data);
	int i;

	component_info = (ComponentInfo *) data;
	for (i = 0, p = component_info->active_connection_list->_buffer;
	     i < component_info->active_connection_list->_length;
	     i++, p++) {
		GtkTreeIter iter;
		char *host = g_strdup_printf ("%s (%s)", p->hostName, p->type);

		gtk_list_store_prepend (GTK_LIST_STORE (model), &iter);
		gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, host, -1);
	}
}

/* GObject methods.  */

static void
impl_dispose (GObject *object)
{
	EShellOfflineHandler *offline_handler;
	EShellOfflineHandlerPrivate *priv;

	offline_handler = E_SHELL_OFFLINE_HANDLER (object);
	priv = offline_handler->priv;

	/* (We don't unref the shell, as it's our owner.)  */

	if (priv->id_to_component_info != NULL) {
		g_hash_table_foreach (priv->id_to_component_info, hash_foreach_free_component_info, NULL);
		g_hash_table_destroy (priv->id_to_component_info);
		priv->id_to_component_info = NULL;
	}

	(* G_OBJECT_CLASS (e_shell_offline_handler_parent_class)->dispose) (object);
}

static void
impl_finalize (GObject *object)
{
	EShellOfflineHandler *offline_handler;
	EShellOfflineHandlerPrivate *priv;

	offline_handler = E_SHELL_OFFLINE_HANDLER (object);
	priv = offline_handler->priv;

	g_free (priv);

	(* G_OBJECT_CLASS (e_shell_offline_handler_parent_class)->finalize) (object);
}


/* GTK type handling.  */

static void
e_shell_offline_handler_class_init (EShellOfflineHandlerClass *klass)
{
	GObjectClass *object_class;

	object_class = G_OBJECT_CLASS (klass);
	object_class->dispose  = impl_dispose;
	object_class->finalize = impl_finalize;

	signals[OFFLINE_PROCEDURE_STARTED]
		= g_signal_new ("offline_procedure_started",
				G_OBJECT_CLASS_TYPE (object_class),
				G_SIGNAL_RUN_LAST,
				G_STRUCT_OFFSET (EShellOfflineHandlerClass, offline_procedure_started),
				NULL, NULL,
				e_shell_marshal_NONE__NONE,
				G_TYPE_NONE, 0);

	signals[OFFLINE_PROCEDURE_FINISHED]
		= g_signal_new ("offline_procedure_finished",
				G_OBJECT_CLASS_TYPE (object_class),
				G_SIGNAL_RUN_LAST,
				G_STRUCT_OFFSET (EShellOfflineHandlerClass, offline_procedure_finished),
				NULL, NULL,
				e_shell_marshal_NONE__BOOL,
				G_TYPE_NONE, 1,
				G_TYPE_BOOLEAN);
}


static void
e_shell_offline_handler_init (EShellOfflineHandler *shell_offline_handler)
{
	EShellOfflineHandlerPrivate *priv;

	priv = g_new (EShellOfflineHandlerPrivate, 1);

	priv->shell                 = NULL;

	priv->num_total_connections = 0;
	priv->id_to_component_info  = g_hash_table_new (g_str_hash, g_str_equal);

	priv->procedure_in_progress = FALSE;
	priv->finished              = FALSE;

	shell_offline_handler->priv = priv;
}


/**
 * e_shell_offline_handler_construct:
 * @offline_handler: A pointer to an EShellOfflineHandler to construct.
 * @shell: The Evolution shell.
 * 
 * Construct the @offline_handler.
 **/
void
e_shell_offline_handler_construct (EShellOfflineHandler *offline_handler,
				   EShell *shell)
{
	EShellOfflineHandlerPrivate *priv;

	g_return_if_fail (E_IS_SHELL_OFFLINE_HANDLER (offline_handler));
	g_return_if_fail (E_IS_SHELL (shell));

	priv = offline_handler->priv;

	g_assert (priv->shell == NULL);

	GTK_OBJECT_UNSET_FLAGS (GTK_OBJECT (offline_handler), GTK_FLOATING);

	priv->shell = shell;
}

/**
 * e_shell_offline_handler_new:
 * @shell: The Evolution shell.
 * 
 * Create a new offline handler.
 * 
 * Return value: A pointer to the newly created EShellOfflineHandler object.
 **/
EShellOfflineHandler *
e_shell_offline_handler_new (EShell *shell)
{
	EShellOfflineHandler *offline_handler;

	g_return_val_if_fail (E_IS_SHELL (shell), NULL);

	offline_handler = (EShellOfflineHandler *) g_object_new (e_shell_offline_handler_get_type (), NULL);
	e_shell_offline_handler_construct (offline_handler, shell);

	return offline_handler;
}


/**
 * e_shell_offline_handler_put_components_offline:
 * @offline_handler: A pointer to an EShellOfflineHandler object.
 * 
 * Put the components offline.
 **/
void
e_shell_offline_handler_put_components_offline (EShellOfflineHandler *offline_handler,
						GtkWindow *parent_window)
{
	EShellOfflineHandlerPrivate *priv;

	g_return_if_fail (offline_handler != NULL);
	g_return_if_fail (E_IS_SHELL_OFFLINE_HANDLER (offline_handler));

	priv = offline_handler->priv;

	priv->procedure_in_progress = TRUE;

	/* Add an extra ref here as the signal handlers might want to unref
	   us.  */

	g_object_ref (offline_handler);

	g_signal_emit (offline_handler, signals[OFFLINE_PROCEDURE_STARTED], 0);

	priv->finished = FALSE;

	if (! prepare_for_offline (offline_handler)) {
		/* FIXME: Maybe do something smarter here.  */
		g_warning ("Couldn't put components off-line");
		priv->finished = TRUE;
		g_signal_emit (offline_handler, signals[OFFLINE_PROCEDURE_FINISHED], 0, FALSE);
		g_object_unref (offline_handler);
		return;
	}

		finalize_offline (offline_handler);

	g_object_unref (offline_handler);
}