static void
account_widget_irc_button_add_network_clicked_cb (GtkWidget *button,
EmpathyAccountWidgetIrc *settings)
{
EmpathyIrcNetwork *network;
GtkTreeModel *model;
GtkListStore *store;
gchar *name;
GtkTreeIter iter;
network = empathy_irc_network_new (_("New Network"));
empathy_irc_network_manager_add (settings->network_manager, network);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (settings->combobox_network));
store = GTK_LIST_STORE (model);
g_object_get (network, "name", &name, NULL);
gtk_list_store_insert_with_values (store, &iter, -1,
COL_NETWORK_OBJ, network,
COL_NETWORK_NAME, name,
-1);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (settings->combobox_network),
&iter);
display_irc_network_dialog (settings, network);
g_free (name);
g_object_unref (network);
}
static void
set_label_from_settings (EmpathyIrcNetworkChooser *self)
{
EmpathyIrcNetworkChooserPriv *priv = GET_PRIV (self);
const gchar *server;
tp_clear_object (&priv->network);
server = empathy_account_settings_get_string (priv->settings, "server");
if (server != NULL)
{
EmpathyIrcServer *srv;
gint port;
gboolean ssl;
priv->network = empathy_irc_network_manager_find_network_by_address (
priv->network_manager, server);
if (priv->network != NULL)
{
/* The network is known */
g_object_ref (priv->network);
set_label (self);
return;
}
/* We don't have this network. Let's create it */
port = empathy_account_settings_get_uint32 (priv->settings, "port");
ssl = empathy_account_settings_get_boolean (priv->settings,
"use-ssl");
DEBUG ("Create a network %s", server);
priv->network = empathy_irc_network_new (server);
srv = empathy_irc_server_new (server, port, ssl);
empathy_irc_network_append_server (priv->network, srv);
empathy_irc_network_manager_add (priv->network_manager, priv->network);
set_label (self);
g_object_unref (srv);
return;
}
/* Set default network */
priv->network = empathy_irc_network_manager_find_network_by_address (
priv->network_manager, DEFAULT_IRC_NETWORK);
g_assert (priv->network != NULL);
set_label (self);
update_server_params (self);
g_object_ref (priv->network);
}
static void
add_network (EmpathyIrcNetworkChooserDialog *self)
{
EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
EmpathyIrcNetwork *network;
GtkTreeIter iter, filter_iter;
gtk_widget_hide (priv->search);
network = empathy_irc_network_new (_("New Network"));
empathy_irc_network_manager_add (priv->network_manager, network);
gtk_list_store_insert_with_values (priv->store, &iter, -1,
COL_NETWORK_OBJ, network,
COL_NETWORK_NAME, empathy_irc_network_get_name (network),
-1);
filter_iter = iter_to_filter_iter (self, &iter);
select_iter (self, &filter_iter, TRUE);
display_irc_network_dialog (self, network);
g_object_unref (network);
}
static void
account_widget_irc_setup (EmpathyAccountWidgetIrc *settings)
{
const gchar *nick = NULL;
const gchar *fullname = NULL;
const gchar *server = NULL;
gint port = 6667;
const gchar *charset;
gboolean ssl = FALSE;
EmpathyIrcNetwork *network = NULL;
EmpathyAccountSettings *ac_settings;
g_object_get (settings->self, "settings", &ac_settings, NULL);
nick = empathy_account_settings_get_string (ac_settings, "account");
fullname = empathy_account_settings_get_string (ac_settings,
"fullname");
server = empathy_account_settings_get_string (ac_settings, "server");
charset = empathy_account_settings_get_string (ac_settings, "charset");
port = empathy_account_settings_get_uint32 (ac_settings, "port");
ssl = empathy_account_settings_get_boolean (ac_settings, "use-ssl");
if (!nick)
{
nick = g_strdup (g_get_user_name ());
empathy_account_settings_set_string (ac_settings,
"account", nick);
}
if (!fullname)
{
fullname = g_strdup (g_get_real_name ());
if (!fullname)
{
fullname = g_strdup (nick);
}
empathy_account_settings_set_string (ac_settings,
"fullname", fullname);
}
if (server != NULL)
{
GtkListStore *store;
network = empathy_irc_network_manager_find_network_by_address (
settings->network_manager, server);
store = GTK_LIST_STORE (gtk_combo_box_get_model (
GTK_COMBO_BOX (settings->combobox_network)));
if (network != NULL)
{
gchar *name;
g_object_set (network, "charset", charset, NULL);
g_object_get (network, "name", &name, NULL);
DEBUG ("Account use network %s", name);
g_free (name);
}
else
{
/* We don't have this network. Let's create it */
EmpathyIrcServer *srv;
GtkTreeIter iter;
DEBUG ("Create a network %s", server);
network = empathy_irc_network_new (server);
srv = empathy_irc_server_new (server, port, ssl);
empathy_irc_network_append_server (network, srv);
empathy_irc_network_manager_add (settings->network_manager, network);
gtk_list_store_insert_with_values (store, &iter, -1,
COL_NETWORK_OBJ, network,
COL_NETWORK_NAME, server,
-1);
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX (settings->combobox_network), &iter);
g_object_unref (srv);
g_object_unref (network);
}
}
fill_networks_model (settings, network);
}
END_TEST
START_TEST (test_modify_both_files)
{
EmpathyIrcNetworkManager *mgr;
EmpathyIrcNetwork *network;
EmpathyIrcServer *server;
gchar *global_file, *user_file;
GSList *networks, *l;
struct server_t gimpnet_servers[] = {
{ "irc.gimp.org", 6667, TRUE },
{ "irc.us.gimp.org", 6668, FALSE }};
struct server_t great_server[] = {
{ "irc.greatserver.com", 7873, TRUE }};
struct server_t another_server[] = {
{ "irc.anothersrv.be", 6660, FALSE }};
struct server_t undernet_servers[] = {
{ "eu.undernet.org", 6667, FALSE },
{ "us.undernet.org", 6667, FALSE }};
gboolean network_modified[4];
gboolean network_checked[4];
gchar *global_file_orig, *user_file_orig;
copy_xml_file (USER_SAMPLE, USER_FILE);
global_file_orig = get_xml_file (GLOBAL_SAMPLE);
user_file_orig = get_user_xml_file (USER_FILE);
mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
g_object_get (mgr,
"global-file", &global_file,
"user-file", &user_file,
NULL);
fail_if (global_file == NULL || strcmp (global_file, global_file_orig) != 0);
fail_if (user_file == NULL || strcmp (user_file, user_file_orig) != 0);
g_free (global_file);
g_free (global_file_orig);
g_free (user_file);
g_free (user_file_orig);
networks = empathy_irc_network_manager_get_networks (mgr);
fail_if (g_slist_length (networks) != 5);
network_modified[0] = network_modified[1] = network_modified[2] =
network_modified[3] = FALSE;
/* check networks and servers */
for (l = networks; l != NULL; l = g_slist_next (l))
{
EmpathyIrcNetwork *network;
gchar *name;
network = l->data;
g_object_get (network, "name", &name, NULL);
fail_if (name == NULL);
if (strcmp (name, "GIMPNet") == 0)
{
/* Modify user network */
GSList *servers, *ll;
servers = empathy_irc_network_get_servers (network);
for (ll = servers; ll != NULL; ll = g_slist_next (ll))
{
EmpathyIrcServer *server;
gchar *address;
server = ll->data;
g_object_get (server, "address", &address, NULL);
if (strcmp (address, "irc.gimp.org") == 0)
{
/* change SSL */
g_object_set (server, "ssl", TRUE, NULL);
}
else if (strcmp (address, "irc.us.gimp.org") == 0)
{
/* change port */
g_object_set (server, "port", 6668, NULL);
}
else if (strcmp (address, "irc.au.gimp.org") == 0)
{
/* remove this server */
empathy_irc_network_remove_server (network, server);
}
else
{
fail_if (TRUE);
}
g_free (address);
}
network_modified[0] = TRUE;
g_slist_foreach (servers, (GFunc) g_object_unref, NULL);
g_slist_free (servers);
}
else if (strcmp (name, "My Server") == 0)
{
/* remove user network */
empathy_irc_network_manager_remove (mgr, network);
network_modified[1] = TRUE;
}
else if (strcmp (name, "Freenode") == 0)
{
/* remove global network */
empathy_irc_network_manager_remove (mgr, network);
network_modified[2] = TRUE;
}
else if (strcmp (name, "Undernet") == 0)
{
/* modify global network */
EmpathyIrcServer *server;
server = empathy_irc_server_new ("us.undernet.org", 6667, FALSE);
empathy_irc_network_append_server (network, server);
g_object_unref (server);
network_modified[3] = TRUE;
}
else if (strcmp (name, "Another Server") == 0)
{
/* Don't change this one */
}
else
{
fail_if (TRUE);
}
g_free (name);
}
fail_if (!network_modified[0] || !network_modified[1] || !network_modified[2]
|| !network_modified[3]);
/* Add a new network */
network = empathy_irc_network_new ("Great Server");
server = empathy_irc_server_new ("irc.greatserver.com", 7873, TRUE);
empathy_irc_network_append_server (network, server);
empathy_irc_network_manager_add (mgr, network);
g_object_unref (server);
g_object_unref (network);
g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
g_slist_free (networks);
g_object_unref (mgr);
/* Now let's reload the file and check its contain */
global_file_orig = get_xml_file (GLOBAL_SAMPLE);
user_file_orig = get_user_xml_file (USER_FILE);
mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
g_free (global_file_orig);
g_free (user_file_orig);
networks = empathy_irc_network_manager_get_networks (mgr);
fail_if (g_slist_length (networks) != 4);
network_checked[0] = network_checked[1] = network_checked[2] =
network_checked[3] = FALSE;
/* check networks and servers */
for (l = networks; l != NULL; l = g_slist_next (l))
{
gchar *name;
g_object_get (l->data, "name", &name, NULL);
fail_if (name == NULL);
if (strcmp (name, "GIMPNet") == 0)
{
check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 2);
network_checked[0] = TRUE;
}
else if (strcmp (name, "Great Server") == 0)
{
check_network (l->data, "Great Server", "UTF-8", great_server, 1);
network_checked[1] = TRUE;
}
else if (strcmp (name, "Another Server") == 0)
{
check_network (l->data, "Another Server", "UTF-8", another_server, 1);
network_checked[2] = TRUE;
}
else if (strcmp (name, "Undernet") == 0)
{
check_network (l->data, "Undernet", "UTF-8", undernet_servers, 2);
network_checked[3] = TRUE;
}
else
{
fail_if (TRUE);
}
g_free (name);
}
fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2] ||
!network_checked[3]);
g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
g_slist_free (networks);
g_object_unref (mgr);
}
static void
irc_network_manager_parse_irc_network (EmpathyIrcNetworkManager *self,
xmlNodePtr node,
gboolean user_defined)
{
EmpathyIrcNetworkManagerPriv *priv = GET_PRIV (self);
EmpathyIrcNetwork *network;
xmlNodePtr child;
gchar *str;
gchar *id, *name;
id = xmlGetProp (node, "id");
if (xmlHasProp (node, "dropped"))
{
if (!user_defined)
{
DEBUG ("the 'dropped' attribute shouldn't be used in the global file");
}
network = g_hash_table_lookup (priv->networks, id);
if (network != NULL)
{
network->dropped = TRUE;
network->user_defined = TRUE;
}
xmlFree (id);
return;
}
if (!xmlHasProp (node, "name"))
return;
name = xmlGetProp (node, "name");
network = empathy_irc_network_new (name);
if (xmlHasProp (node, "network_charset"))
{
gchar *charset;
charset = xmlGetProp (node, "network_charset");
g_object_set (network, "charset", charset, NULL);
xmlFree (charset);
}
add_network (self, network, id);
DEBUG ("add network %s (id %s)", name, id);
for (child = node->children; child; child = child->next)
{
gchar *tag;
tag = (gchar *) child->name;
str = (gchar *) xmlNodeGetContent (child);
if (!str)
continue;
if (strcmp (tag, "servers") == 0)
{
irc_network_manager_parse_irc_server (network, child);
}
xmlFree (str);
}
network->user_defined = user_defined;
g_object_unref (network);
xmlFree (name);
xmlFree (id);
}
