~ubuntu-branches/ubuntu/maverick/empathy/maverick

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

/*

 * Copyright (C) 2003-2007 Imendio AB

 * Copyright (C) 2007-2008 Collabora Ltd.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of the

 * License, or (at your option) any later version.

 *

 * 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., 51 Franklin St, Fifth Floor,

 * Boston, MA  02110-1301  USA

 *

 * Authors: Mikael Hallendal <micke@imendio.com>

 *          Richard Hult <richard@imendio.com>

 *          Martyn Russell <martyn@imendio.com>

 *          Geert-Jan Van den Bogaerde <geertjan@gnome.org>

 *          Xavier Claessens <xclaesse@gmail.com>

 *          Rômulo Fernandes Machado <romulo@castorgroup.net>

 */

#include <config.h>

#include <string.h>

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#include <gdk/gdkx.h>

#include <glib/gi18n.h>

#include <libnotify/notification.h>

/* Add launchpad hooks */

#include <launchpad-integration.h>

#include <telepathy-glib/telepathy-glib.h>

#include <libempathy/empathy-contact.h>

#include <libempathy/empathy-message.h>

#include <libempathy/empathy-chatroom-manager.h>

#include <libempathy/empathy-gsettings.h>

#include <libempathy/empathy-utils.h>

#include <libempathy/empathy-tp-contact-factory.h>

#include <libempathy/empathy-contact-list.h>

#include <libempathy-gtk/empathy-images.h>

#include <libempathy-gtk/empathy-contact-dialogs.h>

#include <libempathy-gtk/empathy-log-window.h>

#include <libempathy-gtk/empathy-geometry.h>

#include <libempathy-gtk/empathy-smiley-manager.h>

#include <libempathy-gtk/empathy-sound.h>

#include <libempathy-gtk/empathy-ui-utils.h>

#include <libempathy-gtk/empathy-notify-manager.h>

#include "empathy-chat-manager.h"

#include "empathy-chat-window.h"

#include "empathy-about-dialog.h"

#include "empathy-invite-participant-dialog.h"

#ifdef HAVE_LIBINDICATE

#include "empathy-indicator.h"

#include "empathy-indicator-manager.h"

#endif

#define DEBUG_FLAG EMPATHY_DEBUG_CHAT

#include <libempathy/empathy-debug.h>

/* Macro to compare guint32 X timestamps, while accounting for wrapping around

 */

#define X_EARLIER_OR_EQL(t1, t2) \

	((t1 <= t2 && ((t2 - t1) < G_MAXUINT32/2))  \

	  || (t1 >= t2 && (t1 - t2) > (G_MAXUINT32/2)) \

	)

#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyChatWindow)

typedef struct {

	EmpathyChat *current_chat;

	GList       *chats;

	GList       *chats_new_msg;

	GList       *chats_composing;

	gboolean     page_added;

	gboolean     dnd_same_window;

	EmpathyChatroomManager *chatroom_manager;

	EmpathyNotifyManager *notify_mgr;

	GtkWidget   *dialog;

	GtkWidget   *notebook;

	NotifyNotification *notification;

#ifdef HAVE_LIBINDICATE

	EmpathyIndicatorManager *indicator_manager;

	/* EmpathyChat -> EmpathyIndicator for that chat, if any */

	GHashTable  *indicators;

#endif

	GtkTargetList *contact_targets;

	GtkTargetList *file_targets;

	EmpathyChatManager *chat_manager;

	gulong chat_manager_chats_changed_id;

	/* Menu items. */

	GtkUIManager *ui_manager;

	GtkAction   *menu_conv_insert_smiley;

	GtkAction   *menu_conv_favorite;

	GtkAction   *menu_conv_always_urgent;

	GtkAction   *menu_conv_toggle_contacts;

	GtkAction   *menu_edit_cut;

	GtkAction   *menu_edit_copy;

	GtkAction   *menu_edit_paste;

	GtkAction   *menu_edit_find;

	GtkAction   *menu_tabs_next;

	GtkAction   *menu_tabs_prev;

	GtkAction   *menu_tabs_undo_close_tab;

	GtkAction   *menu_tabs_left;

	GtkAction   *menu_tabs_right;

	GtkAction   *menu_tabs_detach;

	/* Last user action time we acted upon to show a tab */

	guint32    x_user_action_time;

} EmpathyChatWindowPriv;

static GList *chat_windows = NULL;

static const guint tab_accel_keys[] = {

	GDK_1, GDK_2, GDK_3, GDK_4, GDK_5,

	GDK_6, GDK_7, GDK_8, GDK_9, GDK_0

};

typedef enum {

	DND_DRAG_TYPE_CONTACT_ID,

	DND_DRAG_TYPE_URI_LIST,

	DND_DRAG_TYPE_TAB

} DndDragType;

static const GtkTargetEntry drag_types_dest[] = {

	{ "text/contact-id", 0, DND_DRAG_TYPE_CONTACT_ID },

	{ "GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP, DND_DRAG_TYPE_TAB },

	{ "text/uri-list", 0, DND_DRAG_TYPE_URI_LIST },

	{ "text/path-list", 0, DND_DRAG_TYPE_URI_LIST },

};

static const GtkTargetEntry drag_types_dest_contact[] = {

	{ "text/contact-id", 0, DND_DRAG_TYPE_CONTACT_ID },

};

static const GtkTargetEntry drag_types_dest_file[] = {

	/* must be first to be prioritized, in order to receive the

	 * note's file path from Tomboy instead of an URI */

	{ "text/path-list", 0, DND_DRAG_TYPE_URI_LIST },

	{ "text/uri-list", 0, DND_DRAG_TYPE_URI_LIST },

};

static void chat_window_update (EmpathyChatWindow *window);

G_DEFINE_TYPE (EmpathyChatWindow, empathy_chat_window, G_TYPE_OBJECT);

static void

chat_window_accel_cb (GtkAccelGroup    *accelgroup,

		      GObject          *object,

		      guint             key,

		      GdkModifierType   mod,

		      EmpathyChatWindow *window)

{

	EmpathyChatWindowPriv *priv;

	gint                  num = -1;

	guint                 i;

	priv = GET_PRIV (window);

	for (i = 0; i < G_N_ELEMENTS (tab_accel_keys); i++) {

		if (tab_accel_keys[i] == key) {

			num = i;

			break;

		}

	}

	if (num != -1) {

		gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), num);

	}

}

static EmpathyChatWindow *

chat_window_find_chat (EmpathyChat *chat)

{

	EmpathyChatWindowPriv *priv;

	GList                 *l, *ll;

	for (l = chat_windows; l; l = l->next) {

		priv = GET_PRIV (l->data);

		ll = g_list_find (priv->chats, chat);

		if (ll) {

			return l->data;

		}

	}

	return NULL;

}

static void

chat_window_close_clicked_cb (GtkAction   *action,

			      EmpathyChat *chat)

{

	EmpathyChatWindow *window;

	window = chat_window_find_chat (chat);

	empathy_chat_window_remove_chat (window, chat);

}

static void

chat_tab_style_set_cb (GtkWidget *hbox,

				       GtkStyle  *previous_style,

				       gpointer   user_data)

{

	GtkWidget *button;

	int char_width, h, w;

	PangoContext *context;

	PangoFontMetrics *metrics;

	button = g_object_get_data (G_OBJECT (user_data),

		"chat-window-tab-close-button");

	context = gtk_widget_get_pango_context (hbox);

	metrics = pango_context_get_metrics (context, gtk_widget_get_style (hbox)->font_desc,

		pango_context_get_language (context));

	char_width = pango_font_metrics_get_approximate_char_width (metrics);

	pango_font_metrics_unref (metrics);

	gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (button),

					   GTK_ICON_SIZE_MENU, &w, &h);

	/* Request at least about 12 chars width plus at least space for the status

	 * image and the close button */

	gtk_widget_set_size_request (hbox,

		12 * PANGO_PIXELS (char_width) + 2 * w, -1);

	gtk_widget_set_size_request (button, w, h);

}

static GtkWidget *

chat_window_create_label (EmpathyChatWindow *window,

			  EmpathyChat       *chat,

			  gboolean           is_tab_label)

{

	EmpathyChatWindowPriv *priv;

	GtkWidget            *hbox;

	GtkWidget            *name_label;

	GtkWidget            *status_image;

	GtkWidget            *close_button;

	GtkWidget            *close_image;

	GtkWidget            *event_box;

	GtkWidget            *event_box_hbox;

	PangoAttrList        *attr_list;

	PangoAttribute       *attr;

	priv = GET_PRIV (window);

	/* The spacing between the button and the label. */

	hbox = gtk_hbox_new (FALSE, 0);

	event_box = gtk_event_box_new ();

	gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);

	name_label = gtk_label_new (NULL);

	if (is_tab_label)

		gtk_label_set_ellipsize (GTK_LABEL (name_label), PANGO_ELLIPSIZE_END);

	attr_list = pango_attr_list_new ();

	attr = pango_attr_scale_new (1/1.2);

	attr->start_index = 0;

	attr->end_index = -1;

	pango_attr_list_insert (attr_list, attr);

	gtk_label_set_attributes (GTK_LABEL (name_label), attr_list);

	pango_attr_list_unref (attr_list);

	gtk_misc_set_padding (GTK_MISC (name_label), 2, 0);

	gtk_misc_set_alignment (GTK_MISC (name_label), 0.0, 0.5);

	g_object_set_data (G_OBJECT (chat),

		is_tab_label ? "chat-window-tab-label" : "chat-window-menu-label",

		name_label);

	status_image = gtk_image_new ();

	/* Spacing between the icon and label. */

	event_box_hbox = gtk_hbox_new (FALSE, 0);

	gtk_box_pack_start (GTK_BOX (event_box_hbox), status_image, FALSE, FALSE, 0);

	gtk_box_pack_start (GTK_BOX (event_box_hbox), name_label, TRUE, TRUE, 0);

	g_object_set_data (G_OBJECT (chat),

		is_tab_label ? "chat-window-tab-image" : "chat-window-menu-image",

		status_image);

	g_object_set_data (G_OBJECT (chat),

		is_tab_label ? "chat-window-tab-tooltip-widget" : "chat-window-menu-tooltip-widget",

		event_box);

	gtk_container_add (GTK_CONTAINER (event_box), event_box_hbox);

	gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, TRUE, 0);

	if (is_tab_label) {

		close_button = gtk_button_new ();

		gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);

		g_object_set_data (G_OBJECT (chat), "chat-window-tab-close-button", close_button);

		/* We don't want focus/keynav for the button to avoid clutter, and

		 * Ctrl-W works anyway.

		 */

		gtk_widget_set_can_focus (close_button, FALSE);

		gtk_widget_set_can_default (close_button, FALSE);

		/* Set the name to make the special rc style match. */

		gtk_widget_set_name (close_button, "empathy-close-button");

		close_image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);

		gtk_container_add (GTK_CONTAINER (close_button), close_image);

		gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);

		g_signal_connect (close_button,

				  "clicked",

				  G_CALLBACK (chat_window_close_clicked_cb),

				  chat);

		/* React to theme changes and also setup the size correctly.  */

		g_signal_connect (hbox,

				  "style-set",

				  G_CALLBACK (chat_tab_style_set_cb),

				  chat);

	}

	gtk_widget_show_all (hbox);

	return hbox;

}

static void

_submenu_notify_visible_changed_cb (GObject    *object,

				    GParamSpec *pspec,

				    gpointer    userdata)

{

	g_signal_handlers_disconnect_by_func (object,

					      _submenu_notify_visible_changed_cb,

					      userdata);

	chat_window_update (EMPATHY_CHAT_WINDOW (userdata));

}

static void

chat_window_menu_context_update (EmpathyChatWindowPriv *priv,

			      gint num_pages)

{

	gboolean first_page;

	gboolean last_page;

	gboolean wrap_around;

	gboolean is_connected;

	gint     page_num;

	page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook));

	first_page = (page_num == 0);

	last_page = (page_num == (num_pages - 1));

	g_object_get (gtk_settings_get_default (), "gtk-keynav-wrap-around",

		      &wrap_around, NULL);

	is_connected = empathy_chat_get_tp_chat (priv->current_chat) != NULL;

	gtk_action_set_sensitive (priv->menu_tabs_next, (!last_page ||

							 wrap_around));

	gtk_action_set_sensitive (priv->menu_tabs_prev, (!first_page ||

							 wrap_around));

	gtk_action_set_sensitive (priv->menu_tabs_detach, num_pages > 1);

	gtk_action_set_sensitive (priv->menu_tabs_left, !first_page);

	gtk_action_set_sensitive (priv->menu_tabs_right, !last_page);

	gtk_action_set_sensitive (priv->menu_conv_insert_smiley, is_connected);

}

static void

chat_window_conversation_menu_update (EmpathyChatWindowPriv *priv,

                                      EmpathyChatWindow     *self)

{

	EmpathyTpChat *tp_chat;

	TpConnection *connection;

	GtkAction *action;

	gboolean sensitive = FALSE;

	g_return_if_fail (priv->current_chat != NULL);

	action = gtk_ui_manager_get_action (priv->ui_manager,

		"/chats_menubar/menu_conv/menu_conv_invite_participant");

	tp_chat = empathy_chat_get_tp_chat (priv->current_chat);

	if (tp_chat != NULL) {

		connection = empathy_tp_chat_get_connection (tp_chat);

		sensitive = empathy_tp_chat_can_add_contact (tp_chat) &&

			(tp_connection_get_status (connection, NULL) ==

			 TP_CONNECTION_STATUS_CONNECTED);

	}

	gtk_action_set_sensitive (action, sensitive);

}

static void

chat_window_contact_menu_update (EmpathyChatWindowPriv *priv,

				 EmpathyChatWindow     *window)

{

	GtkWidget *menu, *submenu, *orig_submenu;

	menu = gtk_ui_manager_get_widget (priv->ui_manager,

		"/chats_menubar/menu_contact");

	orig_submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu));

	if (orig_submenu == NULL || !gtk_widget_get_visible (orig_submenu)) {

		submenu = empathy_chat_get_contact_menu (priv->current_chat);

		gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu), submenu);

		gtk_widget_show (menu);

	} else {

		tp_g_signal_connect_object (orig_submenu,

					     "notify::visible",

					     (GCallback)_submenu_notify_visible_changed_cb,

					     window, 0);

	}

}

static guint

get_all_unread_messages (EmpathyChatWindowPriv *priv)

{

	GList *l;

	guint nb = 0;

	for (l = priv->chats_new_msg; l != NULL; l = g_list_next (l)) {

		EmpathyChat *chat = l->data;

		nb += empathy_chat_get_nb_unread_messages (chat);

	}

	return nb;

}

static gchar *

get_window_title_name (EmpathyChatWindowPriv *priv)

{

	const gchar *active_name;

	guint nb_chats;

	guint current_unread_msgs;

	nb_chats = g_list_length (priv->chats);

	g_assert (nb_chats > 0);

	active_name = empathy_chat_get_name (priv->current_chat);

	current_unread_msgs = empathy_chat_get_nb_unread_messages (

			priv->current_chat);

	if (nb_chats == 1) {

		/* only one tab */

		if (current_unread_msgs == 0)

			return g_strdup (active_name);

		else

			return g_strdup_printf (ngettext (

				"%s (%d unread)",

				"%s (%d unread)", current_unread_msgs),

				active_name, current_unread_msgs);

	} else {

		guint nb_others = nb_chats - 1;

		guint all_unread_msgs;

		all_unread_msgs = get_all_unread_messages (priv);

		if (all_unread_msgs == 0) {

			/* no unread message */

			return g_strdup_printf (ngettext (

				"%s (and %u other)",

				"%s (and %u others)", nb_others),

				active_name, nb_others);

		}

		else if (all_unread_msgs == current_unread_msgs) {

			/* unread messages are in the current tab */

			return g_strdup_printf (ngettext (

				"%s (%d unread)",

				"%s (%d unread)", current_unread_msgs),

				active_name, current_unread_msgs);

		}

		else if (current_unread_msgs == 0) {

			/* unread messages are in other tabs */

			return g_strdup_printf (ngettext (

				"%s (%d unread from others)",

				"%s (%d unread from others)",

				all_unread_msgs),

				active_name, all_unread_msgs);

		}

		else {

			/* unread messages are in all the tabs */

			return g_strdup_printf (ngettext (

				"%s (%d unread from all)",

				"%s (%d unread from all)",

				all_unread_msgs),

				active_name, all_unread_msgs);

		}

	}

}

static void

chat_window_title_update (EmpathyChatWindowPriv *priv)

{

	gchar *name;

	name = get_window_title_name (priv);

	gtk_window_set_title (GTK_WINDOW (priv->dialog), name);

	g_free (name);

}

static void

chat_window_icon_update (EmpathyChatWindowPriv *priv)

{

	GdkPixbuf      *icon;

	EmpathyContact *remote_contact;

	gboolean        avatar_in_icon;

	guint           n_chats;

	n_chats = g_list_length (priv->chats);

	/* Update window icon */

	if (priv->chats_new_msg) {

		gtk_window_set_icon_name (GTK_WINDOW (priv->dialog),

					  EMPATHY_IMAGE_MESSAGE);

	} else {

		GSettings *gsettings = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);

		avatar_in_icon = g_settings_get_boolean (gsettings,

				EMPATHY_PREFS_CHAT_AVATAR_IN_ICON);

		if (n_chats == 1 && avatar_in_icon) {

			remote_contact = empathy_chat_get_remote_contact (priv->current_chat);

			icon = empathy_pixbuf_avatar_from_contact_scaled (remote_contact, 0, 0);

			gtk_window_set_icon (GTK_WINDOW (priv->dialog), icon);

			if (icon != NULL) {

				g_object_unref (icon);

			}

		} else {

			gtk_window_set_icon_name (GTK_WINDOW (priv->dialog), NULL);

		}

		g_object_unref (gsettings);

	}

}

static void

chat_window_close_button_update (EmpathyChatWindowPriv *priv,

				 gint num_pages)

{

	GtkWidget *chat;

	GtkWidget *chat_close_button;

	gint       i;

	if (num_pages == 1) {

		chat = gtk_notebook_get_nth_page (GTK_NOTEBOOK (priv->notebook), 0);

		chat_close_button = g_object_get_data (G_OBJECT (chat),

				"chat-window-tab-close-button");

		gtk_widget_hide (chat_close_button);

	} else {

		for (i=0; i<num_pages; i++) {

			chat = gtk_notebook_get_nth_page (GTK_NOTEBOOK (priv->notebook), i);

			chat_close_button = g_object_get_data (G_OBJECT (chat),

					"chat-window-tab-close-button");

			gtk_widget_show (chat_close_button);

		}

	}

}

static void

chat_window_update (EmpathyChatWindow *window)

{

	EmpathyChatWindowPriv *priv = GET_PRIV (window);

	gint                   num_pages;

	num_pages = gtk_notebook_get_n_pages (GTK_NOTEBOOK (priv->notebook));

	/* Update Tab menu */

	chat_window_menu_context_update (priv,

					 num_pages);

	chat_window_conversation_menu_update (priv, window);

	chat_window_contact_menu_update (priv,

					 window);

	chat_window_title_update (priv);

	chat_window_icon_update (priv);

	chat_window_close_button_update (priv,

					 num_pages);

}

static void

append_markup_printf (GString    *string,

		      const char *format,

		      ...)

{

	gchar *tmp;

	va_list args;

	va_start (args, format);

	tmp = g_markup_vprintf_escaped (format, args);

	g_string_append (string, tmp);

	g_free (tmp);

	va_end (args);

}

static void

chat_window_update_chat_tab (EmpathyChat *chat)

{

	EmpathyChatWindow     *window;

	EmpathyChatWindowPriv *priv;

	EmpathyContact        *remote_contact;

	const gchar           *name;

	const gchar           *id;

	TpAccount             *account;

	const gchar           *subject;

	const gchar           *status = NULL;

	GtkWidget             *widget;

	GString               *tooltip;

	gchar                 *markup;

	const gchar           *icon_name;

	GtkWidget             *tab_image;

	GtkWidget             *menu_image;

	window = chat_window_find_chat (chat);

	if (!window) {

		return;

	}

	priv = GET_PRIV (window);

	/* Get information */

	name = empathy_chat_get_name (chat);

	account = empathy_chat_get_account (chat);

	subject = empathy_chat_get_subject (chat);

	remote_contact = empathy_chat_get_remote_contact (chat);

	DEBUG ("Updating chat tab, name=%s, account=%s, subject=%s, remote_contact=%p",

		name, tp_proxy_get_object_path (account), subject, remote_contact);

	/* Update tab image */

	if (empathy_chat_get_tp_chat (chat) == NULL) {

		/* No TpChat, we are disconnected */

		icon_name = NULL;

	}

	else if (g_list_find (priv->chats_new_msg, chat)) {

		icon_name = EMPATHY_IMAGE_MESSAGE;

	}

	else if (g_list_find (priv->chats_composing, chat)) {

		icon_name = EMPATHY_IMAGE_TYPING;

	}

	else if (remote_contact) {

		icon_name = empathy_icon_name_for_contact (remote_contact);

	} else {

		icon_name = EMPATHY_IMAGE_GROUP_MESSAGE;

	}

	tab_image = g_object_get_data (G_OBJECT (chat), "chat-window-tab-image");

	menu_image = g_object_get_data (G_OBJECT (chat), "chat-window-menu-image");

	if (icon_name != NULL) {

		gtk_image_set_from_icon_name (GTK_IMAGE (tab_image), icon_name, GTK_ICON_SIZE_MENU);

		gtk_widget_show (tab_image);

		gtk_image_set_from_icon_name (GTK_IMAGE (menu_image), icon_name, GTK_ICON_SIZE_MENU);

		gtk_widget_show (menu_image);

	} else {

		gtk_widget_hide (tab_image);

		gtk_widget_hide (menu_image);

	}

	/* Update tab tooltip */

	tooltip = g_string_new (NULL);

	if (remote_contact) {

		id = empathy_contact_get_id (remote_contact);

		status = empathy_contact_get_presence_message (remote_contact);

	} else {

		id = name;

	}

	append_markup_printf (tooltip,

			      "<b>%s</b><small> (%s)</small>",

			      id,

			      tp_account_get_display_name (account));

	if (!EMP_STR_EMPTY (status)) {

		append_markup_printf (tooltip, "\n<i>%s</i>", status);

	}

	if (subject) {

		append_markup_printf (tooltip, "\n<b>%s</b> %s",

				      _("Topic:"), subject);

	}

	if (g_list_find (priv->chats_composing, chat)) {

		append_markup_printf (tooltip, "\n%s", _("Typing a message."));

	}

	markup = g_string_free (tooltip, FALSE);

	widget = g_object_get_data (G_OBJECT (chat), "chat-window-tab-tooltip-widget");

	gtk_widget_set_tooltip_markup (widget, markup);

	widget = g_object_get_data (G_OBJECT (chat), "chat-window-menu-tooltip-widget");

	gtk_widget_set_tooltip_markup (widget, markup);