pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
Make user interfaces setup the default history adapter.
2021-10-18, Gary Kramlich
755e1554051c
Make user interfaces setup the default history adapter.
This helps avoid some issues with the unit tests as well as gives us more
flexibility in the future.
Testing Done:
Ran the unit tests without issue. Ran Pidgin 3 with no existing config directory and verified that `history.db` was created properly.
Reviewed at https://reviews.imfreedom.org/r/1033/
/*
* purple
*
* Purple is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed 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., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include
<glib/gi18n-lib.h>
#include
"internal.h"
#include
"debug.h"
#include
"purpleconversationmanager.h"
#include
"purplechatconversation.h"
#include
"purpleenums.h"
#include
"purpleprivate.h"
typedef
struct
{
GList
*
ignored
;
/* Ignored users. */
char
*
who
;
/* The person who set the topic. */
char
*
topic
;
/* The topic. */
int
id
;
/* The chat ID. */
char
*
nick
;
/* Your nick in this chat. */
gboolean
left
;
/* We left the chat and kept the window open */
GHashTable
*
users
;
/* Hash table of the users in the room. */
}
PurpleChatConversationPrivate
;
/* Chat Property enums */
enum
{
PROP_0
,
PROP_TOPIC_WHO
,
PROP_TOPIC
,
PROP_CHAT_ID
,
PROP_NICK
,
PROP_LEFT
,
N_PROPERTIES
};
static
GParamSpec
*
properties
[
N_PROPERTIES
]
=
{
NULL
,
};
G_DEFINE_TYPE_WITH_PRIVATE
(
PurpleChatConversation
,
purple_chat_conversation
,
PURPLE_TYPE_CONVERSATION
);
/**************************************************************************
* Helpers
**************************************************************************/
static
guint
purple_conversation_user_hash
(
gconstpointer
data
)
{
gchar
*
collated
;
guint
hash
;
collated
=
g_utf8_collate_key
((
const
gchar
*
)
data
,
-1
);
hash
=
g_str_hash
(
collated
);
g_free
(
collated
);
return
hash
;
}
static
gboolean
purple_conversation_user_equal
(
gconstpointer
a
,
gconstpointer
b
)
{
return
!
g_utf8_collate
(
a
,
b
);
}
static
void
purple_chat_conversation_clear_users_helper
(
gpointer
data
,
gpointer
user_data
)
{
PurpleChatConversation
*
chat
=
PURPLE_CHAT_CONVERSATION
(
user_data
);
const
gchar
*
name
=
(
const
gchar
*
)
data
;
gpointer
handle
=
purple_conversations_get_handle
();
purple_signal_emit
(
handle
,
"chat-user-leaving"
,
chat
,
name
,
NULL
);
purple_signal_emit
(
handle
,
"chat-user-left"
,
chat
,
name
,
NULL
);
}
/******************************************************************************
* PurpleConversation Implementation
*****************************************************************************/
static
void
chat_conversation_write_message
(
PurpleConversation
*
conv
,
PurpleMessage
*
msg
)
{
PurpleChatConversation
*
chat_conv
=
PURPLE_CHAT_CONVERSATION
(
conv
);
PurpleChatConversationPrivate
*
priv
=
NULL
;
PurpleMessageFlags
flags
;
const
gchar
*
author
=
NULL
;
g_return_if_fail
(
msg
!=
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat_conv
);
/* Don't display this if the person who wrote it is ignored. */
author
=
purple_message_get_author
(
msg
);
if
(
purple_chat_conversation_is_ignored_user
(
chat_conv
,
author
))
{
return
;
}
flags
=
purple_message_get_flags
(
msg
);
if
(
flags
&
PURPLE_MESSAGE_RECV
)
{
if
(
purple_utf8_has_word
(
purple_message_get_contents
(
msg
),
priv
->
nick
))
{
flags
|=
PURPLE_MESSAGE_NICK
;
purple_message_set_flags
(
msg
,
flags
);
}
}
_purple_conversation_write_common
(
conv
,
msg
);
}
/******************************************************************************
* GObject Implementation
*****************************************************************************/
static
void
purple_chat_conversation_set_property
(
GObject
*
obj
,
guint
param_id
,
const
GValue
*
value
,
GParamSpec
*
pspec
)
{
PurpleChatConversation
*
chat
=
PURPLE_CHAT_CONVERSATION
(
obj
);
switch
(
param_id
)
{
case
PROP_CHAT_ID
:
purple_chat_conversation_set_id
(
chat
,
g_value_get_int
(
value
));
break
;
case
PROP_NICK
:
purple_chat_conversation_set_nick
(
chat
,
g_value_get_string
(
value
));
break
;
case
PROP_LEFT
:
if
(
g_value_get_boolean
(
value
))
{
purple_chat_conversation_leave
(
chat
);
}
break
;
default
:
G_OBJECT_WARN_INVALID_PROPERTY_ID
(
obj
,
param_id
,
pspec
);
break
;
}
}
static
void
purple_chat_conversation_get_property
(
GObject
*
obj
,
guint
param_id
,
GValue
*
value
,
GParamSpec
*
pspec
)
{
PurpleChatConversation
*
chat
=
PURPLE_CHAT_CONVERSATION
(
obj
);
switch
(
param_id
)
{
case
PROP_TOPIC_WHO
:
g_value_set_string
(
value
,
purple_chat_conversation_get_topic_who
(
chat
));
break
;
case
PROP_TOPIC
:
g_value_set_string
(
value
,
purple_chat_conversation_get_topic
(
chat
));
break
;
case
PROP_CHAT_ID
:
g_value_set_int
(
value
,
purple_chat_conversation_get_id
(
chat
));
break
;
case
PROP_NICK
:
g_value_set_string
(
value
,
purple_chat_conversation_get_nick
(
chat
));
break
;
case
PROP_LEFT
:
g_value_set_boolean
(
value
,
purple_chat_conversation_has_left
(
chat
));
break
;
default
:
G_OBJECT_WARN_INVALID_PROPERTY_ID
(
obj
,
param_id
,
pspec
);
break
;
}
}
static
void
purple_chat_conversation_init
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
priv
->
users
=
g_hash_table_new_full
(
purple_conversation_user_hash
,
purple_conversation_user_equal
,
g_free
,
g_object_unref
);
}
static
void
purple_chat_conversation_constructed
(
GObject
*
obj
)
{
PurpleChatConversation
*
chat
=
PURPLE_CHAT_CONVERSATION
(
obj
);
PurpleAccount
*
account
=
NULL
;
PurpleConnection
*
connection
=
NULL
;
const
gchar
*
display_name
=
NULL
;
G_OBJECT_CLASS
(
purple_chat_conversation_parent_class
)
->
constructed
(
obj
);
g_object_get
(
obj
,
"account"
,
&
account
,
NULL
);
connection
=
purple_account_get_connection
(
account
);
display_name
=
purple_connection_get_display_name
(
connection
);
if
(
display_name
!=
NULL
)
{
purple_chat_conversation_set_nick
(
chat
,
display_name
);
}
else
{
const
gchar
*
username
=
purple_account_get_username
(
account
);
purple_chat_conversation_set_nick
(
chat
,
username
);
}
if
(
purple_prefs_get_bool
(
"/purple/logging/log_chats"
))
{
purple_conversation_set_logging
(
PURPLE_CONVERSATION
(
chat
),
TRUE
);
}
g_object_unref
(
account
);
}
static
void
purple_chat_conversation_dispose
(
GObject
*
obj
)
{
PurpleChatConversation
*
chat
=
PURPLE_CHAT_CONVERSATION
(
obj
);
PurpleChatConversationPrivate
*
priv
=
NULL
;
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
g_hash_table_remove_all
(
priv
->
users
);
G_OBJECT_CLASS
(
purple_chat_conversation_parent_class
)
->
dispose
(
obj
);
}
static
void
purple_chat_conversation_finalize
(
GObject
*
obj
)
{
PurpleChatConversation
*
chat
=
PURPLE_CHAT_CONVERSATION
(
obj
);
PurpleConversation
*
conv
=
PURPLE_CONVERSATION
(
chat
);
PurpleConnection
*
gc
=
purple_conversation_get_connection
(
conv
);
PurpleChatConversationPrivate
*
priv
=
NULL
;
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
if
(
PURPLE_IS_CONNECTION
(
gc
))
{
/* Still connected */
gint
chat_id
=
purple_chat_conversation_get_id
(
chat
);
/*
* Close the window when the user tells us to, and let the protocol
* deal with the internals on its own time. Don't do this if the
* protocol already knows it left the chat.
*/
if
(
!
purple_chat_conversation_has_left
(
chat
))
{
purple_serv_chat_leave
(
gc
,
chat_id
);
}
/*
* If they didn't call purple_serv_got_chat_left by now, it's too late.
* So we better do it for them before we destroy the thing.
*/
if
(
!
purple_chat_conversation_has_left
(
chat
))
{
purple_serv_got_chat_left
(
gc
,
chat_id
);
}
}
g_clear_pointer
(
&
priv
->
users
,
g_hash_table_destroy
);
g_list_free_full
(
priv
->
ignored
,
g_free
);
priv
->
ignored
=
NULL
;
g_clear_pointer
(
&
priv
->
who
,
g_free
);
g_clear_pointer
(
&
priv
->
topic
,
g_free
);
g_clear_pointer
(
&
priv
->
nick
,
g_free
);
G_OBJECT_CLASS
(
purple_chat_conversation_parent_class
)
->
finalize
(
obj
);
}
static
void
purple_chat_conversation_class_init
(
PurpleChatConversationClass
*
klass
)
{
GObjectClass
*
obj_class
=
G_OBJECT_CLASS
(
klass
);
PurpleConversationClass
*
conv_class
=
PURPLE_CONVERSATION_CLASS
(
klass
);
obj_class
->
constructed
=
purple_chat_conversation_constructed
;
obj_class
->
dispose
=
purple_chat_conversation_dispose
;
obj_class
->
finalize
=
purple_chat_conversation_finalize
;
obj_class
->
get_property
=
purple_chat_conversation_get_property
;
obj_class
->
set_property
=
purple_chat_conversation_set_property
;
conv_class
->
write_message
=
chat_conversation_write_message
;
/**
* PurpleChatConversation::topic-who:
*
* The username who changed the topic last.
*/
properties
[
PROP_TOPIC_WHO
]
=
g_param_spec_string
(
"topic-who"
,
"who set topic"
,
"Who set the topic of the chat."
,
NULL
,
G_PARAM_READABLE
|
G_PARAM_STATIC_STRINGS
);
/**
* PurpleChatConversation::topic:
*
* The text of the topic.
*/
properties
[
PROP_TOPIC
]
=
g_param_spec_string
(
"topic"
,
"topic"
,
"The topic of the chat."
,
NULL
,
G_PARAM_READABLE
|
G_PARAM_STATIC_STRINGS
);
/**
* PurpleChatConversation::chat-id:
*
* The identifier of the chat.
*/
properties
[
PROP_CHAT_ID
]
=
g_param_spec_int
(
"chat-id"
,
"chat id"
,
"The identifier of the chat."
,
G_MININT
,
G_MAXINT
,
0
,
G_PARAM_READWRITE
|
G_PARAM_STATIC_STRINGS
);
/**
* PurpleChatConversation::nick:
*
* The nickname of the user in the chat.
*/
properties
[
PROP_NICK
]
=
g_param_spec_string
(
"nick"
,
"nick"
,
"The nickname of the user in a chat."
,
NULL
,
G_PARAM_READWRITE
|
G_PARAM_STATIC_STRINGS
);
/**
* PurpleChatConversation::left:
*
* Whether the user has left the chat or not.
*/
properties
[
PROP_LEFT
]
=
g_param_spec_boolean
(
"left"
,
"left"
,
"Whether the user has left the chat."
,
FALSE
,
G_PARAM_READWRITE
|
G_PARAM_STATIC_STRINGS
);
g_object_class_install_properties
(
obj_class
,
N_PROPERTIES
,
properties
);
}
/******************************************************************************
* Public API
*****************************************************************************/
PurpleConversation
*
purple_chat_conversation_new
(
PurpleAccount
*
account
,
const
gchar
*
name
)
{
PurpleConversation
*
chat
=
NULL
;
PurpleConversationManager
*
manager
=
NULL
;
PurpleConnection
*
connection
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_ACCOUNT
(
account
),
NULL
);
g_return_val_if_fail
(
name
!=
NULL
,
NULL
);
/* Check if this conversation already exists. */
manager
=
purple_conversation_manager_get_default
();
chat
=
purple_conversation_manager_find_chat
(
manager
,
account
,
name
);
if
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
))
{
if
(
!
purple_chat_conversation_has_left
(
PURPLE_CHAT_CONVERSATION
(
chat
)))
{
purple_debug_warning
(
"chat-conversation"
,
"A chat named %s "
"already exists."
,
name
);
return
NULL
;
}
}
connection
=
purple_account_get_connection
(
account
);
if
(
!
PURPLE_IS_CONNECTION
(
connection
))
{
purple_debug_warning
(
"chat-conversation"
,
"Refusing to create chat "
"for disconnected account %s"
,
purple_account_get_username
(
account
));
return
NULL
;
}
return
PURPLE_CONVERSATION
(
g_object_new
(
PURPLE_TYPE_CHAT_CONVERSATION
,
"account"
,
account
,
"name"
,
name
,
"title"
,
name
,
NULL
));
}
GList
*
purple_chat_conversation_get_users
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
g_hash_table_get_values
(
priv
->
users
);
}
guint
purple_chat_conversation_get_users_count
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
0
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
g_hash_table_size
(
priv
->
users
);
}
void
purple_chat_conversation_ignore
(
PurpleChatConversation
*
chat
,
const
gchar
*
name
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
g_return_if_fail
(
name
!=
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
/* Make sure the user isn't already ignored. */
if
(
purple_chat_conversation_is_ignored_user
(
chat
,
name
))
{
return
;
}
priv
->
ignored
=
g_list_prepend
(
priv
->
ignored
,
g_strdup
(
name
));
}
void
purple_chat_conversation_unignore
(
PurpleChatConversation
*
chat
,
const
gchar
*
name
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
GList
*
item
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
g_return_if_fail
(
name
!=
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
/* Make sure the user is actually ignored. */
if
(
!
purple_chat_conversation_is_ignored_user
(
chat
,
name
))
{
return
;
}
item
=
g_list_find
(
priv
->
ignored
,
purple_chat_conversation_get_ignored_user
(
chat
,
name
));
g_free
(
item
->
data
);
priv
->
ignored
=
g_list_delete_link
(
priv
->
ignored
,
item
);
}
GList
*
purple_chat_conversation_set_ignored
(
PurpleChatConversation
*
chat
,
GList
*
ignored
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
priv
->
ignored
=
ignored
;
return
ignored
;
}
GList
*
purple_chat_conversation_get_ignored
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
priv
->
ignored
;
}
const
gchar
*
purple_chat_conversation_get_ignored_user
(
PurpleChatConversation
*
chat
,
const
gchar
*
user
)
{
GList
*
ignored
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
NULL
);
g_return_val_if_fail
(
user
!=
NULL
,
NULL
);
ignored
=
purple_chat_conversation_get_ignored
(
chat
);
for
(;
ignored
!=
NULL
;
ignored
=
ignored
->
next
)
{
const
gchar
*
ign
=
(
const
gchar
*
)
ignored
->
data
;
if
(
!
purple_utf8_strcasecmp
(
user
,
ign
)
||
((
*
ign
==
'+'
||
*
ign
==
'%'
)
&&
!
purple_utf8_strcasecmp
(
user
,
ign
+
1
)))
{
return
ign
;
}
if
(
*
ign
==
'@'
)
{
ign
++
;
if
((
*
ign
==
'+'
&&
!
purple_utf8_strcasecmp
(
user
,
ign
+
1
))
||
(
*
ign
!=
'+'
&&
!
purple_utf8_strcasecmp
(
user
,
ign
)))
{
return
ign
;
}
}
}
return
NULL
;
}
gboolean
purple_chat_conversation_is_ignored_user
(
PurpleChatConversation
*
chat
,
const
gchar
*
user
)
{
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
FALSE
);
g_return_val_if_fail
(
user
!=
NULL
,
FALSE
);
return
(
purple_chat_conversation_get_ignored_user
(
chat
,
user
)
!=
NULL
);
}
void
purple_chat_conversation_set_topic
(
PurpleChatConversation
*
chat
,
const
gchar
*
who
,
const
gchar
*
topic
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
GObject
*
obj
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
g_clear_pointer
(
&
priv
->
who
,
g_free
);
g_clear_pointer
(
&
priv
->
topic
,
g_free
);
priv
->
who
=
g_strdup
(
who
);
priv
->
topic
=
g_strdup
(
topic
);
obj
=
G_OBJECT
(
chat
);
g_object_freeze_notify
(
obj
);
g_object_notify_by_pspec
(
obj
,
properties
[
PROP_TOPIC_WHO
]);
g_object_notify_by_pspec
(
obj
,
properties
[
PROP_TOPIC
]);
g_object_thaw_notify
(
obj
);
purple_conversation_update
(
PURPLE_CONVERSATION
(
chat
),
PURPLE_CONVERSATION_UPDATE_TOPIC
);
purple_signal_emit
(
purple_conversations_get_handle
(),
"chat-topic-changed"
,
chat
,
priv
->
who
,
priv
->
topic
);
}
const
gchar
*
purple_chat_conversation_get_topic
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
priv
->
topic
;
}
const
gchar
*
purple_chat_conversation_get_topic_who
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
priv
->
who
;
}
void
purple_chat_conversation_set_id
(
PurpleChatConversation
*
chat
,
gint
id
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
priv
->
id
=
id
;
g_object_notify_by_pspec
(
G_OBJECT
(
chat
),
properties
[
PROP_CHAT_ID
]);
}
gint
purple_chat_conversation_get_id
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
-1
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
priv
->
id
;
}
void
purple_chat_conversation_add_user
(
PurpleChatConversation
*
chat
,
const
gchar
*
user
,
const
gchar
*
extra_msg
,
PurpleChatUserFlags
flags
,
gboolean
new_arrival
)
{
GList
*
users
=
g_list_append
(
NULL
,
(
gchar
*
)
user
);
GList
*
extra_msgs
=
g_list_append
(
NULL
,
(
gchar
*
)
extra_msg
);
GList
*
flags2
=
g_list_append
(
NULL
,
GINT_TO_POINTER
(
flags
));
purple_chat_conversation_add_users
(
chat
,
users
,
extra_msgs
,
flags2
,
new_arrival
);
g_list_free
(
users
);
g_list_free
(
extra_msgs
);
g_list_free
(
flags2
);
}
void
purple_chat_conversation_add_users
(
PurpleChatConversation
*
chat
,
GList
*
users
,
GList
*
extra_msgs
,
GList
*
flags
,
gboolean
new_arrivals
)
{
PurpleConversation
*
conv
;
PurpleConversationUiOps
*
ops
;
PurpleChatUser
*
chatuser
;
PurpleChatConversationPrivate
*
priv
;
PurpleAccount
*
account
;
PurpleConnection
*
gc
;
PurpleProtocol
*
protocol
;
GList
*
cbuddies
=
NULL
;
gpointer
handle
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
g_return_if_fail
(
users
!=
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
conv
=
PURPLE_CONVERSATION
(
chat
);
ops
=
purple_conversation_get_ui_ops
(
conv
);
account
=
purple_conversation_get_account
(
conv
);
gc
=
purple_conversation_get_connection
(
conv
);
g_return_if_fail
(
PURPLE_IS_CONNECTION
(
gc
));
protocol
=
purple_connection_get_protocol
(
gc
);
g_return_if_fail
(
PURPLE_IS_PROTOCOL
(
protocol
));
handle
=
purple_conversations_get_handle
();
while
(
users
!=
NULL
&&
flags
!=
NULL
)
{
const
gchar
*
user
=
(
const
gchar
*
)
users
->
data
;
const
gchar
*
alias
=
user
;
gboolean
quiet
;
PurpleChatUserFlags
flag
=
GPOINTER_TO_INT
(
flags
->
data
);
const
gchar
*
extra_msg
=
(
extra_msgs
?
extra_msgs
->
data
:
NULL
);
if
(
!
(
purple_protocol_get_options
(
protocol
)
&
OPT_PROTO_UNIQUE_CHATNAME
))
{
if
(
purple_strequal
(
priv
->
nick
,
purple_normalize
(
account
,
user
)))
{
const
gchar
*
alias2
=
purple_account_get_private_alias
(
account
);
if
(
alias2
!=
NULL
)
{
alias
=
alias2
;
}
else
{
const
gchar
*
display_name
=
purple_connection_get_display_name
(
gc
);
if
(
display_name
!=
NULL
)
{
alias
=
display_name
;
}
}
}
else
{
PurpleBuddy
*
buddy
;
if
((
buddy
=
purple_blist_find_buddy
(
purple_connection_get_account
(
gc
),
user
))
!=
NULL
)
{
alias
=
purple_buddy_get_contact_alias
(
buddy
);
}
}
}
quiet
=
GPOINTER_TO_INT
(
purple_signal_emit_return_1
(
handle
,
"chat-user-joining"
,
chat
,
user
,
flag
))
||
purple_chat_conversation_is_ignored_user
(
chat
,
user
);
chatuser
=
purple_chat_user_new
(
chat
,
user
,
alias
,
flag
);
g_hash_table_replace
(
priv
->
users
,
g_strdup
(
purple_chat_user_get_name
(
chatuser
)),
chatuser
);
cbuddies
=
g_list_prepend
(
cbuddies
,
chatuser
);
if
(
!
quiet
&&
new_arrivals
)
{
gchar
*
alias_esc
=
g_markup_escape_text
(
alias
,
-1
);
gchar
*
tmp
;
if
(
extra_msg
==
NULL
)
{
tmp
=
g_strdup_printf
(
_
(
"%s entered the room."
),
alias_esc
);
}
else
{
gchar
*
extra_msg_esc
=
g_markup_escape_text
(
extra_msg
,
-1
);
tmp
=
g_strdup_printf
(
_
(
"%s [<I>%s</I>] entered the room."
),
alias_esc
,
extra_msg_esc
);
g_free
(
extra_msg_esc
);
}
g_free
(
alias_esc
);
purple_conversation_write_system_message
(
conv
,
tmp
,
PURPLE_MESSAGE_NO_LINKIFY
);
g_free
(
tmp
);
}
purple_signal_emit
(
handle
,
"chat-user-joined"
,
chat
,
user
,
flag
,
new_arrivals
);
users
=
users
->
next
;
flags
=
flags
->
next
;
if
(
extra_msgs
!=
NULL
)
{
extra_msgs
=
extra_msgs
->
next
;
}
}
cbuddies
=
g_list_sort
(
cbuddies
,
(
GCompareFunc
)
purple_chat_user_compare
);
if
(
ops
!=
NULL
&&
ops
->
chat_add_users
!=
NULL
)
{
ops
->
chat_add_users
(
chat
,
cbuddies
,
new_arrivals
);
}
g_list_free
(
cbuddies
);
}
void
purple_chat_conversation_rename_user
(
PurpleChatConversation
*
chat
,
const
gchar
*
old_user
,
const
gchar
*
new_user
)
{
PurpleConversation
*
conv
;
PurpleConversationUiOps
*
ops
;
PurpleAccount
*
account
;
PurpleConnection
*
gc
;
PurpleProtocol
*
protocol
;
PurpleChatUser
*
cb
;
PurpleChatUserFlags
flags
;
PurpleChatConversationPrivate
*
priv
;
const
gchar
*
new_alias
=
new_user
;
gchar
tmp
[
BUF_LONG
];
gboolean
is_me
=
FALSE
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
g_return_if_fail
(
old_user
!=
NULL
);
g_return_if_fail
(
new_user
!=
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
conv
=
PURPLE_CONVERSATION
(
chat
);
ops
=
purple_conversation_get_ui_ops
(
conv
);
account
=
purple_conversation_get_account
(
conv
);
gc
=
purple_conversation_get_connection
(
conv
);
g_return_if_fail
(
PURPLE_IS_CONNECTION
(
gc
));
protocol
=
purple_connection_get_protocol
(
gc
);
g_return_if_fail
(
PURPLE_IS_PROTOCOL
(
protocol
));
if
(
purple_strequal
(
priv
->
nick
,
purple_normalize
(
account
,
old_user
)))
{
const
gchar
*
alias
;
/* Note this for later. */
is_me
=
TRUE
;
if
(
!
(
purple_protocol_get_options
(
protocol
)
&
OPT_PROTO_UNIQUE_CHATNAME
))
{
alias
=
purple_account_get_private_alias
(
account
);
if
(
alias
!=
NULL
)
{
new_alias
=
alias
;
}
else
{
const
gchar
*
display_name
=
purple_connection_get_display_name
(
gc
);
if
(
display_name
!=
NULL
)
{
new_alias
=
display_name
;
}
}
}
}
else
if
(
!
(
purple_protocol_get_options
(
protocol
)
&
OPT_PROTO_UNIQUE_CHATNAME
))
{
PurpleBuddy
*
buddy
;
if
((
buddy
=
purple_blist_find_buddy
(
purple_connection_get_account
(
gc
),
new_user
))
!=
NULL
)
{
new_alias
=
purple_buddy_get_contact_alias
(
buddy
);
}
}
flags
=
purple_chat_user_get_flags
(
purple_chat_conversation_find_user
(
chat
,
old_user
));
cb
=
purple_chat_user_new
(
chat
,
new_user
,
new_alias
,
flags
);
g_hash_table_replace
(
priv
->
users
,
g_strdup
(
purple_chat_user_get_name
(
cb
)),
cb
);
if
(
ops
!=
NULL
&&
ops
->
chat_rename_user
!=
NULL
)
{
ops
->
chat_rename_user
(
chat
,
old_user
,
new_user
,
new_alias
);
}
cb
=
purple_chat_conversation_find_user
(
chat
,
old_user
);
if
(
cb
)
{
g_hash_table_remove
(
priv
->
users
,
purple_chat_user_get_name
(
cb
));
}
if
(
purple_chat_conversation_is_ignored_user
(
chat
,
old_user
))
{
purple_chat_conversation_unignore
(
chat
,
old_user
);
purple_chat_conversation_ignore
(
chat
,
new_user
);
}
else
if
(
purple_chat_conversation_is_ignored_user
(
chat
,
new_user
))
{
purple_chat_conversation_unignore
(
chat
,
new_user
);
}
if
(
is_me
)
{
purple_chat_conversation_set_nick
(
chat
,
new_user
);
}
if
(
purple_prefs_get_bool
(
"/purple/conversations/chat/show_nick_change"
)
&&
!
purple_chat_conversation_is_ignored_user
(
chat
,
new_user
))
{
if
(
is_me
)
{
gchar
*
escaped
=
g_markup_escape_text
(
new_user
,
-1
);
g_snprintf
(
tmp
,
sizeof
(
tmp
),
_
(
"You are now known as %s"
),
escaped
);
g_free
(
escaped
);
}
else
{
const
gchar
*
old_alias
=
old_user
;
const
gchar
*
new_alias
=
new_user
;
gchar
*
escaped
;
gchar
*
escaped2
;
if
(
!
(
purple_protocol_get_options
(
protocol
)
&
OPT_PROTO_UNIQUE_CHATNAME
))
{
PurpleBuddy
*
buddy
;
if
((
buddy
=
purple_blist_find_buddy
(
account
,
old_user
))
!=
NULL
)
{
old_alias
=
purple_buddy_get_contact_alias
(
buddy
);
}
if
((
buddy
=
purple_blist_find_buddy
(
account
,
new_user
))
!=
NULL
)
{
new_alias
=
purple_buddy_get_contact_alias
(
buddy
);
}
}
escaped
=
g_markup_escape_text
(
old_alias
,
-1
);
escaped2
=
g_markup_escape_text
(
new_alias
,
-1
);
g_snprintf
(
tmp
,
sizeof
(
tmp
),
_
(
"%s is now known as %s"
),
escaped
,
escaped2
);
g_free
(
escaped
);
g_free
(
escaped2
);
}
purple_conversation_write_system_message
(
conv
,
tmp
,
PURPLE_MESSAGE_NO_LINKIFY
);
}
}
void
purple_chat_conversation_remove_user
(
PurpleChatConversation
*
chat
,
const
gchar
*
user
,
const
gchar
*
reason
)
{
GList
*
users
=
g_list_append
(
NULL
,
(
gchar
*
)
user
);
purple_chat_conversation_remove_users
(
chat
,
users
,
reason
);
g_list_free
(
users
);
}
void
purple_chat_conversation_remove_users
(
PurpleChatConversation
*
chat
,
GList
*
users
,
const
gchar
*
reason
)
{
PurpleConversation
*
conv
;
PurpleConnection
*
gc
;
PurpleProtocol
*
protocol
;
PurpleConversationUiOps
*
ops
;
PurpleChatUser
*
cb
;
PurpleChatConversationPrivate
*
priv
;
GList
*
l
;
gboolean
quiet
;
gpointer
handle
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
g_return_if_fail
(
users
!=
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
conv
=
PURPLE_CONVERSATION
(
chat
);
gc
=
purple_conversation_get_connection
(
conv
);
g_return_if_fail
(
PURPLE_IS_CONNECTION
(
gc
));
protocol
=
purple_connection_get_protocol
(
gc
);
g_return_if_fail
(
PURPLE_IS_PROTOCOL
(
protocol
));
ops
=
purple_conversation_get_ui_ops
(
conv
);
handle
=
purple_conversations_get_handle
();
for
(
l
=
users
;
l
!=
NULL
;
l
=
l
->
next
)
{
const
gchar
*
user
=
(
const
gchar
*
)
l
->
data
;
quiet
=
GPOINTER_TO_INT
(
purple_signal_emit_return_1
(
handle
,
"chat-user-leaving"
,
chat
,
user
,
reason
))
|
purple_chat_conversation_is_ignored_user
(
chat
,
user
);
cb
=
purple_chat_conversation_find_user
(
chat
,
user
);
if
(
cb
)
{
g_hash_table_remove
(
priv
->
users
,
purple_chat_user_get_name
(
cb
));
}
/* NOTE: Don't remove them from ignored in case they re-enter. */
if
(
!
quiet
)
{
const
gchar
*
alias
=
user
;
gchar
*
alias_esc
;
gchar
*
tmp
;
if
(
!
(
purple_protocol_get_options
(
protocol
)
&
OPT_PROTO_UNIQUE_CHATNAME
))
{
PurpleBuddy
*
buddy
;
if
((
buddy
=
purple_blist_find_buddy
(
purple_connection_get_account
(
gc
),
user
))
!=
NULL
)
{
alias
=
purple_buddy_get_contact_alias
(
buddy
);
}
}
alias_esc
=
g_markup_escape_text
(
alias
,
-1
);
if
(
reason
==
NULL
||
!*
reason
)
{
tmp
=
g_strdup_printf
(
_
(
"%s left the room."
),
alias_esc
);
}
else
{
char
*
reason_esc
=
g_markup_escape_text
(
reason
,
-1
);
tmp
=
g_strdup_printf
(
_
(
"%s left the room (%s)."
),
alias_esc
,
reason_esc
);
g_free
(
reason_esc
);
}
g_free
(
alias_esc
);
purple_conversation_write_system_message
(
conv
,
tmp
,
PURPLE_MESSAGE_NO_LINKIFY
);
g_free
(
tmp
);
}
purple_signal_emit
(
handle
,
"chat-user-left"
,
conv
,
user
,
reason
);
}
if
(
ops
!=
NULL
&&
ops
->
chat_remove_users
!=
NULL
)
{
ops
->
chat_remove_users
(
chat
,
users
);
}
}
void
purple_chat_conversation_clear_users
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
PurpleConversationUiOps
*
ops
=
NULL
;
GList
*
names
=
NULL
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
ops
=
purple_conversation_get_ui_ops
(
PURPLE_CONVERSATION
(
chat
));
names
=
g_hash_table_get_keys
(
priv
->
users
);
if
(
ops
!=
NULL
&&
ops
->
chat_remove_users
!=
NULL
)
{
ops
->
chat_remove_users
(
chat
,
names
);
}
g_list_foreach
(
names
,
purple_chat_conversation_clear_users_helper
,
chat
);
g_list_free
(
names
);
g_hash_table_remove_all
(
priv
->
users
);
}
void
purple_chat_conversation_set_nick
(
PurpleChatConversation
*
chat
,
const
gchar
*
nick
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
PurpleAccount
*
account
=
NULL
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
account
=
purple_conversation_get_account
(
PURPLE_CONVERSATION
(
chat
));
g_free
(
priv
->
nick
);
priv
->
nick
=
g_strdup
(
purple_normalize
(
account
,
nick
));
g_object_notify_by_pspec
(
G_OBJECT
(
chat
),
properties
[
PROP_NICK
]);
}
const
gchar
*
purple_chat_conversation_get_nick
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
priv
->
nick
;
}
static
void
invite_user_to_chat
(
gpointer
data
,
PurpleRequestFields
*
fields
)
{
PurpleChatConversation
*
chat
;
PurpleChatConversationPrivate
*
priv
;
PurpleConnection
*
pc
;
const
gchar
*
user
,
*
message
;
chat
=
PURPLE_CHAT_CONVERSATION
(
data
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
user
=
purple_request_fields_get_string
(
fields
,
"screenname"
);
message
=
purple_request_fields_get_string
(
fields
,
"message"
);
pc
=
purple_conversation_get_connection
(
PURPLE_CONVERSATION
(
chat
));
purple_serv_chat_invite
(
pc
,
priv
->
id
,
message
,
user
);
}
void
purple_chat_conversation_invite_user
(
PurpleChatConversation
*
chat
,
const
gchar
*
user
,
const
gchar
*
message
,
gboolean
confirm
)
{
PurpleAccount
*
account
;
PurpleRequestFields
*
fields
;
PurpleRequestFieldGroup
*
group
;
PurpleRequestField
*
field
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
if
(
user
==
NULL
||
*
user
==
'\0'
||
message
==
NULL
||
*
message
==
'\0'
)
{
confirm
=
TRUE
;
}
account
=
purple_conversation_get_account
(
PURPLE_CONVERSATION
(
chat
));
if
(
!
confirm
)
{
purple_serv_chat_invite
(
purple_account_get_connection
(
account
),
purple_chat_conversation_get_id
(
chat
),
message
,
user
);
return
;
}
fields
=
purple_request_fields_new
();
group
=
purple_request_field_group_new
(
_
(
"Invite to chat"
));
purple_request_fields_add_group
(
fields
,
group
);
field
=
purple_request_field_string_new
(
"screenname"
,
_
(
"Buddy"
),
user
,
FALSE
);
purple_request_field_group_add_field
(
group
,
field
);
purple_request_field_set_required
(
field
,
TRUE
);
purple_request_field_set_type_hint
(
field
,
"screenname"
);
field
=
purple_request_field_string_new
(
"message"
,
_
(
"Message"
),
message
,
FALSE
);
purple_request_field_group_add_field
(
group
,
field
);
purple_request_fields
(
chat
,
_
(
"Invite to chat"
),
NULL
,
_
(
"Please enter the name of the user you wish to "
"invite, along with an optional invite message."
),
fields
,
_
(
"Invite"
),
G_CALLBACK
(
invite_user_to_chat
),
_
(
"Cancel"
),
NULL
,
purple_request_cpar_from_conversation
(
PURPLE_CONVERSATION
(
chat
)),
chat
);
}
gboolean
purple_chat_conversation_has_user
(
PurpleChatConversation
*
chat
,
const
gchar
*
user
)
{
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
FALSE
);
g_return_val_if_fail
(
user
!=
NULL
,
FALSE
);
return
(
purple_chat_conversation_find_user
(
chat
,
user
)
!=
NULL
);
}
void
purple_chat_conversation_leave
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
));
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
priv
->
left
=
TRUE
;
if
(
!
g_object_get_data
(
G_OBJECT
(
chat
),
"is-finalizing"
))
{
g_object_notify_by_pspec
(
G_OBJECT
(
chat
),
properties
[
PROP_LEFT
]);
}
purple_conversation_update
(
PURPLE_CONVERSATION
(
chat
),
PURPLE_CONVERSATION_UPDATE_CHATLEFT
);
}
gboolean
purple_chat_conversation_has_left
(
PurpleChatConversation
*
chat
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
TRUE
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
priv
->
left
;
}
PurpleChatUser
*
purple_chat_conversation_find_user
(
PurpleChatConversation
*
chat
,
const
gchar
*
name
)
{
PurpleChatConversationPrivate
*
priv
=
NULL
;
g_return_val_if_fail
(
PURPLE_IS_CHAT_CONVERSATION
(
chat
),
NULL
);
g_return_val_if_fail
(
name
!=
NULL
,
NULL
);
priv
=
purple_chat_conversation_get_instance_private
(
chat
);
return
g_hash_table_lookup
(
priv
->
users
,
name
);
}