static void gglk_style_response(GtkDialog *dialog,
gint response,
gpointer unused_data)
{
switch(response) {
case GTK_RESPONSE_APPLY:
if(gglk_style_changeset)
gconf_client_commit_change_set(gconf_client_get_default(),
gglk_style_changeset,
TRUE,
NULL);
break;
case GTK_RESPONSE_OK:
if(gglk_style_changeset)
gconf_client_commit_change_set(gconf_client_get_default(),
gglk_style_changeset,
TRUE,
NULL);
gtk_widget_destroy(GTK_WIDGET(dialog));
break;
case GTK_RESPONSE_CANCEL:
gtk_widget_destroy(GTK_WIDGET(dialog));
break;
}
}
static void
nautilus_file_background_write_desktop_default_settings (void)
{
/* We just unset all the gconf keys so they go back to
* defaults
*/
GConfClient *client;
GConfChangeSet *set;
client = gconf_client_get_default ();
set = gconf_change_set_new ();
/* the list of keys here has to be kept in sync with libgnome
* schemas, which isn't the most maintainable thing ever.
*/
gconf_change_set_unset (set, "/desktop/gnome/background/picture_options");
gconf_change_set_unset (set, "/desktop/gnome/background/picture_filename");
gconf_change_set_unset (set, "/desktop/gnome/background/picture_opacity");
gconf_change_set_unset (set, "/desktop/gnome/background/primary_color");
gconf_change_set_unset (set, "/desktop/gnome/background/secondary_color");
gconf_change_set_unset (set, "/desktop/gnome/background/color_shading_type");
/* this isn't atomic yet so it'll be a bit inefficient, but
* someday it might be atomic.
*/
gconf_client_commit_change_set (client, set, FALSE, NULL);
gconf_change_set_unref (set);
g_object_unref (G_OBJECT (client));
}
static void
prefs_dialog_revert(GtkWidget* dialog)
{
GConfChangeSet* cs;
GConfChangeSet* revert_cs;
GConfClient* client;
revert_cs = g_object_get_data(dialog, "revert_changeset");
if (revert_cs == NULL)
return; /* happens on cancel, if no apply has been done */
client = g_object_get_data(dialog, "client");
cs = g_object_get_data(dialog, "changeset");
/* When reverting, you want to discard any pending changes so
"apply" won't do anything */
gconf_change_set_clear(cs);
/* FALSE so we don't remove committed stuff from the revert set */
gconf_client_commit_change_set(client, revert_cs, FALSE, NULL);
/* Set the prefs dialog contents back to the
new values */
update_entry(dialog, revert_cs, "/apps/basic-gconf-app/foo");
update_entry(dialog, revert_cs, "/apps/basic-gconf-app/bar");
update_entry(dialog, revert_cs, "/apps/basic-gconf-app/baz");
update_entry(dialog, revert_cs, "/apps/basic-gconf-app/blah");
/* Update sensitivity of the dialog buttons */
prefs_dialog_update_sensitivity(dialog);
}
static gboolean
gconf_settings_backend_write_tree (GSettingsBackend *backend,
GTree *tree,
gpointer origin_tag)
{
GConfSettingsBackend *gconf = GCONF_SETTINGS_BACKEND (backend);
GConfChangeSet *changeset;
GConfChangeSet *reversed;
gboolean success;
changeset = gconf_change_set_new ();
g_tree_foreach (tree, (GTraverseFunc) gconf_settings_backend_write_one_to_changeset, changeset);
if (gconf_change_set_size (changeset) != g_tree_nnodes (tree))
{
gconf_change_set_unref (changeset);
return FALSE;
}
reversed = gconf_client_reverse_change_set (gconf->priv->client, changeset, NULL);
success = gconf_client_commit_change_set (gconf->priv->client, changeset, TRUE, NULL);
g_tree_foreach (tree, (GTraverseFunc) gconf_settings_backend_add_ignore_notifications, gconf);
if (!success)
{
/* This is a tricky situation: when committing, some keys will have been
* changed, so there will be notifications that we'll want to ignore. But
* we can't ignore notifications for what was not committed. Note that
* when we'll commit the reversed changeset, it should fail for the same
* key, so there'll be no other notifications created. And in the worst
* case, it's no big deal... */
gconf_change_set_foreach (changeset,
(GConfChangeSetForeachFunc) gconf_settings_backend_remove_ignore_notifications,
gconf);
gconf_client_commit_change_set (gconf->priv->client, reversed, FALSE, NULL);
}
else
g_settings_backend_changed_tree (backend, tree, origin_tag);
gconf_change_set_unref (changeset);
gconf_change_set_unref (reversed);
return success;
}
gboolean
on_userlist_import_page_2_next (GnomeDruidPage * druidpage, GtkWidget * widget, gpointer user_data)
{
GtkWidget *file_chooser = glade_xml_get_widget (gladexml_import_userlist, "ImportFileChooser");
GIOChannel *channel = NULL;
gchar *line = NULL;
gsize len, terminator_pos;
gchar *filename = NULL;
gsize status = -1;
g_assert (file_chooser);
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser));
channel = g_io_channel_new_file (filename, "r", NULL);
if (!channel)
{
GtkDialog *msgdialog = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
"<span weight=\"bold\"size=\"larger\">Plik nie został wybrany</span>\n\nWymagane pola nie zostały wypełnione prawidłowo, spróbuj jeszcze raz.");
gtk_dialog_run (GTK_DIALOG (msgdialog));
gtk_widget_destroy (GTK_WIDGET (msgdialog));
goto end;
}
g_io_channel_set_encoding (channel, NULL, NULL);
GConfChangeSet *changeset = gconf_change_set_new();
while (status != G_IO_STATUS_ERROR && status != G_IO_STATUS_EOF)
{
status = g_io_channel_read_line (channel, &line, &len, &terminator_pos, NULL);
if (status == G_IO_STATUS_ERROR || status == G_IO_STATUS_EOF)
{
g_free (line);
continue;
}
gnomegadu_ui_import_userlist_process_line (line, changeset);
if (!gconf_client_commit_change_set(gconf, changeset, TRUE, NULL))
g_printerr("Some error while import");
g_free (line);
}
gconf_change_set_unref(changeset);
gconf_client_suggest_sync (gconf, NULL);
g_io_channel_unref (channel);
end:
g_free (filename);
return FALSE;
}
static void
unset_in_db (GConfDefaults *mechanism,
const gchar *address,
const gchar **includes,
const gchar **excludes,
GError **error)
{
GConfEngine *engine;
GConfClient *dest = NULL;
GConfChangeSet *changes = NULL;
int i;
engine = gconf_engine_get_local (address, error);
if (*error)
goto out;
dest = gconf_client_get_for_engine (engine);
gconf_engine_unref (engine);
changes = gconf_change_set_new ();
/* recursively copy each include, leaving out the excludes */
for (i = 0; includes[i]; i++) {
if (gconf_client_dir_exists (dest, includes[i], NULL))
unset_tree (dest, includes[i], changes, excludes);
else
unset_entry (dest, includes[i], changes, excludes);
}
gconf_client_commit_change_set (dest, changes, TRUE, error);
gconf_client_suggest_sync (dest, NULL);
out:
if (dest)
g_object_unref (dest);
if (changes)
gconf_change_set_unref (changes);
}
static void
prefs_dialog_apply(GtkWidget* dialog)
{
GConfChangeSet* cs;
GConfClient* client;
GConfChangeSet* revert_cs;
client = g_object_get_data(dialog, "client");
/* Create the revert changeset on the first apply; this means
the revert button should now be sensitive */
revert_cs = g_object_get_data(dialog, "revert_changeset");
if (revert_cs == NULL)
{
revert_cs = gconf_client_change_set_from_current(client,
NULL,
"/apps/basic-gconf-app/foo",
"/apps/basic-gconf-app/bar",
"/apps/basic-gconf-app/baz",
"/apps/basic-gconf-app/blah",
NULL);
g_object_set_data(dialog, "revert_changeset", revert_cs);
}
cs = g_object_get_data(dialog, "changeset");
/* again, relying on default error handler. The third argument here
is whether to remove the successfully-committed items from the
change set; here we remove the already-committed stuff, so if the
user resolves the error, they can bang on "apply" some more and
commit the remaining items. The return value indicates whether an
error occurred. */
gconf_client_commit_change_set(client, cs, TRUE, NULL);
prefs_dialog_update_sensitivity(dialog);
}
static void
do_copy_authorized (GConfDefaults *mechanism,
DBusGMethodInvocation *context,
gpointer user_data)
{
CopyData *data = user_data;
GConfClient *source = NULL;
GConfClient *dest = NULL;
GConfChangeSet *changes = NULL;
GConfEngine *engine;
char *address = NULL;
gint i;
GError *error;
error = NULL;
engine = gconf_engine_get_local (data->dest_address, &error);
if (error)
goto cleanup;
dest = gconf_client_get_for_engine (engine);
gconf_engine_unref (engine);
/* find the address to from the caller id */
address = gconf_address_for_caller (data->mechanism, data->context, &error);
if (error)
goto cleanup;
engine = gconf_engine_get_local (address, &error);
if (error)
goto cleanup;
source = gconf_client_get_for_engine (engine);
gconf_engine_unref (engine);
changes = gconf_change_set_new ();
if (data->value) {
g_assert (data->includes[1] == NULL);
g_assert (data->excludes == NULL);
gconf_change_set_set (changes, data->includes[0], data->value);
}
else {
/* recursively copy each include, leaving out the excludes */
for (i = 0; data->includes[i]; i++) {
if (gconf_client_dir_exists (source, data->includes[i], NULL))
copy_tree (source, data->includes[i], changes, (const char **)data->excludes);
else
copy_entry (source, data->includes[i], changes, (const char **)data->excludes);
}
}
gconf_client_commit_change_set (dest, changes, FALSE, &error);
gconf_client_suggest_sync (dest, NULL);
if (data->changeset_callback) {
data->changeset_callback (data->mechanism, changes, data->user_data);
}
cleanup:
g_free (address);
if (changes)
gconf_change_set_unref (changes);
if (dest)
g_object_unref (dest);
if (source)
g_object_unref (source);
if (error) {
throw_error (data->context,
GCONF_DEFAULTS_ERROR_GENERAL,
"%s", error->message);
g_error_free (error);
}
else
dbus_g_method_return (data->context);
}
static void
do_set_value (GConfDefaults *mechanism,
gboolean mandatory,
const char *path,
const char *value,
DBusGMethodInvocation *context,
GConfChangeSet **changeset_out)
{
GConfClient *dest = NULL;
GConfChangeSet *changes = NULL;
GConfEngine *engine;
GConfValue *gvalue;
GError *error;
GError *error2;
const char *action;
const char *annotation_key;
const char *default_action;
const char *dest_address;
if (changeset_out)
*changeset_out = NULL;
stop_killtimer ();
if (mandatory) {
annotation_key = "org.gnome.gconf.defaults.set-mandatory.prefix";
default_action = "org.gnome.gconf.defaults.set-mandatory";
dest_address = "xml:merged:/etc/gconf/gconf.xml.mandatory";
}
else {
annotation_key = "org.gnome.gconf.defaults.set-system.prefix";
default_action = "org.gnome.gconf.defaults.set-system";
dest_address = "xml:merged:/etc/gconf/gconf.xml.system";
}
action = polkit_action_for_gconf_path (mechanism, annotation_key, path);
if (action == NULL)
action = default_action;
if (!check_polkit_for_action (mechanism, context, action))
goto out;
error = NULL;
engine = gconf_engine_get_local (dest_address, &error);
if (error)
goto cleanup;
dest = gconf_client_get_for_engine (engine);
gconf_engine_unref (engine);
changes = gconf_change_set_new ();
gvalue = gconf_value_decode (value);
if (!gvalue)
goto cleanup;
gconf_change_set_set (changes, path, gvalue);
gconf_value_free (gvalue);
gconf_client_commit_change_set (dest, changes, FALSE, &error);
gconf_client_suggest_sync (dest, NULL);
if (changeset_out) {
*changeset_out = changes;
changes = NULL;
}
cleanup:
if (changes)
gconf_change_set_unref (changes);
if (dest)
g_object_unref (dest);
if (error) {
g_print ("failed to set GConf values: %s\n", error->message);
error2 = g_error_new_literal (GCONF_DEFAULTS_ERROR,
GCONF_DEFAULTS_ERROR_GENERAL,
error->message);
g_error_free (error);
dbus_g_method_return_error (context, error2);
g_error_free (error2);
}
else
dbus_g_method_return (context);
out:
start_killtimer ();
}
static void
do_copy (GConfDefaults *mechanism,
gboolean mandatory,
const char **includes,
const char **excludes,
DBusGMethodInvocation *context,
GConfChangeSet **changeset_out)
{
char *address = NULL;
GConfClient *source = NULL;
GConfClient *dest = NULL;
GConfChangeSet *changes = NULL;
GConfEngine *engine;
GError *error;
GError *error2;
const char *action;
const char *annotation_key;
const char *default_action;
const char *dest_address;
int i;
if (changeset_out)
*changeset_out = NULL;
stop_killtimer ();
/* check privileges for each include */
if (mandatory) {
annotation_key = "org.gnome.gconf.defaults.set-mandatory.prefix";
default_action = "org.gnome.gconf.defaults.set-mandatory";
dest_address = "xml:merged:" SYSGCONFDIR "/gconf.xml.mandatory";
}
else {
annotation_key = "org.gnome.gconf.defaults.set-system.prefix";
default_action = "org.gnome.gconf.defaults.set-system";
dest_address = "xml:merged:" SYSGCONFDIR "/gconf.xml.system";
}
for (i = 0; includes[i]; i++) {
action = polkit_action_for_gconf_path (mechanism, annotation_key, includes[i]);
if (action == NULL)
action = default_action;
if (!check_polkit_for_action (mechanism, context, action))
goto out;
}
error = NULL;
engine = gconf_engine_get_local (dest_address, &error);
if (error)
goto cleanup;
dest = gconf_client_get_for_engine (engine);
gconf_engine_unref (engine);
/* find the address to from the caller id */
address = gconf_address_for_caller (mechanism, context, &error);
if (error)
goto cleanup;
engine = gconf_engine_get_local (address, &error);
if (error)
goto cleanup;
source = gconf_client_get_for_engine (engine);
gconf_engine_unref (engine);
changes = gconf_change_set_new ();
/* recursively copy each include, leaving out the excludes */
for (i = 0; includes[i]; i++) {
if (gconf_client_dir_exists (source, includes[i], NULL))
copy_tree (source, includes[i], changes, excludes);
else
copy_entry (source, includes[i], changes, excludes);
}
gconf_client_commit_change_set (dest, changes, FALSE, &error);
gconf_client_suggest_sync (dest, NULL);
if (changeset_out) {
*changeset_out = changes;
changes = NULL;
}
cleanup:
g_free (address);
if (changes)
gconf_change_set_unref (changes);
if (dest)
g_object_unref (dest);
if (source)
g_object_unref (source);
if (error) {
g_print ("failed to set GConf values: %s\n", error->message);
error2 = g_error_new_literal (GCONF_DEFAULTS_ERROR,
GCONF_DEFAULTS_ERROR_GENERAL,
error->message);
g_error_free (error);
dbus_g_method_return_error (context, error2);
g_error_free (error2);
}
else
dbus_g_method_return (context);
out:
start_killtimer ();
}
gboolean
gnomegadu_protocol_loop (GIOChannel * source, GIOCondition condition, gpointer data)
{
static gint prev_check = GG_CHECK_READ;
gboolean ret = TRUE;
struct gg_event *e = NULL;
/* w przypadku bledu/utraty polaczenia postap tak jak w przypadku disconnect */
if (!gnomegadu_gadugadu_session || !(e = gg_watch_fd (gnomegadu_gadugadu_session)) || (condition & G_IO_ERR) ||
((condition & G_IO_HUP)
&& ((gnomegadu_gadugadu_session->state != GG_STATE_CONNECTING_GG) && (gnomegadu_gadugadu_session->check != GG_CHECK_WRITE))))
{
g_printerr ("gnomegadu_protocol_loop(): some kind of problem while processing\n");
gnomegadu_gadugadu_disconnect ();
prev_check = GG_CHECK_READ;
return FALSE;
}
switch (e->type)
{
case GG_EVENT_NONE:
g_print ("GG_EVENT_NONE\n");
break;
case GG_EVENT_PONG:
g_print ("GG_EVENT_PONG\n");
gg_ping (gnomegadu_gadugadu_session);
break;
case GG_EVENT_CONN_FAILED:
g_print ("GG_EVENT_CONN_FAILED\n");
gnomegadu_gadugadu_disconnect ();
ret = FALSE;
break;
case GG_EVENT_DISCONNECT:
g_print ("GG_EVENT_DISCONNECT\n");
gnomegadu_gadugadu_disconnect ();
ret = FALSE;
break;
case GG_EVENT_CONN_SUCCESS:
{
g_print ("GG_EVENT_CONN_SUCCESS\n");
//wysyłam swoją listę
gint i, j = 0;
uint32_t *uins;
GSList *contacts_list = gnomegadu_conf_get_contacts ();
GSList *contacts_list_start = contacts_list;
gnomegadu_protocol_is_connected = TRUE;
if (!contacts_list)
break;
i = g_slist_length (contacts_list);
uins = g_malloc0 (i * sizeof (uint32_t));
while (contacts_list)
{
gchar *uin_str;
gchar *path = (gchar *) contacts_list->data;
gchar *uin_path = g_strconcat (path, "/uin", NULL);
uin_str = gconf_client_get_string (gconf, uin_path, NULL);
uins[j++] = g_strtod (uin_str, NULL);
g_free (uin_path);
contacts_list = g_slist_next(contacts_list);
}
if (j > 0)
gg_notify (gnomegadu_gadugadu_session, uins, i);
/* pingpong */
g_timeout_add(100000, gnomegadu_protocol_ping, NULL);
g_slist_foreach (contacts_list_start, gnomegadu_conf_free_list_of_string, NULL);
g_slist_free (contacts_list_start);
g_free (uins);
}
break;
// case GG_EVENT_NOTIFY_DESCR:
case GG_EVENT_NOTIFY:
{
gint i;
g_print ("GG_EVENT_NOTIFY\n");
for (i = 0; e->event.notify[i].uin; i++)
{
gchar *uin_str = g_strdup_printf ("%d", e->event.notify[i].uin);
gint new_status = gnomegadu_gadugadu_from_protocol_status (e->event.notify[i].status);
gnomegadu_userlist_set_model_status (uin_str, new_status, NULL); //tutaj dodac obsluge opisów
g_free (uin_str);
}
}
break;
case GG_EVENT_NOTIFY60:
{
gint i;
g_print ("GG_EVENT_NOTIFY60\n");
for (i = 0; e->event.notify60[i].uin; i++)
{
gchar *descr_utf = NULL;
gchar *uin_str = g_strdup_printf ("%d", e->event.notify60[i].uin);
gint new_status = gnomegadu_gadugadu_from_protocol_status (e->event.notify60[i].status);
if (e->event.notify60[i].descr)
descr_utf =
g_convert (e->event.notify60[i].descr, strlen (e->event.notify60[i].descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
gnomegadu_userlist_set_model_status (uin_str, new_status, descr_utf);
g_free (uin_str);
}
}
break;
case GG_EVENT_STATUS:
case GG_EVENT_STATUS60:
{
GdkPixbuf *pix = NULL;
gchar *descr_utf = NULL;
gchar *uuid = NULL;
gchar *display = NULL;
gchar *notify_txt = NULL;
gint new_status;
gchar *uin_str = NULL;
if (e->type == GG_EVENT_STATUS)
{
new_status = gnomegadu_gadugadu_from_protocol_status (e->event.status.status);
uin_str = g_strdup_printf ("%d", e->event.status.uin);
if (e->event.status.descr)
descr_utf = g_convert (e->event.status.descr, strlen (e->event.status.descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
} else {
new_status = gnomegadu_gadugadu_from_protocol_status (e->event.status60.status);
uin_str = g_strdup_printf ("%d", e->event.status60.uin);
if (e->event.status60.descr)
descr_utf = g_convert (e->event.status60.descr, strlen (e->event.status60.descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
}
gnomegadu_userlist_set_model_status (uin_str, new_status, descr_utf);
uuid = gnomegadu_conf_contact_get_uuid_for_uin(uin_str);
display = gnomegadu_conf_contact_get_display_for_uuid(uuid);
pix = gnomegadu_stock_get_pixbuf (gnomegadu_ui_status_get_icon_name (new_status));
notify_txt = g_strdup_printf("Status: %s\n<span size=\"smaller\" style=\"italic\">%s</span>",gnomegadu_protocol_status_txt(new_status),descr_utf ? descr_utf : "");
gnomegadu_ui_notify_show (display, notify_txt, pix);
g_object_unref (pix);
gnomegadu_tray_blinking(2000);
g_free (notify_txt);
g_free (display);
g_free (uuid);
g_free (uin_str);
}
break;
case GG_EVENT_USERLIST:
{
g_print ("GG_EVENT_USERLIST\n");
if (e->event.userlist.type == GG_USERLIST_GET_REPLY)
{
gint i;
gfloat step;
gchar **split_buf = NULL;
GtkWidget *progress = glade_xml_get_widget (gladexml_import_userlist_progress, "ImportUserlistServerProgress");
GtkWidget *progress_window = glade_xml_get_widget (gladexml_import_userlist_progress, "ImportUserlistServerProgressWindow");
if (!progress_window || !progress)
break;
gchar *buf = e->event.userlist.reply;
if (!buf)
{
gtk_widget_destroy(GTK_WIDGET(progress_window));
GtkDialog *msgdialog = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
"<span weight=\"bold\"size=\"larger\">Lista jest pusta</span>\n\nLista kontaktów na serwerze jest pusta.");
gtk_dialog_run (GTK_DIALOG (msgdialog));
gtk_widget_destroy (GTK_WIDGET (msgdialog));
break;
}
GConfChangeSet *changeset = gconf_change_set_new();
split_buf = g_strsplit (buf, "\r\n", 2048);
step = 1 / (gfloat)g_strv_length (split_buf);
for (i = 0; i < g_strv_length (split_buf); i++)
{
gdouble percentage = gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR (progress));
if (percentage < 1)
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), percentage + step);
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL,TRUE);
gnomegadu_ui_import_userlist_process_line (split_buf[i], changeset);
if (!gconf_client_commit_change_set(gconf, changeset, TRUE, NULL))
g_printerr("Some error while import");
}
gconf_change_set_unref(changeset);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), 1);
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL,TRUE);
gtk_widget_destroy(GTK_WIDGET(progress_window));
}
}
break;
case GG_EVENT_MSG:
{
gchar *uin_sender = NULL;
if (e->event.msg.msgclass == GG_CLASS_CHAT)
{
gint i = 0;
uin_sender = g_strdup_printf("%d", e->event.msg.sender);
gchar *txt = g_strdup((gchar *)e->event.msg.message);
gchar *txt_utf = NULL;
GList *list = NULL;
g_print("message from sender: (%s):%s\n",uin_sender,txt);
/* first add sender */
list = g_list_append(list,g_strdup(uin_sender));
if (e->event.msg.recipients_count > 0)
{
gchar *uin_str_2 = NULL;
/* then add recipients */
for (i = 0; i < e->event.msg.recipients_count; i++)
{
uin_str_2 = g_strdup_printf("%d",e->event.msg.recipients[i]);
list = g_list_append(list,g_strdup(uin_str_2));
g_free(uin_str_2);
g_print("conference(%d): %s\n",e->event.msg.recipients_count,uin_str_2);
}
}
g_assert(list);
//chat window
GladeXML *chat_window_xml = gnomegadu_ui_chat_find(list,TRUE);
g_assert(chat_window_xml);
txt_utf = g_convert (txt, strlen (txt), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
gnomegadu_ui_chat_append_text(chat_window_xml,txt_utf,GNOMEGADU_CHAT_RCV, uin_sender);
g_free(txt);
g_free(uin_sender);
}
}
break;
}
gg_free_event (e);
if (gnomegadu_gadugadu_session && prev_check != gnomegadu_gadugadu_session->check)
{
prev_check = gnomegadu_gadugadu_session->check;
if (gnomegadu_gadugadu_session->check == GG_CHECK_READ)
{
g_source_remove (gnomegadu_watch_protocol);
gnomegadu_watch_protocol = g_io_add_watch (gnomegadu_source_chan, G_IO_IN | G_IO_ERR | G_IO_HUP, gnomegadu_protocol_loop, NULL);
ret = FALSE;
}
if (gnomegadu_gadugadu_session->check == GG_CHECK_WRITE)
{
g_source_remove (gnomegadu_watch_protocol);
gnomegadu_watch_protocol = g_io_add_watch (gnomegadu_source_chan, G_IO_OUT | G_IO_ERR | G_IO_HUP, gnomegadu_protocol_loop, NULL);
ret = FALSE;
}
}
return ret;
}
