adium / Plugins / Purple Service / adiumPurpleConversation.m

/*

 * Adium is the legal property of its developers, whose names are listed in the copyright file included

 * with this source distribution.

 *

 * 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.

 */

#import "adiumPurpleConversation.h"

#import <AIUtilities/AIObjectAdditions.h>

#import <AIUtilities/AIAttributedStringAdditions.h>

#import <Adium/AIChat.h>

#import <Adium/AIContentTyping.h>

#import <Adium/AIHTMLDecoder.h>

#import <Adium/AIListContact.h>

#import <Adium/AIContentControllerProtocol.h>

#import "AINudgeBuzzHandlerPlugin.h"

#pragma mark Purple Images

#pragma mark Conversations

static void adiumPurpleConvCreate(PurpleConversation *conv)

{

	//Pass chats along to the account

	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {

		AIChat *chat = groupChatLookupFromConv(conv);

		[accountLookup(purple_conversation_get_account(conv)) addChat:chat];

	}

}

static void adiumPurpleConvDestroy(PurpleConversation *conv)

{

	/* Purple is telling us a conv was destroyed.  We've probably already cleaned up, but be sure in case purple calls this

	 * when we don't ask it to (for example if we are summarily kicked from a chat room and purple closes the 'window').

	 */

	AIChat *chat = (AIChat *)conv->ui_data;

	AILogWithSignature(@"%p: %@", conv, chat);

	//Chat will be nil if we've already cleaned up, at which point no further action is needed.

	if (chat) {

		[accountLookup(purple_conversation_get_account(conv)) chatWasDestroyed:chat];

		[chat setIdentifier:nil];

		[chat release];

		conv->ui_data = nil;

	}

}

static void adiumPurpleConvWriteChat(PurpleConversation *conv, const char *who,

								   const char *message, PurpleMessageFlags flags,

								   time_t mtime)

{

	/* We only care about this if:

	 *	1) It does not have the PURPLE_MESSAGE_SEND flag, which is set if Purple is sending a sent message back to us -or-

	 *  2) It is a delayed (history) message from a chat

	 */

	if (!(flags & PURPLE_MESSAGE_SEND) || (flags & PURPLE_MESSAGE_DELAYED)) {

		NSDictionary	*messageDict;

		NSString		*messageString;

		messageString = [NSString stringWithUTF8String:message];

		AILog(@"Source: %s \t Name: %s \t MyNick: %s : Message %@", 

			  who,

			  purple_conversation_get_name(conv),

			  purple_conv_chat_get_nick(PURPLE_CONV_CHAT(conv)),

			  messageString);

		NSDate				*date = [NSDate dateWithTimeIntervalSince1970:mtime];

		PurpleAccount		*purpleAccount = purple_conversation_get_account(conv);

		if ((flags & PURPLE_MESSAGE_SYSTEM) == PURPLE_MESSAGE_SYSTEM || !who) {

			CBPurpleAccount *account = accountLookup(purpleAccount);

			[account receivedEventForChat:groupChatLookupFromConv(conv)

								  message:messageString

									 date:date

									flags:flags];

		} else {

			NSAttributedString	*attributedMessage = [AIHTMLDecoder decodeHTML:messageString];

			NSNumber			*purpleMessageFlags = [NSNumber numberWithInteger:flags];

			NSString			*normalizedUID = get_real_name_for_account_conv_buddy(purpleAccount, conv, (char *)who);

			if (normalizedUID.length) {

				messageDict = [NSDictionary dictionaryWithObjectsAndKeys:attributedMessage, @"AttributedMessage",

							   normalizedUID, @"Source",

							   purpleMessageFlags, @"PurpleMessageFlags",

							   date, @"Date",nil];

			} else {

				messageDict = [NSDictionary dictionaryWithObjectsAndKeys:attributedMessage, @"AttributedMessage",

							   purpleMessageFlags, @"PurpleMessageFlags",

							   date, @"Date",nil];

			}

			[accountLookup(purple_conversation_get_account(conv)) receivedMultiChatMessage:messageDict inChat:groupChatLookupFromConv(conv)];

		}

	}

}

static void adiumPurpleConvWriteIm(PurpleConversation *conv, const char *who,

								 const char *message, PurpleMessageFlags flags,

								 time_t mtime)

{

	//We only care about this if it does not have the PURPLE_MESSAGE_SEND flag, which is set if Purple is sending a sent message back to us

	if ((flags & PURPLE_MESSAGE_SEND) == 0) {

		if (flags & PURPLE_MESSAGE_NOTIFY) {

			// We received a notification (nudge or buzz). Send a notification of such.

			NSString *type, *messageString = [NSString stringWithUTF8String:message];

			// Determine what we're actually notifying about.

			if ([messageString rangeOfString:@"nudge" options:(NSCaseInsensitiveSearch | NSLiteralSearch)].location != NSNotFound) {

				type = @"Nudge";

			} else if ([messageString rangeOfString:@"buzz" options:(NSCaseInsensitiveSearch | NSLiteralSearch)].location != NSNotFound) {

				type = @"Buzz";

			} else {

				// Just call an unknown type a "notification"

				type = @"notification";

			}

			[[NSNotificationCenter defaultCenter] postNotificationName:Chat_NudgeBuzzOccured

																			   object:chatLookupFromConv(conv)

																			 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:

																					   type, @"Type",

																					   nil]];

		} else {

			NSDictionary		*messageDict;

			CBPurpleAccount		*adiumAccount = accountLookup(purple_conversation_get_account(conv));

			NSString			*messageString;

			AIChat				*chat;

			messageString = [NSString stringWithUTF8String:message];

			chat = chatLookupFromConv(conv);

			AILog(@"adiumPurpleConvWriteIm: Received %@ from %@", messageString, chat.listObject.UID);

			//Process any purple imgstore references into real HTML tags pointing to real images

			messageString = processPurpleImages(messageString, adiumAccount);

			messageDict = [NSDictionary dictionaryWithObjectsAndKeys:messageString,@"Message",

						   [NSNumber numberWithInteger:flags],@"PurpleMessageFlags",

						   [NSDate dateWithTimeIntervalSince1970:mtime],@"Date",nil];

			[adiumAccount receivedIMChatMessage:messageDict

										 inChat:chat];

		}

	}

}

static void adiumPurpleConvWriteConv(PurpleConversation *conv, const char *who, const char *alias,

								   const char *message, PurpleMessageFlags flags,

								   time_t mtime)

{

	AILog(@"adiumPurpleConvWriteConv: Received %s from %s [%i]",message,who,flags);

	AIChat	*chat = chatLookupFromConv(conv);

	if (!chat) {

		return;

	}

	NSString			*messageString = [NSString stringWithUTF8String:message];

	if (!messageString) {

		AILogWithSignature(@"Received write without message: %@ %d", chat, flags);

		return;

	}

	if (flags & PURPLE_MESSAGE_ERROR) {	

		if ([messageString rangeOfString:@"User information not available"].location != NSNotFound) {

			//Ignore user information errors; they are irrelevent

			//XXX The user info check only works in English; libpurple should be modified to be better about this useless information spamming

			return;

		}

		AIChatErrorType	errorType = AIChatUnknownError;

		if (([messageString rangeOfString:[NSString stringWithUTF8String:_("Not logged in")]].location != NSNotFound) || 

			([messageString rangeOfString:[NSString stringWithUTF8String:_("User temporarily unavailable")]].location != NSNotFound)) {

			errorType = AIChatMessageSendingUserNotAvailable;

		} else if ([messageString rangeOfString:[NSString stringWithUTF8String:_("In local permit/deny")]].location != NSNotFound) {

			errorType = AIChatMessageSendingUserIsBlocked;

		} else if (([messageString rangeOfString:[NSString stringWithUTF8String:_("Reply too big")]].location != NSNotFound) ||

				   ([messageString rangeOfString:@"message is too large"].location != NSNotFound)) {

			//XXX - there may be other conditions, but this seems the most common so that's how we'll classify it

			errorType = AIChatMessageSendingTooLarge;

		} else if ([messageString rangeOfString:[NSString stringWithUTF8String:_("Command failed")]].location != NSNotFound) {

			errorType = AIChatCommandFailed;

		} else if ([messageString rangeOfString:[NSString stringWithUTF8String:_("Wrong number of arguments")]].location != NSNotFound) {

			errorType = AIChatInvalidNumberOfArguments;

		} else if ([messageString rangeOfString:[NSString stringWithUTF8String:_("Rate")]].location != NSNotFound) {

			//XXX Is 'Rate' really a standalone translated string?

			errorType = AIChatMessageSendingMissedRateLimitExceeded;

		} else if ([messageString rangeOfString:[NSString stringWithUTF8String:_("Too evil")]].location != NSNotFound) {

			errorType = AIChatMessageReceivingMissedRemoteIsTooEvil;

		}

		/* Another is 'refused by client', which is definitely seen when sending an offline message to an invalid screenname...

		 * but I don't know when else it is sent. -evands

		 */

		/* We will wait until the next run loop, in case this error message was generated by

		 * the sending of a message. This allows the results of sending the message to be displayed

		 * first.

		 */

		if (errorType != AIChatUnknownError) {

			[accountLookup(purple_conversation_get_account(conv)) performSelector:@selector(errorForChat:type:)

			 withObject:chat

			 withObject:[NSNumber numberWithInteger:errorType]

			 afterDelay:0];

		} else {

			[adium.contentController performSelector:@selector(displayEvent:ofType:inChat:)

			 withObject:messageString

			 withObject:@"libpurpleMessage"

			 withObject:chat

			 afterDelay:0];

		}

		AILog(@"*** Conversation error %@: %@", chat, messageString);

	} else if (flags & PURPLE_MESSAGE_RAW)

	{

		[adium.contentController performSelector:@selector(displayEvent:ofType:inChat:)

									  withObject:messageString

									  withObject:@"libpurpleMessage"

									  withObject:chat

									  afterDelay:0];

	} else {

		BOOL				shouldDisplayMessage = TRUE;

		if (strcmp(message, _("Direct IM established")) == 0) {

			[accountLookup(purple_conversation_get_account(conv)) updateContact:chat.listObject

											   forEvent:[NSNumber numberWithInteger:PURPLE_BUDDY_DIRECTIM_CONNECTED]];

			shouldDisplayMessage = FALSE;

		} else {

			BOOL isClosingDirectIM = FALSE;

			if ((strcmp(message, _("The remote user has closed the connection.")) == 0) ||

				(strcmp(message, _("The remote user has declined your request.")) == 0) ||

				(strcmp(message, _("Received invalid data on connection with remote user.")) == 0) ||

				(strcmp(message, _("Could not establish a connection with the remote user.")) == 0)) {

				isClosingDirectIM = TRUE;

			}

			if (!isClosingDirectIM) {

				//Only works in English - XXX fix me!

				if ([messageString rangeOfString:@"Lost connection with the remote user:"].location != NSNotFound) {

					isClosingDirectIM = TRUE;

				}

			}

			if (isClosingDirectIM) {

				if (strcmp(message, _("The remote user has closed the connection.")) != 0) {

					//Display the message if it's not just the one for the other guy closing it...

					[adium.contentController displayEvent:messageString

												   ofType:@"directIMDisconnected"

												   inChat:chat];

				}

				[accountLookup(purple_conversation_get_account(conv)) updateContact:chat.listObject forEvent:[NSNumber numberWithInteger:PURPLE_BUDDY_DIRECTIM_DISCONNECTED]];

				shouldDisplayMessage = FALSE;

			}

		}

		if (shouldDisplayMessage) {

			CBPurpleAccount *account = accountLookup(purple_conversation_get_account(conv));

			[account receivedEventForChat:chat

								  message:messageString

									 date:[NSDate dateWithTimeIntervalSince1970:mtime]

									flags:flags];

		}

	}

}

NSString *get_real_name_for_account_conv_buddy(PurpleAccount *account, PurpleConversation *conv, char *who)

{

	g_return_val_if_fail(who != NULL && strlen(who), nil);

	PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(account));

	PurplePluginProtocolInfo  *prpl_info = (prpl ? PURPLE_PLUGIN_PROTOCOL_INFO(prpl) : NULL);

	PurpleConvChat *convChat = purple_conversation_get_chat_data(conv);

	char *uid = NULL;

	NSString *normalizedUID;

	if (prpl_info && prpl_info->get_cb_real_name) {

		// Get the real name of the buddy for use as a UID, if available.

		uid = prpl_info->get_cb_real_name(purple_account_get_connection(account),

										  purple_conv_chat_get_id(convChat),

										  who);

	}

	if (!uid) {

		// strdup it, mostly so the free below won't have to be cased out.

		uid = g_strdup(who);

	}

	normalizedUID = [NSString stringWithUTF8String:purple_normalize(account, uid)];

	// We have to free the result of get_cb_real_name.

	g_free(uid);

	return normalizedUID;

}

static void adiumPurpleConvChatAddUsers(PurpleConversation *conv, GList *cbuddies, gboolean new_arrivals)

{

	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {

		PurpleAccount *account = purple_conversation_get_account(conv);

		NSMutableArray *users = [NSMutableArray array];

		for (GList *l = cbuddies; l; l = l->next) {

			PurpleConvChatBuddy *cb = (PurpleConvChatBuddy *)l->data;

			NSMutableDictionary *user = [NSMutableDictionary dictionary];

			[user setObject:get_real_name_for_account_conv_buddy(account, conv, cb->name) forKey:@"UID"];

			[user setObject:[NSNumber numberWithInteger:cb->flags] forKey:@"Flags"];

			if (cb->alias) {

				[user setObject:[NSString stringWithUTF8String:cb->alias] forKey:@"Alias"];

			}

			[users addObject:user];

		}

		[accountLookup(account) updateUserListForChat:groupChatLookupFromConv(conv)

												users:users

										   newlyAdded:new_arrivals];

	} else

		AILog(@"adiumPurpleConvChatAddUsers: IM");

}

static void adiumPurpleConvChatRenameUser(PurpleConversation *conv, const char *oldName,

										const char *newName, const char *newAlias)

{

	AILog(@"adiumPurpleConvChatRenameUser: %s: oldName %s, newName %s, newAlias %s",

			   purple_conversation_get_name(conv),

			   oldName, newName, newAlias);

	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {

		PurpleConvChat *convChat = purple_conversation_get_chat_data(conv);

		PurpleConvChatBuddy *cb = purple_conv_chat_cb_find(convChat, oldName);

		PurpleAccount *account = purple_conversation_get_account(conv);

		[accountLookup(purple_conversation_get_account(conv)) renameParticipant:get_real_name_for_account_conv_buddy(account, conv, (char *)oldName)

																		newName:get_real_name_for_account_conv_buddy(account, conv, (char *)newName)

																	   newAlias:[NSString stringWithUTF8String:newAlias]

																		  flags:cb->flags

																		 inChat:groupChatLookupFromConv(conv)];

	}

}

static void adiumPurpleConvChatRemoveUsers(PurpleConversation *conv, GList *users)

{

	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {

		NSMutableArray	*usersArray = [NSMutableArray array];

		PurpleAccount	*account = purple_conversation_get_account(conv);

		GList *l;

		for (l = users; l != NULL; l = l->next) {

			NSString *normalizedUID = get_real_name_for_account_conv_buddy(account, conv, (char *)l->data);

			[usersArray addObject:normalizedUID];

		}

		[accountLookup(account) removeUsersArray:usersArray

										fromChat:groupChatLookupFromConv(conv)];

	} else {

		AILog(@"adiumPurpleConvChatRemoveUser: IM");

	}

}

static void adiumPurpleConvUpdateUser(PurpleConversation *conv, const char *user)

{

	PurpleAccount *account = purple_conversation_get_account(conv);

	CBPurpleAccount *adiumAccount = accountLookup(account);

	PurpleConvChatBuddy *cb = purple_conv_chat_cb_find(PURPLE_CONV_CHAT(conv), user);

	NSMutableDictionary *attributes = [NSMutableDictionary dictionary];

	GList *attribute = purple_conv_chat_cb_get_attribute_keys(cb);

	for (; attribute != NULL; attribute = g_list_next(attribute)) {

		[attributes setObject:[NSString stringWithUTF8String:purple_conv_chat_cb_get_attribute(cb, attribute->data)]

					   forKey:[NSString stringWithUTF8String:attribute->data]];

	}

	g_list_free(attribute);

	NSString *alias = cb->alias ? [NSString stringWithUTF8String:cb->alias] : nil;

	[adiumAccount updateUser:get_real_name_for_account_conv_buddy(account, conv, (char *)user)

					 forChat:groupChatLookupFromConv(conv)

					   flags:cb->flags

					   alias:alias

				  attributes:attributes];

}

static void adiumPurpleConvPresent(PurpleConversation *conv)

{

}

//This isn't a function we want Purple doing anything with, I don't think

static gboolean adiumPurpleConvHasFocus(PurpleConversation *conv)

{

	return NO;

}

static void adiumPurpleConvUpdated(PurpleConversation *conv, PurpleConvUpdateType type)

{

	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {

		PurpleConvChat  *chat = purple_conversation_get_chat_data(conv);

		switch(type) {

			case PURPLE_CONV_UPDATE_TOPIC:

			{

				NSString *who = nil;

				if (chat->who != NULL) {

					who = [NSString stringWithUTF8String:chat->who];

				}

				[accountLookup(purple_conversation_get_account(conv)) updateTopic:(purple_conv_chat_get_topic(chat) ?

																				   [NSString stringWithUTF8String:purple_conv_chat_get_topic(chat)] :

																				   nil)

																		  forChat:groupChatLookupFromConv(conv)

																	   withSource:who];

				break;

			}

			case PURPLE_CONV_UPDATE_TITLE:

				[accountLookup(purple_conversation_get_account(conv)) updateTitle:(purple_conversation_get_title(conv) ?

														   [NSString stringWithUTF8String:purple_conversation_get_title(conv)] :

														   nil)

												  forChat:groupChatLookupFromConv(conv)];

				AILog(@"Update to title: %s",purple_conversation_get_title(conv));

				break;

			case PURPLE_CONV_UPDATE_CHATLEFT:

				[accountLookup(purple_conversation_get_account(conv)) leftChat:groupChatLookupFromConv(conv)];

				break;

			case PURPLE_CONV_UPDATE_ADD:

			case PURPLE_CONV_UPDATE_REMOVE:

			case PURPLE_CONV_UPDATE_ACCOUNT:

			case PURPLE_CONV_UPDATE_TYPING:

			case PURPLE_CONV_UPDATE_UNSEEN:

			case PURPLE_CONV_UPDATE_LOGGING:

			case PURPLE_CONV_ACCOUNT_ONLINE:

			case PURPLE_CONV_ACCOUNT_OFFLINE:

			case PURPLE_CONV_UPDATE_AWAY:

			case PURPLE_CONV_UPDATE_ICON:

			case PURPLE_CONV_UPDATE_FEATURES:

/*				

				[accountLookup(purple_conversation_get_account(conv)) mainPerformSelector:@selector(convUpdateForChat:type:)

													   withObject:groupChatLookupFromConv(conv)

													   withObject:[NSNumber numberWithInt:type]];

*/				

			default:

				break;

		}

	} else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {

		PurpleConvIm  *im = purple_conversation_get_im_data(conv);

		switch (type) {

			case PURPLE_CONV_UPDATE_TYPING: {

				AITypingState typingState;

				switch (purple_conv_im_get_typing_state(im)) {

					case PURPLE_TYPING:

						typingState = AITyping;

						break;

					case PURPLE_TYPED:

						typingState = AIEnteredText;

						break;

					case PURPLE_NOT_TYPING:

					default:

						typingState = AINotTyping;

						break;

				}

				NSNumber	*typingStateNumber = [NSNumber numberWithInteger:typingState];

				[accountLookup(purple_conversation_get_account(conv)) typingUpdateForIMChat:imChatLookupFromConv(conv)

															 typing:typingStateNumber];

				break;

			}

			case PURPLE_CONV_UPDATE_AWAY: {

				//If the conversation update is UPDATE_AWAY, it seems to suppress the typing state being updated

				//Reset purple's typing tracking, then update to receive a PURPLE_CONV_UPDATE_TYPING message

				purple_conv_im_set_typing_state(im, PURPLE_NOT_TYPING);

				purple_conv_im_update_typing(im);

				break;

			}

			default:

				break;

		}

	}

}

#pragma mark Custom smileys

gboolean adiumPurpleConvCustomSmileyAdd(PurpleConversation *conv, const char *smile, gboolean remote)

{

	AILog(@"%s: Added Custom Smiley %s",purple_conversation_get_name(conv),smile);

	[accountLookup(purple_conversation_get_account(conv)) chat:chatLookupFromConv(conv)

			 isWaitingOnCustomEmoticon:[NSString stringWithUTF8String:smile]];

	return TRUE;

}

void adiumPurpleConvCustomSmileyWrite(PurpleConversation *conv, const char *smile,

									const guchar *data, gsize size)

{

	AILog(@"%s: Write Custom Smiley %s (%x %i)",purple_conversation_get_name(conv),smile,data,size);

	[accountLookup(purple_conversation_get_account(conv)) chat:chatLookupFromConv(conv)

					 setCustomEmoticon:[NSString stringWithUTF8String:smile]

						 withImageData:[NSData dataWithBytes:data

													  length:size]];

}

void adiumPurpleConvCustomSmileyClose(PurpleConversation *conv, const char *smile)

{

	AILog(@"%s: Close Custom Smiley %s",purple_conversation_get_name(conv),smile);

	[accountLookup(purple_conversation_get_account(conv)) chat:chatLookupFromConv(conv)

				  closedCustomEmoticon:[NSString stringWithUTF8String:smile]];

}

static gboolean adiumPurpleConvJoin(PurpleConversation *conv, const char *name,

									PurpleConvChatBuddyFlags flags,

									GHashTable *users)

{

	AIChat *chat = groupChatLookupFromConv(conv);

	// We return TRUE if we want to hide it.

	return !chat.showJoinLeave;

}

static gboolean adiumPurpleConvLeave(PurpleConversation *conv, const char *name,

									 const char *reason, GHashTable *users)

{

	AIChat *chat = groupChatLookupFromConv(conv);

	// We return TRUE if we want to hide it.

	return !chat.showJoinLeave;	

}

static PurpleConversationUiOps adiumPurpleConversationOps = {

	adiumPurpleConvCreate,

    adiumPurpleConvDestroy,

    adiumPurpleConvWriteChat,

    adiumPurpleConvWriteIm,

    adiumPurpleConvWriteConv,

    adiumPurpleConvChatAddUsers,

    adiumPurpleConvChatRenameUser,

    adiumPurpleConvChatRemoveUsers,

	adiumPurpleConvUpdateUser,

	adiumPurpleConvPresent,

	adiumPurpleConvHasFocus,

	/* Custom Smileys */

	adiumPurpleConvCustomSmileyAdd,

	adiumPurpleConvCustomSmileyWrite,

	adiumPurpleConvCustomSmileyClose,

	/* send_confirm */

	NULL

};

PurpleConversationUiOps *adium_purple_conversation_get_ui_ops(void)

{

	return &adiumPurpleConversationOps;

}

void adiumPurpleConversation_init(void)

{	

	purple_conversations_set_ui_ops(adium_purple_conversation_get_ui_ops());

	purple_signal_connect_priority(purple_conversations_get_handle(), "conversation-updated", adium_purple_get_handle(),

								 PURPLE_CALLBACK(adiumPurpleConvUpdated), NULL,

								 PURPLE_SIGNAL_PRIORITY_LOWEST);

	purple_signal_connect(purple_conversations_get_handle(), "chat-buddy-joining", adium_purple_get_handle(),

						  PURPLE_CALLBACK(adiumPurpleConvJoin), NULL);

	purple_signal_connect(purple_conversations_get_handle(), "chat-buddy-leaving", adium_purple_get_handle(),

						  PURPLE_CALLBACK(adiumPurpleConvLeave), NULL);

}