Initial room list support. It does not works yet.

2007-07-20 Xavier Claessens  <xclaesse@gmail.com>

	* libempathy/Makefile.am:
	* libempathy/empathy-tp-roomlist.h:
	* libempathy/empathy-tp-roomlist.c:
	* libempathy-gtk/empathy-chatrooms-window.c:
	* libempathy-gtk/empathy-new-chatroom-dialog.c: Initial room list
	support. It does not works yet.

	* libempathy-gtk/empathy-account-widget-generic.c: Add support for all
	types of integer and float. Fixes bug #457740 (Jamey Hicks).

	* libempathy/empathy-tp-chat.c:
	* libempathy-gtk/empathy-chat.c: If there is an error sending a message,
	show an error message to the user.

	* libempathy-gtk/empathy-accounts-dialog.c: Fix a leak, profile should
	be unrefed after mc_account_get_profile.

	* libempathy/empathy-utils.c:
	* libempathy/empathy-utils.h:
	* libempathy/empathy-tp-chatroom.c:
	* libempathy/empathy-tp-group.h:
	* libempathy/empathy-tp-group.c:
	* src/empathy.c: Rename empathy_get_channel_id() to
	empathy_inspect_channel(). We now have empathy_inspect_handle().

	* po/POTFILES.in:
	* libempathy/empathy-tp-contact-list.c: Set all contacts from salut
	protocol to the "Local Network" group.

	* libempathy/empathy-idle.c: Fix NetworkManager support.

	* libempathy/empathy-chatroom.h: Fix indentation.

	* libempathy-gtk/empathy-status-icon.c:
	* libempathy-gtk/empathy-ui-utils.c:
	* libempathy-gtk/empathy-ui-utils.h:
	 - Iconify main window to the status icon like in rhythmbox.
	   Fixes bug #458106 (Jaap A. Haitsma).
	 - Rounded avatars. Fixes bug #457992 (Raphael Slinckx)

	* Makefile.am: Fix distcheck for gtkdoc (Vincent Untz)

	* data/empathy.desktop.in.in: Change application description
	(Jaap A. Haitsma).


svn path=/trunk/; revision=190

12 files changed, 555 insertions, 87 deletions

diff --git a/libempathy/Makefile.am b/libempathy/Makefile.am
index 3f73265cf..9fbb7fe0b 100644
--- a/libempathy/Makefile.am
+++ b/libempathy/Makefile.am
@@ -30,6 +30,7 @@ libempathy_la_SOURCES =					\
 	empathy-tp-contact-list.c			\
 	empathy-tp-chat.c				\
 	empathy-tp-chatroom.c				\
+	empathy-tp-roomlist.c				\
 	empathy-chandler.c				\
 	empathy-filter.c				\
 	empathy-idle.c					\
@@ -57,6 +58,7 @@ libempathy_HEADERS =				\
 	empathy-tp-contact-list.h		\
 	empathy-tp-chat.h			\
 	empathy-tp-chatroom.h			\
+	empathy-tp-roomlist.h			\
 	empathy-chandler.h			\
 	empathy-filter.h			\
 	empathy-idle.h				\
diff --git a/libempathy/empathy-chatroom.h b/libempathy/empathy-chatroom.h
index 20f98ecc6..39dff36db 100644
--- a/libempathy/empathy-chatroom.h
+++ b/libempathy/empathy-chatroom.h
@@ -50,27 +50,27 @@ struct _EmpathyChatroomClass {
 	GObjectClass parent_class;
 };
 
-GType           empathy_chatroom_get_type         (void) G_GNUC_CONST;
-EmpathyChatroom *empathy_chatroom_new              (McAccount      *account,
-						  const gchar    *room);
+GType            empathy_chatroom_get_type        (void) G_GNUC_CONST;
+EmpathyChatroom *empathy_chatroom_new             (McAccount       *account,
+						   const gchar     *room);
 EmpathyChatroom *empathy_chatroom_new_full         (McAccount      *account,
-						  const gchar    *room,
-						  const gchar    *name,
-						  gboolean        auto_connect);
+						   const gchar     *room,
+						   const gchar     *name,
+						   gboolean         auto_connect);
 McAccount *     empathy_chatroom_get_account      (EmpathyChatroom *chatroom);
 void            empathy_chatroom_set_account      (EmpathyChatroom *chatroom,
-						  McAccount      *account);
+						   McAccount       *account);
 const gchar *   empathy_chatroom_get_room         (EmpathyChatroom *chatroom);
 void            empathy_chatroom_set_room         (EmpathyChatroom *chatroom,
-						  const gchar    *room);
+						   const gchar     *room);
 const gchar *   empathy_chatroom_get_name         (EmpathyChatroom *chatroom);
 void            empathy_chatroom_set_name         (EmpathyChatroom *chatroom,
-						  const gchar    *name);
+						   const gchar     *name);
 gboolean        empathy_chatroom_get_auto_connect (EmpathyChatroom *chatroom);
 void            empathy_chatroom_set_auto_connect (EmpathyChatroom *chatroom,
-						  gboolean        auto_connect);
-gboolean        empathy_chatroom_equal            (gconstpointer   v1,
-						  gconstpointer   v2);
+						   gboolean         auto_connect);
+gboolean        empathy_chatroom_equal            (gconstpointer    v1,
+						   gconstpointer    v2);
 
 
 G_BEGIN_DECLS
diff --git a/libempathy/empathy-idle.c b/libempathy/empathy-idle.c
index 5b04d363f..923b499be 100644
--- a/libempathy/empathy-idle.c
+++ b/libempathy/empathy-idle.c
@@ -42,7 +42,7 @@
 #define EXT_AWAY_TIME (30*60)
 
 typedef enum {
-	NM_STATE_UNKNOWN = 0,
+	NM_STATE_UNKNOWN,
 	NM_STATE_ASLEEP,
 	NM_STATE_CONNECTING,
 	NM_STATE_CONNECTED,
@@ -180,16 +180,31 @@ empathy_idle_init (EmpathyIdle *idle)
 							    "org.freedesktop.NetworkManager");
 	}
 	if (priv->nm_proxy) {
+		guint nm_status;
+
 		dbus_g_proxy_add_signal (priv->nm_proxy, "StateChange",
 					 G_TYPE_UINT, G_TYPE_INVALID);
 		dbus_g_proxy_connect_signal (priv->nm_proxy, "StateChange",
 					     G_CALLBACK (idle_nm_state_change_cb),
 					     idle, NULL);
+		dbus_g_proxy_call (priv->nm_proxy, "state",
+				   &error,
+				   G_TYPE_INVALID,
+				   G_TYPE_UINT, &nm_status,
+				   G_TYPE_INVALID);
+		priv->nm_connected = (nm_status == NM_STATE_CONNECTED);
+
+		empathy_debug (DEBUG_DOMAIN, "NetworkManager connected: %s",
+			       priv->nm_connected ? "Yes" : "No");
+
+		if (!priv->nm_connected) {
+			priv->saved_state = priv->state;
+			priv->saved_status = g_strdup (priv->status);
+		}
 	} else {
 		empathy_debug (DEBUG_DOMAIN, "Failed to get nm proxy");
+		priv->nm_connected = TRUE;
 	}
-	/* FIXME: get value */
-	priv->nm_connected = TRUE;
 }
 
 static void
@@ -363,7 +378,13 @@ empathy_idle_set_presence (EmpathyIdle *idle,
 
 	priv = GET_PRIV (idle);
 
+	empathy_debug (DEBUG_DOMAIN, "Changing presence to %s (%d)",
+		       status, state);
+
 	if (!priv->nm_connected) {
+		empathy_debug (DEBUG_DOMAIN,
+			       "NM not connected, saving requested presence");
+
 		g_free (priv->saved_status);
 		priv->saved_state = state;
 		priv->saved_status = g_strdup (status);
@@ -475,8 +496,7 @@ idle_nm_state_change_cb (DBusGProxy  *proxy,
 
 	empathy_debug (DEBUG_DOMAIN, "New network state (%d)", state);
 
-	if (state != NM_STATE_CONNECTED &&
-	    priv->state > MC_PRESENCE_OFFLINE) {
+	if (state != NM_STATE_CONNECTED && priv->nm_connected) {
 		/* We are no more connected */
 		idle_ext_away_stop (idle);
 		g_free (priv->saved_status);
@@ -486,8 +506,7 @@ idle_nm_state_change_cb (DBusGProxy  *proxy,
 		empathy_idle_set_state (idle, MC_PRESENCE_OFFLINE);
 		priv->nm_connected = FALSE;
 	}
-	else if (priv->state <= MC_PRESENCE_OFFLINE &&
-		 state == NM_STATE_CONNECTED) {
+	else if (state == NM_STATE_CONNECTED && !priv->nm_connected) {
 		/* We are now connected */
 		priv->nm_connected = TRUE;
 		empathy_idle_set_presence (idle,
diff --git a/libempathy/empathy-tp-chat.c b/libempathy/empathy-tp-chat.c
index e52b4a086..691d7a2f1 100644
--- a/libempathy/empathy-tp-chat.c
+++ b/libempathy/empathy-tp-chat.c
@@ -88,6 +88,12 @@ static void             tp_chat_sent_cb               (DBusGProxy
 						       guint                      message_type,
 						       gchar                     *message_body,
 						       EmpathyTpChat             *chat);
+static void             tp_chat_send_error_cb         (DBusGProxy                *text_iface,
+						       guint                      error_code,
+						       guint                      timestamp,
+						       guint                      message_type,
+						       gchar                     *message_body,
+						       EmpathyTpChat             *chat);
 static void             tp_chat_state_changed_cb      (DBusGProxy                *chat_state_iface,
 						       guint                      handle,
 						       TelepathyChannelChatState  state,
@@ -127,6 +133,7 @@ enum {
 
 enum {
 	MESSAGE_RECEIVED,
+	SEND_ERROR,
 	CHAT_STATE_CHANGED,
 	DESTROY,
 	LAST_SIGNAL
@@ -291,6 +298,16 @@ empathy_tp_chat_class_init (EmpathyTpChatClass *klass)
 			      G_TYPE_NONE,
 			      1, EMPATHY_TYPE_MESSAGE);
 
+	signals[SEND_ERROR] =
+		g_signal_new ("send-error",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      0,
+			      NULL, NULL,
+			      empathy_marshal_VOID__OBJECT_UINT,
+			      G_TYPE_NONE,
+			      2, EMPATHY_TYPE_MESSAGE, G_TYPE_UINT);
+
 	signals[CHAT_STATE_CHANGED] =
 		g_signal_new ("chat-state-changed",
 			      G_TYPE_FROM_CLASS (klass),
@@ -399,6 +416,9 @@ tp_chat_constructor (GType                  type,
 	dbus_g_proxy_connect_signal (priv->text_iface, "Sent",
 				     G_CALLBACK (tp_chat_sent_cb),
 				     chat, NULL);
+	dbus_g_proxy_connect_signal (priv->text_iface, "SendError",
+				     G_CALLBACK (tp_chat_send_error_cb),
+				     chat, NULL);
 
 	if (priv->chat_state_iface != NULL) {
 		dbus_g_proxy_connect_signal (priv->chat_state_iface,
@@ -733,7 +753,7 @@ empathy_tp_chat_get_id (EmpathyTpChat *chat)
 		return priv->id;
 	}
 
-	priv->id = empathy_get_channel_id (priv->account, priv->tp_chan);
+	priv->id = empathy_inspect_channel (priv->account, priv->tp_chan);
 
 	return priv->id;
 }
@@ -770,7 +790,6 @@ tp_chat_closed_cb (TpChan        *text_chan,
 					      tp_chat_destroy_cb,
 					      chat);
 	tp_chat_destroy_cb (text_chan, chat);
-
 }
 
 static void
@@ -832,6 +851,29 @@ tp_chat_sent_cb (DBusGProxy    *text_iface,
 }
 
 static void
+tp_chat_send_error_cb (DBusGProxy    *text_iface,
+		       guint          error_code,
+		       guint          timestamp,
+		       guint          message_type,
+		       gchar         *message_body,
+		       EmpathyTpChat *chat)
+{
+	EmpathyMessage *message;
+
+	empathy_debug (DEBUG_DOMAIN, "Message sent error: %s (%d)",
+		       message_body, error_code);
+
+	message = tp_chat_build_message (chat,
+					 message_type,
+					 timestamp,
+					 0,
+					 message_body);
+
+	g_signal_emit (chat, signals[SEND_ERROR], 0, message, error_code);
+	g_object_unref (message);
+}
+
+static void
 tp_chat_state_changed_cb (DBusGProxy                *chat_state_iface,
 			  guint                      handle,
 			  TelepathyChannelChatState  state,
diff --git a/libempathy/empathy-tp-chatroom.c b/libempathy/empathy-tp-chatroom.c
index fe8e7f8e7..32716865d 100644
--- a/libempathy/empathy-tp-chatroom.c
+++ b/libempathy/empathy-tp-chatroom.c
@@ -22,8 +22,6 @@
 
 #include <config.h>
 
-#include <libmissioncontrol/mission-control.h>
-
 #include "empathy-tp-chatroom.h"
 #include "empathy-tp-contact-list.h"
 #include "empathy-contact-list.h"
@@ -130,8 +128,6 @@ empathy_tp_chatroom_new (McAccount *account,
 {
 	EmpathyTpChatroomPriv *priv;
 	EmpathyTpChatroom     *chatroom;
-	TpConn                *tp_conn;
-	MissionControl        *mc;
 	GList                 *members, *l;
 	guint                  self_handle;
 
@@ -145,11 +141,9 @@ empathy_tp_chatroom_new (McAccount *account,
 
 	priv = GET_PRIV (chatroom);
 
-	mc = empathy_mission_control_new ();
-	tp_conn = mission_control_get_connection (mc, account, NULL);
 	priv->manager = empathy_contact_manager_new ();
 	priv->list = empathy_contact_manager_get_list (priv->manager, account);
-	priv->group = empathy_tp_group_new (tp_chan, tp_conn);
+	priv->group = empathy_tp_group_new (account, tp_chan);
 
 	g_signal_connect (priv->group, "members-added",
 			  G_CALLBACK (tp_chatroom_members_added_cb),
@@ -181,8 +175,6 @@ empathy_tp_chatroom_new (McAccount *account,
 	}
 
 	empathy_tp_group_info_list_free (members);
-	g_object_unref (mc);
-	g_object_unref (tp_conn);
 
 	return chatroom;
 }
diff --git a/libempathy/empathy-tp-contact-list.c b/libempathy/empathy-tp-contact-list.c
index 4dedb4fef..8ecf564e3 100644
--- a/libempathy/empathy-tp-contact-list.c
+++ b/libempathy/empathy-tp-contact-list.c
@@ -24,6 +24,7 @@
 #include <config.h>
 
 #include <string.h>
+#include <glib/gi18n.h>
 
 #include <libtelepathy/tp-helpers.h>
 #include <libtelepathy/tp-conn.h>
@@ -51,6 +52,7 @@ struct _EmpathyTpContactListPriv {
 	MissionControl *mc;
 	EmpathyContact *user_contact;
 	gboolean        setup;
+	const gchar    *protocol_group;
 
 	EmpathyTpGroup *publish;
 	EmpathyTpGroup *subscribe;
@@ -322,6 +324,8 @@ empathy_tp_contact_list_new (McAccount *account)
 	EmpathyTpContactListPriv *priv;
 	EmpathyTpContactList     *list;
 	MissionControl           *mc;
+	McProfile                *profile;
+	const gchar              *protocol_name;
 	guint                     handle;
 	GError                   *error = NULL;
 
@@ -341,6 +345,16 @@ empathy_tp_contact_list_new (McAccount *account)
 	priv->account = g_object_ref (account);
 	priv->mc = mc;
 
+	/* Check for protocols that does not support contact groups. We can
+	 * put all contacts into a special group in that case.
+	 * FIXME: Default group should be an information in the profile */
+	profile = mc_account_get_profile (account);
+	protocol_name = mc_profile_get_protocol_name (profile);
+	if (strcmp (protocol_name, "salut") == 0) {
+		priv->protocol_group = _("Local Network");
+	}
+	g_object_unref (profile);
+
 	g_signal_connect (priv->tp_conn, "destroy",
 			  G_CALLBACK (tp_contact_list_destroy_cb),
 			  list);
@@ -704,7 +718,7 @@ empathy_tp_contact_list_get_from_handles (EmpathyTpContactList *list,
 	/* Create contact objects */
 	for (i = 0, id = handles_names; *id && i < new_handles->len; id++, i++) {
 		EmpathyContact *contact;
-		guint          handle;
+		guint           handle;
 
 		handle = g_array_index (new_handles, guint, i);
 		contact = g_object_new (EMPATHY_TYPE_CONTACT,
@@ -713,6 +727,10 @@ empathy_tp_contact_list_get_from_handles (EmpathyTpContactList *list,
 					"handle", handle,
 					NULL);
 
+		if (priv->protocol_group) {
+			empathy_contact_add_group (contact, priv->protocol_group);
+		}
+
 		if (!priv->presence_iface) {
 			EmpathyPresence *presence;
 
@@ -960,7 +978,7 @@ tp_contact_list_newchannel_cb (DBusGProxy           *proxy,
 	if (handle_type == TP_HANDLE_TYPE_LIST) {
 		TpContactListType list_type;
 
-		group = empathy_tp_group_new (new_chan, priv->tp_conn);
+		group = empathy_tp_group_new (priv->account, new_chan);
 
 		list_type = tp_contact_list_get_type (list, group);
 		if (list_type == TP_CONTACT_LIST_TYPE_UNKNOWN) {
@@ -1058,7 +1076,7 @@ tp_contact_list_newchannel_cb (DBusGProxy           *proxy,
 			return;
 		}
 
-		group = empathy_tp_group_new (new_chan, priv->tp_conn);
+		group = empathy_tp_group_new (priv->account, new_chan);
 
 		empathy_debug (DEBUG_DOMAIN, "New server-side group channel: %s",
 			      empathy_tp_group_get_name (group));
@@ -1472,7 +1490,7 @@ tp_contact_list_get_group (EmpathyTpContactList *list,
 				     list,
 				     NULL);
 
-	group = empathy_tp_group_new (group_channel, priv->tp_conn);
+	group = empathy_tp_group_new (priv->account, group_channel);
 	g_hash_table_insert (priv->groups, group_object_path, group);
 	g_signal_connect (group, "members-added",
 			  G_CALLBACK (tp_contact_list_group_members_added_cb),
diff --git a/libempathy/empathy-tp-group.c b/libempathy/empathy-tp-group.c
index 65e52f091..b86a00e28 100644
--- a/libempathy/empathy-tp-group.c
+++ b/libempathy/empathy-tp-group.c
@@ -28,6 +28,7 @@
 
 #include "empathy-debug.h"
 #include "empathy-tp-group.h"
+#include "empathy-utils.h"
 #include "empathy-marshal.h"
 
 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
@@ -36,8 +37,8 @@
 #define DEBUG_DOMAIN "TpGroup"
 
 struct _EmpathyTpGroupPriv {
+	McAccount  *account;
 	DBusGProxy *group_iface;
-	TpConn     *tp_conn;
 	TpChan     *tp_chan;
 	gchar      *group_name;
 };
@@ -141,8 +142,8 @@ tp_group_finalize (GObject *object)
 		g_object_unref (priv->group_iface);
 	}
 
-	if (priv->tp_conn) {
-		g_object_unref (priv->tp_conn);
+	if (priv->account) {
+		g_object_unref (priv->account);
 	}
 
 	if (priv->tp_chan) {
@@ -155,15 +156,15 @@ tp_group_finalize (GObject *object)
 }
 
 EmpathyTpGroup *
-empathy_tp_group_new (TpChan *tp_chan,
-		      TpConn *tp_conn)
+empathy_tp_group_new (McAccount *account,
+		      TpChan    *tp_chan)
 {
 	EmpathyTpGroup     *group;
 	EmpathyTpGroupPriv *priv;
 	DBusGProxy         *group_iface;
 
 	g_return_val_if_fail (TELEPATHY_IS_CHAN (tp_chan), NULL);
-	g_return_val_if_fail (TELEPATHY_IS_CONN (tp_conn), NULL);
+	g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 
 	group_iface = tp_chan_get_interface (tp_chan,
 					     TELEPATHY_CHAN_IFACE_GROUP_QUARK);
@@ -172,7 +173,7 @@ empathy_tp_group_new (TpChan *tp_chan,
 	group = g_object_new (EMPATHY_TYPE_TP_GROUP, NULL);
 	priv = GET_PRIV (group);
 
-	priv->tp_conn = g_object_ref (tp_conn);
+	priv->account = g_object_ref (account);
 	priv->tp_chan = g_object_ref (tp_chan);
 	priv->group_iface = g_object_ref (group_iface);
 
@@ -393,11 +394,9 @@ tp_group_destroy_cb (DBusGProxy     *proxy,
 	priv = GET_PRIV (group);
 
 	g_object_unref (priv->group_iface);
-	g_object_unref (priv->tp_conn);
 	g_object_unref (priv->tp_chan);
 	priv->group_iface = NULL;
 	priv->tp_chan = NULL;
-	priv->tp_conn = NULL;
 }
 
 static void
@@ -437,12 +436,6 @@ tp_group_members_changed_cb (DBusGProxy     *group_iface,
 const gchar *
 empathy_tp_group_get_name (EmpathyTpGroup *group)
 {
-	TelepathyHandleType  handle_type;
-	guint                channel_handle;
-	GArray              *group_handles;
-	gchar              **group_names;
-	GError              *error = NULL;
-
 	EmpathyTpGroupPriv *priv;
 
 	g_return_val_if_fail (EMPATHY_IS_TP_GROUP (group), NULL);
@@ -454,35 +447,7 @@ empathy_tp_group_get_name (EmpathyTpGroup *group)
 		return priv->group_name;
 	}
 
-	if (!tp_chan_get_handle (DBUS_G_PROXY (priv->tp_chan),
-				 &handle_type,
-				 &channel_handle,
-				 &error)) {
-		empathy_debug (DEBUG_DOMAIN, 
-			      "Couldn't retreive channel handle for group: %s",
-			      error ? error->message : "No error given");
-		g_clear_error (&error);
-		return NULL;
-	}
-
-	group_handles = g_array_new (FALSE, FALSE, sizeof (guint));
-	g_array_append_val (group_handles, channel_handle);
-	if (!tp_conn_inspect_handles (DBUS_G_PROXY (priv->tp_conn),
-				      handle_type,
-				      group_handles,
-				      &group_names,
-				      &error)) {
-		empathy_debug (DEBUG_DOMAIN, 
-			      "Couldn't get group name: %s",
-			      error ? error->message : "No error given");
-		g_clear_error (&error);
-		g_array_free (group_handles, TRUE);
-		return NULL;
-	}
-
-	priv->group_name = *group_names;
-	g_array_free (group_handles, TRUE);
-	g_free (group_names);
+	priv->group_name = empathy_inspect_channel (priv->account, priv->tp_chan);
 
 	return priv->group_name;
 }
diff --git a/libempathy/empathy-tp-group.h b/libempathy/empathy-tp-group.h
index 2381ea10e..5ea7bfc71 100644
--- a/libempathy/empathy-tp-group.h
+++ b/libempathy/empathy-tp-group.h
@@ -24,6 +24,7 @@
 #include <glib.h>
 
 #include <libtelepathy/tp-chan.h>
+#include <libmissioncontrol/mc-account.h>
 
 G_BEGIN_DECLS
 
@@ -54,8 +55,8 @@ typedef struct {
 } EmpathyTpGroupInfo;
 
 GType            empathy_tp_group_get_type                            (void) G_GNUC_CONST;
-EmpathyTpGroup * empathy_tp_group_new                                 (TpChan          *tp_chan,
-								       TpConn          *tp_conn);
+EmpathyTpGroup * empathy_tp_group_new                                 (McAccount       *account,
+								       TpChan          *tp_chan);
 void             empathy_tp_group_add_members                         (EmpathyTpGroup  *group,
 								       GArray          *handles,
 								       const gchar     *message);
diff --git a/libempathy/empathy-tp-roomlist.c b/libempathy/empathy-tp-roomlist.c
new file mode 100644
index 000000000..a91d1ba07
--- /dev/null
+++ b/libempathy/empathy-tp-roomlist.c
@@ -0,0 +1,352 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * Copyright (C) 2007 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ * 
+ * Authors: Xavier Claessens <xclaesse@gmail.com>
+ */
+
+#include <config.h>
+
+#include <string.h>
+
+#include <libtelepathy/tp-chan-type-room-list-gen.h>
+#include <libtelepathy/tp-helpers.h>
+#include <libtelepathy/tp-conn.h>
+#include <libtelepathy/tp-chan.h>
+
+#include <libmissioncontrol/mission-control.h>
+
+#include "empathy-tp-roomlist.h"
+#include "empathy-chatroom.h"
+#include "empathy-utils.h"
+#include "empathy-debug.h"
+
+#define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
+		       EMPATHY_TYPE_TP_ROOMLIST, EmpathyTpRoomlistPriv))
+
+#define DEBUG_DOMAIN "TpRoomlist"
+
+struct _EmpathyTpRoomlistPriv {
+	McAccount  *account;
+	TpChan     *tp_chan;
+	DBusGProxy *roomlist_iface;
+};
+
+static void empathy_tp_roomlist_class_init (EmpathyTpRoomlistClass *klass);
+static void empathy_tp_roomlist_init       (EmpathyTpRoomlist      *chat);
+static void tp_roomlist_finalize           (GObject                *object);
+static void tp_roomlist_destroy_cb         (TpChan                 *tp_chan,
+					    EmpathyTpRoomlist      *list);
+static void tp_roomlist_closed_cb          (TpChan                 *tp_chan,
+					    EmpathyTpRoomlist      *list);
+static void tp_roomlist_listing_cb         (DBusGProxy             *roomlist_iface,
+					    gboolean                listing,
+					    EmpathyTpRoomlist      *list);
+static void tp_roomlist_got_rooms_cb       (DBusGProxy             *roomlist_iface,
+					    GPtrArray              *room_list,
+					    EmpathyTpRoomlist      *list);
+
+enum {
+	NEW_ROOM,
+	LISTING,
+	DESTROY,
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+G_DEFINE_TYPE (EmpathyTpRoomlist, empathy_tp_roomlist, G_TYPE_OBJECT);
+
+static void
+empathy_tp_roomlist_class_init (EmpathyTpRoomlistClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->finalize = tp_roomlist_finalize;
+
+	signals[NEW_ROOM] =
+		g_signal_new ("new-room",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      0,
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__OBJECT,
+			      G_TYPE_NONE,
+			      1, EMPATHY_TYPE_CHATROOM);
+
+	signals[LISTING] =
+		g_signal_new ("listing",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      0,
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__BOOLEAN,
+			      G_TYPE_NONE,
+			      1, G_TYPE_BOOLEAN);
+
+	signals[DESTROY] =
+		g_signal_new ("destroy",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      0,
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__VOID,
+			      G_TYPE_NONE,
+			      0);
+
+	g_type_class_add_private (object_class, sizeof (EmpathyTpRoomlistPriv));
+}
+
+static void
+empathy_tp_roomlist_init (EmpathyTpRoomlist *list)
+{
+}
+
+static void
+tp_roomlist_finalize (GObject *object)
+{
+	EmpathyTpRoomlistPriv *priv;
+	GError                *error = NULL;
+
+	priv = GET_PRIV (object);
+
+	if (priv->tp_chan) {
+		g_signal_handlers_disconnect_by_func (priv->tp_chan,
+						      tp_roomlist_destroy_cb,
+						      object);
+
+		empathy_debug (DEBUG_DOMAIN, "Closing channel...");
+		if (!tp_chan_close (DBUS_G_PROXY (priv->tp_chan), &error)) {
+			empathy_debug (DEBUG_DOMAIN, 
+				      "Error closing roomlist channel: %s",
+				      error ? error->message : "No error given");
+			g_clear_error (&error);
+		}
+		g_object_unref (priv->tp_chan);
+	}
+
+	if (priv->account) {
+		g_object_unref (priv->account);
+	}
+
+	G_OBJECT_CLASS (empathy_tp_roomlist_parent_class)->finalize (object);
+}
+
+EmpathyTpRoomlist *
+empathy_tp_roomlist_new (McAccount *account)
+{
+	EmpathyTpRoomlist     *list;
+	EmpathyTpRoomlistPriv *priv;
+	TpConn                *tp_conn;
+	MissionControl        *mc;
+	const gchar           *bus_name;
+
+	g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
+
+	list = g_object_new (EMPATHY_TYPE_TP_ROOMLIST, NULL);
+	priv = GET_PRIV (list);
+
+	mc = empathy_mission_control_new ();
+	tp_conn = mission_control_get_connection (mc, account, NULL);
+	g_object_unref (mc);
+
+	bus_name = dbus_g_proxy_get_bus_name (DBUS_G_PROXY (tp_conn));
+	priv->tp_chan = tp_conn_new_channel (tp_get_bus (),
+					     tp_conn,
+					     bus_name,
+					     TP_IFACE_CHANNEL_TYPE_ROOM_LIST,
+					     TP_HANDLE_TYPE_NONE,
+					     0,
+					     TRUE);
+	g_object_unref (tp_conn);
+
+	if (!priv->tp_chan) {
+		empathy_debug (DEBUG_DOMAIN, "Failed to get roomlist channel");
+		g_object_unref (list);
+		return NULL;
+	}
+
+	priv->account = g_object_ref (account);
+	priv->roomlist_iface = tp_chan_get_interface (priv->tp_chan,
+						      TELEPATHY_CHAN_IFACE_ROOMLIST_QUARK);
+
+	g_signal_connect (priv->tp_chan, "destroy",
+			  G_CALLBACK (tp_roomlist_destroy_cb),
+			  list);
+	dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->tp_chan), "Closed",
+				     G_CALLBACK (tp_roomlist_closed_cb),
+				     list, NULL);
+	dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->roomlist_iface), "ListingRooms",
+				     G_CALLBACK (tp_roomlist_listing_cb),
+				     list, NULL);
+	dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->roomlist_iface), "GotRooms",
+				     G_CALLBACK (tp_roomlist_got_rooms_cb),
+				     list, NULL);
+
+	return list;
+}
+
+gboolean
+empathy_tp_roomlist_is_listing (EmpathyTpRoomlist *list)
+{
+	EmpathyTpRoomlistPriv *priv;
+	GError                *error = NULL;
+	gboolean               listing = FALSE;
+
+	g_return_val_if_fail (EMPATHY_IS_TP_ROOMLIST (list), FALSE);
+
+	priv = GET_PRIV (list);
+
+	if (!tp_chan_type_room_list_get_listing_rooms (priv->roomlist_iface,
+						       &listing,
+						       &error)) {
+		empathy_debug (DEBUG_DOMAIN, 
+			      "Error GetListingRooms: %s",
+			      error ? error->message : "No error given");
+		g_clear_error (&error);
+		return FALSE;
+	}
+
+	return listing;
+}
+
+void
+empathy_tp_roomlist_start (EmpathyTpRoomlist *list)
+{
+	EmpathyTpRoomlistPriv *priv;
+	GError                *error = NULL;
+
+	g_return_if_fail (EMPATHY_IS_TP_ROOMLIST (list));
+
+	priv = GET_PRIV (list);
+
+	if (!tp_chan_type_room_list_list_rooms (priv->roomlist_iface, &error)) {
+		empathy_debug (DEBUG_DOMAIN, 
+			      "Error ListRooms: %s",
+			      error ? error->message : "No error given");
+		g_clear_error (&error);
+	}
+}
+
+void
+empathy_tp_roomlist_stop (EmpathyTpRoomlist *list)
+{
+	EmpathyTpRoomlistPriv *priv;
+	GError                *error = NULL;
+
+	g_return_if_fail (EMPATHY_IS_TP_ROOMLIST (list));
+
+	priv = GET_PRIV (list);
+
+	if (!tp_chan_type_room_list_stop_listing (priv->roomlist_iface, &error)) {
+		empathy_debug (DEBUG_DOMAIN, 
+			      "Error StopListing: %s",
+			      error ? error->message : "No error given");
+		g_clear_error (&error);
+	}
+}
+
+static void
+tp_roomlist_destroy_cb (TpChan            *tp_chan,
+			EmpathyTpRoomlist *list)
+{
+	EmpathyTpRoomlistPriv *priv;
+
+	priv = GET_PRIV (list);
+
+	empathy_debug (DEBUG_DOMAIN, "Channel Closed or CM crashed");
+
+	tp_roomlist_listing_cb (priv->roomlist_iface, FALSE, list);
+
+	g_object_unref  (priv->tp_chan);
+	priv->tp_chan = NULL;
+	priv->roomlist_iface = NULL;
+
+	g_signal_emit (list, signals[DESTROY], 0);
+}
+
+static void
+tp_roomlist_closed_cb (TpChan            *tp_chan,
+		       EmpathyTpRoomlist *list)
+{
+	EmpathyTpRoomlistPriv *priv;
+
+	priv = GET_PRIV (list);
+
+	/* The channel is closed, do just like if the proxy was destroyed */
+	g_signal_handlers_disconnect_by_func (priv->tp_chan,
+					      tp_roomlist_destroy_cb,
+					      list);
+	tp_roomlist_destroy_cb (priv->tp_chan, list);
+}
+
+static void
+tp_roomlist_listing_cb (DBusGProxy        *roomlist_iface,
+			gboolean           listing,
+			EmpathyTpRoomlist *list)
+{
+	empathy_debug (DEBUG_DOMAIN, "Listing: %s", listing ? "Yes" : "No");
+	g_signal_emit (list, signals[LISTING], 0, listing);
+}
+
+static void
+tp_roomlist_got_rooms_cb (DBusGProxy        *roomlist_iface,
+			  GPtrArray         *room_list,
+			  EmpathyTpRoomlist *list)
+{
+	EmpathyTpRoomlistPriv *priv;
+	guint                  i;
+
+	priv = GET_PRIV (list);
+
+	g_print ("Got negsghgfdhgfdhgfdw room !!!");
+
+	for (i = 0; i < room_list->len; i++) {
+		EmpathyChatroom *chatroom;
+		gchar           *room_id;
+		const gchar     *room_name;
+		GValueArray     *room_struct;
+		guint            handle;
+		const gchar     *channel_type;
+		GHashTable      *info;
+
+		/* Get information */
+		room_struct = g_ptr_array_index (room_list, i);
+		handle = g_value_get_uint (g_value_array_get_nth (room_struct, 0));
+		channel_type = g_value_get_string (g_value_array_get_nth (room_struct, 1));
+		info = g_value_get_boxed (g_value_array_get_nth (room_struct, 0));
+
+		g_print ("Got new room !!!");
+
+		/* Create the chatroom */
+		room_name = g_hash_table_lookup (info, "name");
+		room_id = empathy_inspect_handle (priv->account,
+						  handle,
+						  TP_HANDLE_TYPE_ROOM);
+		chatroom = empathy_chatroom_new_full (priv->account,
+						      room_id,
+						      room_name,
+						      FALSE);
+
+		/* Tells the world */
+		g_signal_emit (list, signals[NEW_ROOM], 0, chatroom);
+
+		g_object_unref (chatroom);
+	}
+}
+
diff --git a/libempathy/empathy-tp-roomlist.h b/libempathy/empathy-tp-roomlist.h
new file mode 100644
index 000000000..4faa6d9c6
--- /dev/null
+++ b/libempathy/empathy-tp-roomlist.h
@@ -0,0 +1,59 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * Copyright (C) 2007 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Authors: Xavier Claessens <xclaesse@gmail.com>
+ */
+
+#ifndef __EMPATHY_TP_ROOMLIST_H__
+#define __EMPATHY_TP_ROOMLIST_H__
+
+#include <glib.h>
+
+#include <libmissioncontrol/mc-account.h>
+
+G_BEGIN_DECLS
+
+#define EMPATHY_TYPE_TP_ROOMLIST         (empathy_tp_roomlist_get_type ())
+#define EMPATHY_TP_ROOMLIST(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), EMPATHY_TYPE_TP_ROOMLIST, EmpathyTpRoomlist))
+#define EMPATHY_TP_ROOMLIST_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), EMPATHY_TYPE_TP_ROOMLIST, EmpathyTpRoomlistClass))
+#define EMPATHY_IS_TP_ROOMLIST(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), EMPATHY_TYPE_TP_ROOMLIST))
+#define EMPATHY_IS_TP_ROOMLIST_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), EMPATHY_TYPE_TP_ROOMLIST))
+#define EMPATHY_TP_ROOMLIST_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EMPATHY_TYPE_TP_ROOMLIST, EmpathyTpRoomlistClass))
+
+typedef struct _EmpathyTpRoomlist      EmpathyTpRoomlist;
+typedef struct _EmpathyTpRoomlistClass EmpathyTpRoomlistClass;
+typedef struct _EmpathyTpRoomlistPriv  EmpathyTpRoomlistPriv;
+
+struct _EmpathyTpRoomlist {
+	GObject      parent;
+};
+
+struct _EmpathyTpRoomlistClass {
+	GObjectClass parent_class;
+};
+
+GType              empathy_tp_roomlist_get_type   (void) G_GNUC_CONST;
+EmpathyTpRoomlist *empathy_tp_roomlist_new        (McAccount *account);
+gboolean           empathy_tp_roomlist_is_listing (EmpathyTpRoomlist *list);
+void               empathy_tp_roomlist_start      (EmpathyTpRoomlist *list);
+void               empathy_tp_roomlist_stop       (EmpathyTpRoomlist *list);
+
+G_END_DECLS
+
+#endif /* __EMPATHY_TP_ROOMLIST_H__ */
diff --git a/libempathy/empathy-utils.c b/libempathy/empathy-utils.c
index 74a6bc076..2bb171976 100644
--- a/libempathy/empathy-utils.c
+++ b/libempathy/empathy-utils.c
@@ -446,8 +446,21 @@ empathy_mission_control_new (void)
 }
 
 gchar *
-empathy_get_channel_id (McAccount *account,
-		       TpChan    *tp_chan)
+empathy_inspect_channel (McAccount *account,
+		         TpChan    *tp_chan)
+{
+	g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
+	g_return_val_if_fail (TELEPATHY_IS_CHAN (tp_chan), NULL);
+
+	return empathy_inspect_handle (account,
+				       tp_chan->handle,
+				       tp_chan->handle_type);
+}
+
+gchar *
+empathy_inspect_handle (McAccount *account,
+			guint      handle,
+			guint      handle_type)
 {
 	MissionControl  *mc;
 	TpConn          *tp_conn;
@@ -457,7 +470,8 @@ empathy_get_channel_id (McAccount *account,
 	GError          *error;
 
 	g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
-	g_return_val_if_fail (TELEPATHY_IS_CHAN (tp_chan), NULL);
+	g_return_val_if_fail (handle != 0, NULL);
+	g_return_val_if_fail (handle_type != 0, NULL);
 
 	mc = empathy_mission_control_new ();
 	tp_conn = mission_control_get_connection (mc, account, NULL);
@@ -469,9 +483,9 @@ empathy_get_channel_id (McAccount *account,
 
 	/* Get the handle's name */
 	handles = g_array_new (FALSE, FALSE, sizeof (guint));
-	g_array_append_val (handles, tp_chan->handle);
+	g_array_append_val (handles, handle);
 	if (!tp_conn_inspect_handles (DBUS_G_PROXY (tp_conn),
-				      tp_chan->handle_type,
+				      handle_type,
 				      handles,
 				      &names,
 				      &error)) {
@@ -493,3 +507,4 @@ empathy_get_channel_id (McAccount *account,
 	return name;
 }
 
+
diff --git a/libempathy/empathy-utils.h b/libempathy/empathy-utils.h
index 17be9ed3c..da56174bd 100644
--- a/libempathy/empathy-utils.h
+++ b/libempathy/empathy-utils.h
@@ -92,8 +92,11 @@ guint        empathy_account_hash                   (gconstpointer    key);
 gboolean     empathy_account_equal                  (gconstpointer    a,
 						    gconstpointer    b);
 MissionControl *empathy_mission_control_new         (void);
-gchar *      empathy_get_channel_id                 (McAccount       *account,
-						    TpChan          *tp_chan);
+gchar *      empathy_inspect_handle                 (McAccount       *account,
+						     guint            handle,
+						     guint            handle_type);
+gchar *      empathy_inspect_channel                (McAccount       *account,
+						     TpChan          *tp_chan);
 
 G_END_DECLS