From 9130b26c7b84ea9d96bb9d77f819a4c6fe099eda Mon Sep 17 00:00:00 2001 From: Ettore Perazzoli Date: Wed, 19 Nov 2003 09:54:50 +0000 Subject: (evolution_activity_client_construct): Get a raw GNOME_Evolution_Shell as an arg instead of an EvolutionShellClient. (get_shell_activity_iface): New helper function. (evolution_activity_client_construct): Use it. svn path=/trunk/; revision=23440 --- shell/ChangeLog | 9 + shell/e-activity-handler.c | 588 ++++++++++++++++++++++++++++++++++++++ shell/e-activity-handler.h | 72 +++++ shell/evolution-activity-client.c | 44 +-- shell/evolution-activity-client.h | 4 +- 5 files changed, 699 insertions(+), 18 deletions(-) create mode 100644 shell/e-activity-handler.c create mode 100644 shell/e-activity-handler.h (limited to 'shell') diff --git a/shell/ChangeLog b/shell/ChangeLog index 0480780d3b..a854194c16 100644 --- a/shell/ChangeLog +++ b/shell/ChangeLog @@ -1,3 +1,12 @@ +2003-11-19 Ettore Perazzoli + + * evolution-activity-client.c + (evolution_activity_client_construct): Get a raw + GNOME_Evolution_Shell as an arg instead of an + EvolutionShellClient. + (get_shell_activity_iface): New helper function. + (evolution_activity_client_construct): Use it. + 2003-11-19 Ettore Perazzoli * e-shell-window.c (impl_dispose): Destroy the tooltips instead of diff --git a/shell/e-activity-handler.c b/shell/e-activity-handler.c new file mode 100644 index 0000000000..023ff59cd5 --- /dev/null +++ b/shell/e-activity-handler.c @@ -0,0 +1,588 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ +/* e-activity-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 + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include "e-activity-handler.h" + +#include "e-shell-corba-icon-utils.h" + +#include +#include + +#include +#include + +#include +#include + +#include + + +#define PARENT_TYPE bonobo_object_get_type () +static BonoboObjectClass *parent_class = NULL; + + +#define ICON_SIZE 16 + + +struct _ActivityInfo { + char *component_id; + GdkPixbuf *icon_pixbuf; + GNOME_Evolution_Activity_ActivityId id; + CORBA_char *information; + CORBA_boolean cancellable; + Bonobo_Listener event_listener; + CORBA_float progress; + GtkWidget *menu; +}; +typedef struct _ActivityInfo ActivityInfo; + +struct _EActivityHandlerPrivate { + GNOME_Evolution_Activity_ActivityId next_activity_id; + GList *activity_infos; + GSList *task_bars; +}; + + +/* Utility functions. */ + +static unsigned int +get_new_activity_id (EActivityHandler *activity_handler) +{ + EActivityHandlerPrivate *priv; + + priv = activity_handler->priv; + + return priv->next_activity_id ++; +} + +static GList * +lookup_activity (GList *list, + GNOME_Evolution_Activity_ActivityId activity_id, + int *order_number_return) +{ + GList *p; + int i; + + for (p = list, i = 0; p != NULL; p = p->next, i ++) { + ActivityInfo *activity_info; + + activity_info = (ActivityInfo *) p->data; + if (activity_info->id == activity_id) { + *order_number_return = i; + return p; + } + } + + *order_number_return = -1; + return NULL; +} + +#if 0 +static const CORBA_any * +get_corba_null_value (void) +{ + static CORBA_any *null_value = NULL; + + if (null_value == NULL) { + null_value = CORBA_any__alloc (); + null_value->_type = TC_null; + } + + return null_value; +} + +static void +report_task_event (ActivityInfo *activity_info, + const char *event_name) +{ + CORBA_Environment ev; + + CORBA_exception_init (&ev); + + Bonobo_Listener_event (activity_info->event_listener, event_name, get_corba_null_value (), &ev); + if (ev._major != CORBA_NO_EXCEPTION) + g_warning ("EActivityHandler: Cannot event `%s' -- %s", event_name, ev._repo_id); + + CORBA_exception_free (&ev); +} +#endif + + +/* ETaskWidget actions. */ + +#if 0 +static void +task_widget_cancel_callback (GtkWidget *widget, + void *data) +{ + ActivityInfo *activity_info; + + activity_info = (ActivityInfo *) data; + report_task_event (activity_info, "Cancel"); +} + +static void +task_widget_show_details_callback (GtkWidget *widget, + void *data) +{ + ActivityInfo *activity_info; + + activity_info = (ActivityInfo *) data; + report_task_event (activity_info, "ShowDetails"); +} + +static void +show_cancellation_popup (ActivityInfo *activity_info, + GtkWidget *task_widget, + GdkEventButton *button_event) +{ + GtkMenu *popup; + EPopupMenu items[] = { + E_POPUP_MENU (N_("Show Details"), task_widget_show_details_callback, 0), + E_POPUP_SEPARATOR, + E_POPUP_MENU (N_("Cancel Operation"), task_widget_cancel_callback, 0), + E_POPUP_TERMINATOR + }; + + /* FIXME: We should gray out things properly here. */ + popup = e_popup_menu_create (items, 0, 0, activity_info); + + g_assert (activity_info->menu == NULL); + activity_info->menu = GTK_WIDGET (popup); + + gnome_popup_menu_do_popup_modal (GTK_WIDGET (popup), NULL, NULL, button_event, activity_info); + + activity_info->menu = NULL; +} +#endif + +static int +task_widget_button_press_event_callback (GtkWidget *widget, + GdkEventButton *button_event, + void *data) +{ + CORBA_Environment ev; + ActivityInfo *activity_info; + CORBA_any *null_value; + + activity_info = (ActivityInfo *) data; + + if (button_event->button == 3) { + if (! activity_info->cancellable) { + return FALSE; + } else { + /* show_cancellation_popup (activity_info, widget, button_event); */ + /* return TRUE; */ + return TRUE; + } + } + + if (button_event->button != 1) + return FALSE; + + CORBA_exception_init (&ev); + + null_value = CORBA_any__alloc (); + null_value->_type = TC_null; + + Bonobo_Listener_event (activity_info->event_listener, "Clicked", null_value, &ev); + if (BONOBO_EX (&ev) != CORBA_NO_EXCEPTION) + g_warning ("EActivityHandler: Cannot report `Clicked' event -- %s", + BONOBO_EX_REPOID (&ev)); + + CORBA_free (null_value); + + CORBA_exception_free (&ev); + + return TRUE; +} + + +/* Creating and destroying ActivityInfos. */ + +static ActivityInfo * +activity_info_new (const char *component_id, + GNOME_Evolution_Activity_ActivityId id, + GdkPixbuf *icon, + const CORBA_char *information, + CORBA_boolean cancellable, + const Bonobo_Listener event_listener) +{ + ActivityInfo *info; + CORBA_Environment ev; + + CORBA_exception_init (&ev); + + info = g_new (ActivityInfo, 1); + info->component_id = g_strdup (component_id); + info->id = id; + info->icon_pixbuf = g_object_ref (icon); + info->information = CORBA_string_dup (information); + info->cancellable = cancellable; + info->event_listener = CORBA_Object_duplicate (event_listener, &ev); + info->progress = -1.0; /* (Unknown) */ + info->menu = NULL; + + CORBA_exception_free (&ev); + + return info; +} + +static void +activity_info_free (ActivityInfo *info) +{ + CORBA_Environment ev; + + CORBA_exception_init (&ev); + + g_free (info->component_id); + + g_object_unref (info->icon_pixbuf); + CORBA_free (info->information); + CORBA_Object_release (info->event_listener, &ev); + + if (info->menu != NULL) + gtk_widget_destroy (info->menu); + + g_free (info); + + CORBA_exception_free (&ev); +} + +static ETaskWidget * +task_widget_new_from_activity_info (ActivityInfo *activity_info) +{ + GtkWidget *widget; + + widget = e_task_widget_new (activity_info->icon_pixbuf, + activity_info->component_id, + activity_info->information); + gtk_widget_show (widget); + + g_signal_connect (widget, "button_press_event", + G_CALLBACK (task_widget_button_press_event_callback), + activity_info); + + return E_TASK_WIDGET (widget); +} + + +/* Task Bar handling. */ + +static void +setup_task_bar (EActivityHandler *activity_handler, + ETaskBar *task_bar) +{ + EActivityHandlerPrivate *priv; + GList *p; + + priv = activity_handler->priv; + + for (p = g_list_last (priv->activity_infos); p != NULL; p = p->prev) { + e_task_bar_prepend_task (task_bar, + task_widget_new_from_activity_info ((ActivityInfo *) p->data)); + } +} + +static void +task_bar_destroy_notify (void *data, + GObject *task_bar_instance) +{ + EActivityHandler *activity_handler; + EActivityHandlerPrivate *priv; + + activity_handler = E_ACTIVITY_HANDLER (data); + priv = activity_handler->priv; + + priv->task_bars = g_slist_remove (priv->task_bars, task_bar_instance); +} + + +/* GObject methods. */ + +static void +impl_dispose (GObject *object) +{ + EActivityHandler *handler; + EActivityHandlerPrivate *priv; + GList *p; + GSList *sp; + + handler = E_ACTIVITY_HANDLER (object); + priv = handler->priv; + + for (p = priv->activity_infos; p != NULL; p = p->next) { + ActivityInfo *info; + + info = (ActivityInfo *) p->data; + activity_info_free (info); + } + + g_list_free (priv->activity_infos); + priv->activity_infos = NULL; + + for (sp = priv->task_bars; sp != NULL; sp = sp->next) + g_object_weak_unref (G_OBJECT (sp->data), task_bar_destroy_notify, sp->data); + priv->task_bars = NULL; + + (* G_OBJECT_CLASS (parent_class)->dispose) (object); +} + +static void +impl_finalize (GObject *object) +{ + EActivityHandler *handler; + EActivityHandlerPrivate *priv; + + handler = E_ACTIVITY_HANDLER (object); + priv = handler->priv; + + g_free (priv); + + (* G_OBJECT_CLASS (parent_class)->finalize) (object); +} + + +/* CORBA methods. */ + +static void +impl_operationStarted (PortableServer_Servant servant, + const CORBA_char *component_id, + const GNOME_Evolution_AnimatedIcon *icon, + const CORBA_char *information, + const CORBA_boolean cancellable, + const Bonobo_Listener event_listener, + GNOME_Evolution_Activity_ActivityId *activity_id_return, + CORBA_boolean *suggest_display_return, + CORBA_Environment *ev) +{ + EActivityHandler *activity_handler; + EActivityHandlerPrivate *priv; + ActivityInfo *activity_info; + GdkPixbuf *icon_pixbuf; + unsigned int activity_id; + GSList *p; + + activity_handler = E_ACTIVITY_HANDLER (bonobo_object_from_servant (servant)); + + priv = activity_handler->priv; + + if (icon->_length == 0) { + CORBA_exception_set (ev, CORBA_USER_EXCEPTION, + ex_GNOME_Evolution_Activity_InvalidIcon, NULL); + return; + } + + if (icon->_length > 1) + g_warning ("Animated icons are not supported for activities (yet)."); + + icon_pixbuf = e_new_gdk_pixbuf_from_corba_icon (icon->_buffer, ICON_SIZE, ICON_SIZE); + + activity_id = get_new_activity_id (activity_handler); + + activity_info = activity_info_new (component_id, activity_id, icon_pixbuf, information, + cancellable, event_listener); + + for (p = priv->task_bars; p != NULL; p = p->next) + e_task_bar_prepend_task (E_TASK_BAR (p->data), + task_widget_new_from_activity_info (activity_info)); + + g_object_unref (icon_pixbuf); + + priv->activity_infos = g_list_prepend (priv->activity_infos, activity_info); + + *activity_id_return = activity_id; +} + +static void +impl_operationProgressing (PortableServer_Servant servant, + const GNOME_Evolution_Activity_ActivityId activity_id, + const CORBA_char *information, + const CORBA_float progress, + CORBA_Environment *ev) +{ + EActivityHandler *activity_handler; + EActivityHandlerPrivate *priv; + ActivityInfo *activity_info; + GList *p; + GSList *sp; + int order_number; + + /* FIXME? The complexity in this function sucks. */ + + activity_handler = E_ACTIVITY_HANDLER (bonobo_object_from_servant (servant)); + + priv = activity_handler->priv; + + p = lookup_activity (priv->activity_infos, activity_id, &order_number); + if (p == NULL) { + CORBA_exception_set (ev, CORBA_USER_EXCEPTION, + ex_GNOME_Evolution_Activity_IdNotFound, NULL); + return; + } + + activity_info = (ActivityInfo *) p->data; + + CORBA_free (activity_info->information); + activity_info->information = CORBA_string_dup (information); + + activity_info->progress = progress; + + for (sp = priv->task_bars; sp != NULL; sp = sp->next) { + ETaskBar *task_bar; + ETaskWidget *task_widget; + + task_bar = E_TASK_BAR (sp->data); + task_widget = e_task_bar_get_task_widget (task_bar, order_number); + + e_task_widget_update (task_widget, information, progress); + } +} + +static void +impl_operationFinished (PortableServer_Servant servant, + const GNOME_Evolution_Activity_ActivityId activity_id, + CORBA_Environment *ev) +{ + EActivityHandler *activity_handler; + EActivityHandlerPrivate *priv; + GList *p; + GSList *sp; + int order_number; + + activity_handler = E_ACTIVITY_HANDLER (bonobo_object_from_servant (servant)); + + priv = activity_handler->priv; + + p = lookup_activity (priv->activity_infos, activity_id, &order_number); + + activity_info_free ((ActivityInfo *) p->data); + priv->activity_infos = g_list_remove_link (priv->activity_infos, p); + + for (sp = priv->task_bars; sp != NULL; sp = sp->next) { + ETaskBar *task_bar; + + task_bar = E_TASK_BAR (sp->data); + e_task_bar_remove_task (task_bar, order_number); + } +} + +static GNOME_Evolution_Activity_DialogAction +impl_requestDialog (PortableServer_Servant servant, + const GNOME_Evolution_Activity_ActivityId activity_id, + const GNOME_Evolution_Activity_DialogType dialog_type, + CORBA_Environment *ev) +{ + EActivityHandler *activity_handler; + + activity_handler = E_ACTIVITY_HANDLER (bonobo_object_from_servant (servant)); + + /* FIXME implement. */ + g_warning ("Evolution::Activity::requestDialog not implemented"); + + return GNOME_Evolution_Activity_DIALOG_ACTION_DISPLAY; +} + + +/* GTK+ type stuff. */ + +static void +e_activity_handler_class_init (GObjectClass *object_class) +{ + EActivityHandlerClass *handler_class; + + parent_class = g_type_class_ref(PARENT_TYPE); + + object_class->dispose = impl_dispose; + object_class->finalize = impl_finalize; + + handler_class = E_ACTIVITY_HANDLER_CLASS (object_class); + handler_class->epv.operationStarted = impl_operationStarted; + handler_class->epv.operationProgressing = impl_operationProgressing; + handler_class->epv.operationFinished = impl_operationFinished; + handler_class->epv.requestDialog = impl_requestDialog; +} + +static void +e_activity_handler_init (EActivityHandler *activity_handler) +{ + EActivityHandlerPrivate *priv; + + priv = g_new (EActivityHandlerPrivate, 1); + priv->next_activity_id = 0; + priv->activity_infos = NULL; + priv->task_bars = NULL; + + activity_handler->priv = priv; +} + + +void +e_activity_handler_construct (EActivityHandler *activity_handler) +{ + g_return_if_fail (activity_handler != NULL); + g_return_if_fail (E_IS_ACTIVITY_HANDLER (activity_handler)); + + /* Nothing to do here. */ +} + +EActivityHandler * +e_activity_handler_new (void) +{ + EActivityHandler *activity_handler; + + activity_handler = g_object_new (e_activity_handler_get_type (), 0); + e_activity_handler_construct (activity_handler); + + return activity_handler; +} + + +void +e_activity_handler_attach_task_bar (EActivityHandler *activity_handler, + ETaskBar *task_bar) +{ + EActivityHandlerPrivate *priv; + + g_return_if_fail (activity_handler != NULL); + g_return_if_fail (E_IS_ACTIVITY_HANDLER (activity_handler)); + g_return_if_fail (task_bar != NULL); + g_return_if_fail (E_IS_TASK_BAR (task_bar)); + + priv = activity_handler->priv; + + g_object_weak_ref (G_OBJECT (task_bar), task_bar_destroy_notify, activity_handler); + + priv->task_bars = g_slist_prepend (priv->task_bars, task_bar); + + setup_task_bar (activity_handler, task_bar); +} + + +BONOBO_TYPE_FUNC_FULL (EActivityHandler, + GNOME_Evolution_Activity, + PARENT_TYPE, + e_activity_handler) diff --git a/shell/e-activity-handler.h b/shell/e-activity-handler.h new file mode 100644 index 0000000000..b69c360765 --- /dev/null +++ b/shell/e-activity-handler.h @@ -0,0 +1,72 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ +/* e-activity-handler.h + * + * 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 + */ + +#ifndef _E_ACTIVITY_HANDLER_H_ +#define _E_ACTIVITY_HANDLER_H_ + +#include "Evolution.h" + +#include "e-task-bar.h" + +#include + +#ifdef __cplusplus +extern "C" { +#pragma } +#endif /* __cplusplus */ + +#define E_TYPE_ACTIVITY_HANDLER (e_activity_handler_get_type ()) +#define E_ACTIVITY_HANDLER(obj) (GTK_CHECK_CAST ((obj), E_TYPE_ACTIVITY_HANDLER, EActivityHandler)) +#define E_ACTIVITY_HANDLER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_TYPE_ACTIVITY_HANDLER, EActivityHandlerClass)) +#define E_IS_ACTIVITY_HANDLER(obj) (GTK_CHECK_TYPE ((obj), E_TYPE_ACTIVITY_HANDLER)) +#define E_IS_ACTIVITY_HANDLER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), E_TYPE_ACTIVITY_HANDLER)) + + +typedef struct _EActivityHandler EActivityHandler; +typedef struct _EActivityHandlerPrivate EActivityHandlerPrivate; +typedef struct _EActivityHandlerClass EActivityHandlerClass; + +struct _EActivityHandler { + BonoboObject parent; + + EActivityHandlerPrivate *priv; +}; + +struct _EActivityHandlerClass { + BonoboObjectClass parent_class; + + POA_GNOME_Evolution_Activity__epv epv; +}; + + +GtkType e_activity_handler_get_type (void); +void e_activity_handler_construct (EActivityHandler *activity_hanlder); +EActivityHandler *e_activity_handler_new (void); + +void e_activity_handler_attach_task_bar (EActivityHandler *activity_hanlder, + ETaskBar *task_bar); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* _E_ACTIVITY_HANDLER_H_ */ diff --git a/shell/evolution-activity-client.c b/shell/evolution-activity-client.c index 1ab93402d0..584ad6e15a 100644 --- a/shell/evolution-activity-client.c +++ b/shell/evolution-activity-client.c @@ -43,9 +43,11 @@ #include #include +#include + #include - + #define PARENT_TYPE gtk_object_get_type () static GtkObjectClass *parent_class = NULL; @@ -82,7 +84,7 @@ struct _EvolutionActivityClientPrivate { double new_progress; }; - + /* Utility functions. */ static gboolean @@ -136,7 +138,20 @@ update_timeout_callback (void *data) } } - +static CORBA_Object +get_shell_activity_iface (GNOME_Evolution_Shell shell_iface) +{ + CORBA_Object iface_object; + const char *iface_name = "IDL:GNOME/Evolution/Activity:1.0"; + + iface_object = bonobo_object_query_remote (shell_iface, iface_name, NULL); + if (iface_object == CORBA_OBJECT_NIL) + g_warning ("EvolutionActivityClient: No iface %s on Shell", iface_name); + + return iface_object; +} + + /* BonoboListener callback. */ static void @@ -158,7 +173,7 @@ listener_callback (BonoboListener *listener, g_warning ("EvolutionActivityClient: Unknown event from listener -- %s", event_name); } - + /* GObject methods. */ static void @@ -216,7 +231,7 @@ impl_finalize (GObject *object) (* G_OBJECT_CLASS (parent_class)->finalize) (object); } - + static void class_init (EvolutionActivityClientClass *klass) { @@ -265,10 +280,10 @@ init (EvolutionActivityClient *activity_client) activity_client->priv = priv; } - + gboolean evolution_activity_client_construct (EvolutionActivityClient *activity_client, - EvolutionShellClient *shell_client, + GNOME_Evolution_Shell shell_iface, const char *component_id, GdkPixbuf **animated_icon, const char *information, @@ -283,8 +298,6 @@ evolution_activity_client_construct (EvolutionActivityClient *activity_client, g_return_val_if_fail (activity_client != NULL, FALSE); g_return_val_if_fail (EVOLUTION_IS_ACTIVITY_CLIENT (activity_client), FALSE); - g_return_val_if_fail (shell_client != NULL, FALSE); - g_return_val_if_fail (EVOLUTION_IS_SHELL_CLIENT (shell_client), FALSE); g_return_val_if_fail (animated_icon != NULL, FALSE); g_return_val_if_fail (*animated_icon != NULL, FALSE); g_return_val_if_fail (information != NULL, FALSE); @@ -297,7 +310,7 @@ evolution_activity_client_construct (EvolutionActivityClient *activity_client, CORBA_exception_init (&ev); - activity_interface = evolution_shell_client_get_activity_interface (shell_client); + activity_interface = get_shell_activity_iface (shell_iface); priv->activity_interface = CORBA_Object_duplicate (activity_interface, &ev); if (ev._major != CORBA_NO_EXCEPTION) { priv->activity_interface = CORBA_OBJECT_NIL; @@ -331,7 +344,7 @@ evolution_activity_client_construct (EvolutionActivityClient *activity_client, } EvolutionActivityClient * -evolution_activity_client_new (EvolutionShellClient *shell_client, +evolution_activity_client_new (GNOME_Evolution_Shell shell_iface, const char *component_id, GdkPixbuf **animated_icon, const char *information, @@ -340,8 +353,7 @@ evolution_activity_client_new (EvolutionShellClient *shell_client, { EvolutionActivityClient *activity_client; - g_return_val_if_fail (shell_client != NULL, NULL); - g_return_val_if_fail (EVOLUTION_IS_SHELL_CLIENT (shell_client), NULL); + g_return_val_if_fail (shell_iface != CORBA_OBJECT_NIL, NULL); g_return_val_if_fail (animated_icon != NULL, NULL); g_return_val_if_fail (*animated_icon != NULL, NULL); g_return_val_if_fail (information != NULL, NULL); @@ -350,7 +362,7 @@ evolution_activity_client_new (EvolutionShellClient *shell_client, activity_client = g_object_new (evolution_activity_client_get_type (), NULL); if (! evolution_activity_client_construct (activity_client, - shell_client, + shell_iface, component_id, animated_icon, information, @@ -363,7 +375,7 @@ evolution_activity_client_new (EvolutionShellClient *shell_client, return activity_client; } - + gboolean evolution_activity_client_update (EvolutionActivityClient *activity_client, const char *information, @@ -444,6 +456,6 @@ evolution_activity_client_request_dialog (EvolutionActivityClient *activity_clie return retval; } - + E_MAKE_TYPE (evolution_activity_client, "EvolutionActivityClient", EvolutionActivityClient, class_init, init, PARENT_TYPE) diff --git a/shell/evolution-activity-client.h b/shell/evolution-activity-client.h index d212dad219..ff42ba2317 100644 --- a/shell/evolution-activity-client.h +++ b/shell/evolution-activity-client.h @@ -63,13 +63,13 @@ struct _EvolutionActivityClientClass { GtkType evolution_activity_client_get_type (void); gboolean evolution_activity_client_construct (EvolutionActivityClient *activity_client, - EvolutionShellClient *shell_client, + GNOME_Evolution_Shell shell, const char *component_id, GdkPixbuf **animated_icon, const char *information, gboolean cancellable, gboolean *suggest_display_return); -EvolutionActivityClient *evolution_activity_client_new (EvolutionShellClient *shell_client, +EvolutionActivityClient *evolution_activity_client_new (GNOME_Evolution_Shell shell, const char *component_id, GdkPixbuf **animated_icon, const char *information, -- cgit v1.2.3