static void chat_text_view_append_event (EmpathyChatView *view, const gchar *str) { EmpathyChatTextView *text_view = EMPATHY_CHAT_TEXT_VIEW (view); EmpathyChatTextViewPriv *priv = GET_PRIV (text_view); gboolean bottom; GtkTextIter iter; gchar *msg; g_return_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view)); g_return_if_fail (!EMP_STR_EMPTY (str)); bottom = chat_text_view_is_scrolled_down (text_view); chat_text_view_maybe_trim_buffer (EMPATHY_CHAT_TEXT_VIEW (view)); chat_text_maybe_append_date_and_time (text_view, empathy_time_get_current ()); gtk_text_buffer_get_end_iter (priv->buffer, &iter); msg = g_strdup_printf (" - %s\n", str); gtk_text_buffer_insert_with_tags_by_name (priv->buffer, &iter, msg, -1, EMPATHY_CHAT_TEXT_VIEW_TAG_EVENT, NULL); g_free (msg); if (bottom) { chat_text_view_scroll_down (view); } if (priv->last_contact) { g_object_unref (priv->last_contact); priv->last_contact = NULL; g_object_notify (G_OBJECT (view), "last-contact"); } }
void empathy_account_widget_add_forget_button (McAccount *account, GtkBuilder *gui, const gchar *button, const gchar *entry) { GtkWidget *button_forget; GtkWidget *entry_password; gchar *password = NULL; button_forget = GTK_WIDGET (gtk_builder_get_object (gui, button)); entry_password = GTK_WIDGET (gtk_builder_get_object (gui, entry)); mc_account_get_param_string (account, "password", &password); gtk_widget_set_sensitive (button_forget, !EMP_STR_EMPTY (password)); g_free (password); g_signal_connect (button_forget, "clicked", G_CALLBACK (account_widget_forget_clicked_cb), entry_password); g_signal_connect (entry_password, "changed", G_CALLBACK (account_widget_password_changed_cb), button_forget); }
void empathy_presence_manager_set_presence (EmpathyPresenceManager *self, TpConnectionPresenceType state, const gchar *status) { const gchar *default_status; DEBUG ("Changing presence to %s (%d)", status, state); g_free (self->priv->requested_status_message); self->priv->requested_presence_type = state; self->priv->requested_status_message = g_strdup (status); /* Do not set translated default messages */ default_status = empathy_presence_get_default_message (state); if (!tp_strdiff (status, default_status)) status = NULL; if (state != TP_CONNECTION_PRESENCE_TYPE_OFFLINE && !empathy_connectivity_is_online (self->priv->connectivity)) { DEBUG ("Empathy is not online"); self->priv->saved_state = state; if (tp_strdiff (self->priv->status, status)) { g_free (self->priv->saved_status); self->priv->saved_status = NULL; if (!EMP_STR_EMPTY (status)) self->priv->saved_status = g_strdup (status); } return; } empathy_presence_manager_do_set_presence (self, state, status); }
static void most_available_presence_changed (TpAccountManager *manager, TpConnectionPresenceType state, gchar *status, gchar *status_message, EmpathyPresenceManager *self) { if (state == TP_CONNECTION_PRESENCE_TYPE_UNSET) /* Assume our presence is offline if MC reports UNSET */ state = TP_CONNECTION_PRESENCE_TYPE_OFFLINE; DEBUG ("Presence changed to '%s' (%d) \"%s\"", status, state, status_message); g_free (self->priv->status); self->priv->state = state; if (EMP_STR_EMPTY (status_message)) self->priv->status = NULL; else self->priv->status = g_strdup (status_message); g_object_notify (G_OBJECT (self), "state"); g_object_notify (G_OBJECT (self), "status"); }
static void chat_text_view_populate_popup (EmpathyChatTextView *view, GtkMenu *menu, gpointer user_data) { EmpathyChatTextViewPriv *priv; GtkTextTagTable *table; GtkTextTag *tag; gint x, y; GtkTextIter iter, start, end; GtkWidget *item; gchar *str = NULL; priv = GET_PRIV (view); /* Clear menu item */ if (gtk_text_buffer_get_char_count (priv->buffer) > 0) { item = gtk_menu_item_new (); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); item = gtk_image_menu_item_new_from_stock (GTK_STOCK_CLEAR, NULL); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); g_signal_connect (item, "activate", G_CALLBACK (chat_text_view_clear_view_cb), view); } /* Link context menu items */ table = gtk_text_buffer_get_tag_table (priv->buffer); tag = gtk_text_tag_table_lookup (table, EMPATHY_CHAT_TEXT_VIEW_TAG_LINK); gtk_widget_get_pointer (GTK_WIDGET (view), &x, &y); gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (view), GTK_TEXT_WINDOW_WIDGET, x, y, &x, &y); gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (view), &iter, x, y); start = end = iter; if (gtk_text_iter_backward_to_tag_toggle (&start, tag) && gtk_text_iter_forward_to_tag_toggle (&end, tag)) { str = gtk_text_buffer_get_text (priv->buffer, &start, &end, FALSE); } if (EMP_STR_EMPTY (str)) { g_free (str); return; } /* NOTE: Set data just to get the string freed when not needed. */ g_object_set_data_full (G_OBJECT (menu), "url", str, (GDestroyNotify) g_free); item = gtk_menu_item_new (); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); item = gtk_menu_item_new_with_mnemonic (_("_Copy Link Address")); g_signal_connect (item, "activate", G_CALLBACK (chat_text_view_copy_address_cb), str); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); item = gtk_menu_item_new_with_mnemonic (_("_Open Link")); g_signal_connect (item, "activate", G_CALLBACK (chat_text_view_open_address_cb), str); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); }
static void dispatch_cb (EmpathyDispatcher *dispatcher, EmpathyDispatchOperation *operation, gpointer user_data) { GQuark channel_type; channel_type = empathy_dispatch_operation_get_channel_type_id (operation); if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_TEXT) { EmpathyTpChat *tp_chat; EmpathyChat *chat = NULL; const gchar *id; tp_chat = EMPATHY_TP_CHAT (empathy_dispatch_operation_get_channel_wrapper (operation)); id = empathy_tp_chat_get_id (tp_chat); if (!EMP_STR_EMPTY (id)) { TpConnection *connection; TpAccount *account; connection = empathy_tp_chat_get_connection (tp_chat); account = empathy_get_account_for_connection (connection); chat = empathy_chat_window_find_chat (account, id); } if (chat) { empathy_chat_set_tp_chat (chat, tp_chat); } else { chat = empathy_chat_new (tp_chat); /* empathy_chat_new returns a floating reference as EmpathyChat is * a GtkWidget. This reference will be taken by a container * (a GtkNotebook) when we'll call empathy_chat_window_present_chat */ } empathy_chat_window_present_chat (chat); empathy_dispatch_operation_claim (operation); } else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA) { EmpathyCallFactory *factory; factory = empathy_call_factory_get (); empathy_call_factory_claim_channel (factory, operation); } else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER) { EmpathyFTFactory *factory; factory = empathy_ft_factory_dup_singleton (); /* if the operation is not incoming, don't claim it, * as it might have been triggered by another client, and * we are observing it. */ if (empathy_dispatch_operation_is_incoming (operation)) empathy_ft_factory_claim_channel (factory, operation); } }
static void do_constructed (GObject *obj) { EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj); EmpathyAccountWidgetPriv *priv = GET_PRIV (self); TpAccount *account; const gchar *protocol, *cm_name; guint i = 0; struct { const gchar *cm_name; const gchar *protocol; const char *file; void (*func)(EmpathyAccountWidget *self, const gchar *filename); } widgets [] = { { "salut", "local-xmpp", "empathy-account-widget-local-xmpp.ui", account_widget_build_salut }, WIDGET (gabble, jabber), WIDGET (butterfly, msn), WIDGET (haze, icq), WIDGET (haze, aim), WIDGET (haze, yahoo), WIDGET (haze, groupwise), WIDGET (idle, irc), WIDGET (sofiasip, sip), }; cm_name = empathy_account_settings_get_cm (priv->settings); protocol = empathy_account_settings_get_protocol (priv->settings); for (i = 0 ; i < G_N_ELEMENTS (widgets); i++) { if (!tp_strdiff (widgets[i].cm_name, cm_name) && !tp_strdiff (widgets[i].protocol, protocol)) { gchar *filename; filename = empathy_file_lookup (widgets[i].file, "libempathy-gtk"); widgets[i].func (self, filename); g_free (filename); break; } } if (i == G_N_ELEMENTS (widgets)) { gchar *filename = empathy_file_lookup ( "empathy-account-widget-generic.ui", "libempathy-gtk"); account_widget_build_generic (self, filename); g_free (filename); } /* handle default focus */ if (self->ui_details->default_focus != NULL) { GObject *default_focus_entry; default_focus_entry = gtk_builder_get_object (self->ui_details->gui, self->ui_details->default_focus); g_signal_connect (default_focus_entry, "realize", G_CALLBACK (gtk_widget_grab_focus), NULL); } /* handle forget button */ if (self->ui_details->add_forget) { const gchar *password = NULL; priv->button_forget = GTK_WIDGET (gtk_builder_get_object (self->ui_details->gui, "button_forget")); priv->entry_password = GTK_WIDGET (gtk_builder_get_object (self->ui_details->gui, "entry_password")); password = empathy_account_settings_get_string (priv->settings, "password"); gtk_widget_set_sensitive (priv->button_forget, !EMP_STR_EMPTY (password)); g_signal_connect (priv->button_forget, "clicked", G_CALLBACK (account_widget_forget_clicked_cb), self); g_signal_connect (priv->entry_password, "changed", G_CALLBACK (account_widget_password_changed_cb), self); } /* handle apply and cancel button */ if (!priv->simple) { GtkWidget *hbox = gtk_hbox_new (TRUE, 3); priv->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); if (priv->creating_account) { TpConnectionPresenceType state; priv->idle = empathy_idle_dup_singleton (); empathy_signal_connect_weak (priv->idle, "notify::state", G_CALLBACK (idle_state_change_cb), obj); state = empathy_idle_get_state (priv->idle); if (state > TP_CONNECTION_PRESENCE_TYPE_OFFLINE) { /* We are online, display a Login button */ GtkWidget *image; priv->apply_button = gtk_button_new_with_mnemonic (_("L_og in")); image = gtk_image_new_from_stock (GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (priv->apply_button), image); } else { /* We are offline, display a Save button */ priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_SAVE); } } else { /* We are editing an existing account, display an Apply button */ priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY); } gtk_box_pack_end (GTK_BOX (hbox), priv->apply_button, TRUE, TRUE, 3); gtk_box_pack_end (GTK_BOX (hbox), priv->cancel_button, TRUE, TRUE, 3); gtk_box_pack_end (GTK_BOX (self->ui_details->widget), hbox, FALSE, FALSE, 3); g_signal_connect (priv->cancel_button, "clicked", G_CALLBACK (account_widget_cancel_clicked_cb), self); g_signal_connect (priv->apply_button, "clicked", G_CALLBACK (account_widget_apply_clicked_cb), self); gtk_widget_show_all (hbox); if (priv->creating_account) /* When creating an account, the user might have nothing to enter. * That means that no control interaction might occur, * so we update the control button sensitivity manually. */ account_widget_handle_control_buttons_sensitivity (self); else account_widget_set_control_buttons_sensitivity (self, FALSE); } account = empathy_account_settings_get_account (priv->settings); if (account != NULL) { g_signal_connect (account, "notify::enabled", G_CALLBACK (empathy_account_widget_enabled_cb), self); } /* handle the "Enabled" checkbox. We only add it when modifying an account */ if (!priv->creating_account && priv->table_common_settings != NULL) { #ifdef HAVE_MOBLIN GtkWidget *w; #endif guint nb_rows, nb_columns; gboolean is_enabled; is_enabled = tp_account_is_enabled (account); #ifndef HAVE_MOBLIN priv->enabled_checkbox = gtk_check_button_new_with_label (_("Enabled")); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (priv->enabled_checkbox), is_enabled); #else /* Translators: this is used only when built on a moblin platform */ w = gtk_label_new (_("Account:")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); priv->enabled_checkbox = nbtk_gtk_light_switch_new (); nbtk_gtk_light_switch_set_active ( NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox), is_enabled); gtk_widget_show (w); #endif /* HAVE_MOBLIN */ g_object_get (priv->table_common_settings, "n-rows", &nb_rows, "n-columns", &nb_columns, NULL); gtk_table_resize (GTK_TABLE (priv->table_common_settings), ++nb_rows, nb_columns); #ifndef HAVE_MOBLIN gtk_table_attach (GTK_TABLE (priv->table_common_settings), priv->enabled_checkbox, 0, nb_columns, nb_rows - 1, nb_rows, GTK_EXPAND | GTK_FILL, 0, 0, 0); #else gtk_table_attach (GTK_TABLE (priv->table_common_settings), w, 0, 1, nb_rows - 1, nb_rows, GTK_FILL, 0, 0, 0); gtk_table_attach (GTK_TABLE (priv->table_common_settings), priv->enabled_checkbox, 1, nb_columns, nb_rows - 1, nb_rows, GTK_EXPAND | GTK_FILL, 0, 0, 0); #endif /* HAVE_MOBLIN */ gtk_widget_show (priv->enabled_checkbox); #ifndef HAVE_MOBLIN g_signal_connect (G_OBJECT (priv->enabled_checkbox), "released", G_CALLBACK (account_widget_enabled_released_cb), self); #else g_signal_connect (G_OBJECT (priv->enabled_checkbox), "switch-flipped", G_CALLBACK (account_widget_switch_flipped_cb), self); #endif /* HAVE_MOBLIN */ } /* hook up to widget destruction to unref ourselves */ g_signal_connect (self->ui_details->widget, "destroy", G_CALLBACK (account_widget_destroy_cb), self); empathy_builder_unref_and_keep_widget (self->ui_details->gui, self->ui_details->widget); self->ui_details->gui = NULL; }
GList * empathy_log_manager_get_messages_for_file (EmpathyLogManager *manager, const gchar *filename) { GList *messages = NULL; xmlParserCtxtPtr ctxt; xmlDocPtr doc; xmlNodePtr log_node; xmlNodePtr node; EmpathyLogSearchHit *hit; McAccount *account; g_return_val_if_fail (EMPATHY_IS_LOG_MANAGER (manager), NULL); g_return_val_if_fail (filename != NULL, NULL); DEBUG ("Attempting to parse filename:'%s'...", filename); if (!g_file_test (filename, G_FILE_TEST_EXISTS)) { DEBUG ("Filename:'%s' does not exist", filename); return NULL; } /* Get the account from the filename */ hit = log_manager_search_hit_new (manager, filename); account = g_object_ref (hit->account); log_manager_search_hit_free (hit); /* Create parser. */ ctxt = xmlNewParserCtxt (); /* Parse and validate the file. */ doc = xmlCtxtReadFile (ctxt, filename, NULL, 0); if (!doc) { g_warning ("Failed to parse file:'%s'", filename); xmlFreeParserCtxt (ctxt); return NULL; } /* The root node, presets. */ log_node = xmlDocGetRootElement (doc); if (!log_node) { xmlFreeDoc (doc); xmlFreeParserCtxt (ctxt); return NULL; } /* Now get the messages. */ for (node = log_node->children; node; node = node->next) { EmpathyMessage *message; EmpathyContact *sender; gchar *time; time_t t; gchar *sender_id; gchar *sender_name; gchar *sender_avatar_token; gchar *body; gchar *is_user_str; gboolean is_user = FALSE; gchar *msg_type_str; TpChannelTextMessageType msg_type = TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL; if (strcmp (node->name, "message") != 0) { continue; } body = xmlNodeGetContent (node); time = xmlGetProp (node, "time"); sender_id = xmlGetProp (node, "id"); sender_name = xmlGetProp (node, "name"); sender_avatar_token = xmlGetProp (node, "token"); is_user_str = xmlGetProp (node, "isuser"); msg_type_str = xmlGetProp (node, "type"); if (is_user_str) { is_user = strcmp (is_user_str, "true") == 0; } if (msg_type_str) { msg_type = empathy_message_type_from_str (msg_type_str); } t = empathy_time_parse (time); sender = empathy_contact_new_full (account, sender_id, sender_name); empathy_contact_set_is_user (sender, is_user); if (!EMP_STR_EMPTY (sender_avatar_token)) { empathy_contact_load_avatar_cache (sender, sender_avatar_token); } message = empathy_message_new (body); empathy_message_set_sender (message, sender); empathy_message_set_timestamp (message, t); empathy_message_set_tptype (message, msg_type); messages = g_list_append (messages, message); g_object_unref (sender); xmlFree (time); xmlFree (sender_id); xmlFree (sender_name); xmlFree (body); xmlFree (is_user_str); xmlFree (msg_type_str); } DEBUG ("Parsed %d messages", g_list_length (messages)); xmlFreeDoc (doc); xmlFreeParserCtxt (ctxt); return messages; }
void empathy_log_manager_add_message (EmpathyLogManager *manager, const gchar *chat_id, gboolean chatroom, EmpathyMessage *message) { FILE *file; McAccount *account; EmpathyContact *sender; const gchar *body_str; const gchar *str; EmpathyAvatar *avatar; gchar *avatar_token = NULL; gchar *filename; gchar *basedir; gchar *body; gchar *timestamp; gchar *contact_name; gchar *contact_id; TpChannelTextMessageType msg_type; g_return_if_fail (EMPATHY_IS_LOG_MANAGER (manager)); g_return_if_fail (chat_id != NULL); g_return_if_fail (EMPATHY_IS_MESSAGE (message)); sender = empathy_message_get_sender (message); account = empathy_contact_get_account (sender); body_str = empathy_message_get_body (message); msg_type = empathy_message_get_tptype (message); if (EMP_STR_EMPTY (body_str)) { return; } filename = log_manager_get_filename (manager, account, chat_id, chatroom); basedir = g_path_get_dirname (filename); if (!g_file_test (basedir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) { DEBUG ("Creating directory:'%s'", basedir); g_mkdir_with_parents (basedir, LOG_DIR_CREATE_MODE); } g_free (basedir); DEBUG ("Adding message: '%s' to file: '%s'", body_str, filename); if (!g_file_test (filename, G_FILE_TEST_EXISTS)) { file = g_fopen (filename, "w+"); if (file) { g_fprintf (file, LOG_HEADER); } g_chmod (filename, LOG_FILE_CREATE_MODE); } else { file = g_fopen (filename, "r+"); if (file) { fseek (file, - strlen (LOG_FOOTER), SEEK_END); } } body = g_markup_escape_text (body_str, -1); timestamp = log_manager_get_timestamp_from_message (message); str = empathy_contact_get_name (sender); contact_name = g_markup_escape_text (str, -1); str = empathy_contact_get_id (sender); contact_id = g_markup_escape_text (str, -1); avatar = empathy_contact_get_avatar (sender); if (avatar) { avatar_token = g_markup_escape_text (avatar->token, -1); } g_fprintf (file, "<message time='%s' id='%s' name='%s' token='%s' isuser='******' type='%s'>%s</message>\n" LOG_FOOTER, timestamp, contact_id, contact_name, avatar_token ? avatar_token : "", empathy_contact_is_user (sender) ? "true" : "false", empathy_message_type_to_str (msg_type), body); fclose (file); g_free (filename); g_free (contact_id); g_free (contact_name); g_free (timestamp); g_free (body); g_free (avatar_token); }
static void contact_list_store_add_contact (EmpathyContactListStore *store, EmpathyContact *contact) { EmpathyContactListStorePriv *priv; GtkTreeIter iter; GList *groups = NULL, *l; TpConnection *connection; EmpathyContactListFlags flags = 0; priv = GET_PRIV (store); if (EMP_STR_EMPTY (empathy_contact_get_name (contact)) || (!priv->show_offline && !empathy_contact_is_online (contact))) { return; } if (priv->show_groups) { groups = empathy_contact_list_get_groups (priv->list, contact); } connection = empathy_contact_get_connection (contact); if (EMPATHY_IS_CONTACT_MANAGER (priv->list)) { flags = empathy_contact_manager_get_flags_for_connection ( EMPATHY_CONTACT_MANAGER (priv->list), connection); } /* If no groups just add it at the top level. */ if (!groups) { GtkTreeModel *model = GTK_TREE_MODEL (store); if (gtk_tree_model_get_iter_first (model, &iter)) do { EmpathyContact *c; gtk_tree_model_get (model, &iter, EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &c, -1); if (c == contact) { g_object_unref (c); return; } if (c != NULL) g_object_unref (c); } while (gtk_tree_model_iter_next (model, &iter)); gtk_tree_store_append (GTK_TREE_STORE (store), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (store), &iter, EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_AUDIO, EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_VIDEO, EMPATHY_CONTACT_LIST_STORE_COL_FLAGS, flags, -1); } /* Else add to each group. */ for (l = groups; l; l = l->next) { GtkTreeIter iter_group; contact_list_store_get_group (store, l->data, &iter_group, NULL, NULL); gtk_tree_store_insert_after (GTK_TREE_STORE (store), &iter, &iter_group, NULL); gtk_tree_store_set (GTK_TREE_STORE (store), &iter, EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_AUDIO, EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_VIDEO, EMPATHY_CONTACT_LIST_STORE_COL_FLAGS, flags, -1); g_free (l->data); } g_list_free (groups); contact_list_store_contact_update (store, contact); }
static void megaphone_applet_update_icon (MegaphoneApplet *applet) { MegaphoneAppletPriv *priv = GET_PRIV (applet); EmpathyAvatar *avatar = NULL; GdkPixbuf *avatar_pixbuf; if (priv->contact) { avatar = empathy_contact_get_avatar (priv->contact); } else { gtk_image_set_from_icon_name (GTK_IMAGE (priv->image), GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU); return; } if (!avatar) { gchar *avatar_token; /* Try to take avatar from cache */ avatar_token = panel_applet_gconf_get_string (PANEL_APPLET (applet), "avatar_token", NULL); if (!EMP_STR_EMPTY (avatar_token)) { empathy_contact_load_avatar_cache (priv->contact, avatar_token); avatar = empathy_contact_get_avatar (priv->contact); } g_free (avatar_token); } if (avatar) { avatar_pixbuf = empathy_pixbuf_from_avatar_scaled (avatar, priv->image_size - 2, priv->image_size - 2); } else { GtkIconTheme *icon_theme; /* Load the default icon when no avatar is found */ icon_theme = gtk_icon_theme_get_default (); avatar_pixbuf = gtk_icon_theme_load_icon (icon_theme, "stock_contact", priv->image_size - 2, 0, NULL); } /* Now some desaturation if the contact is offline */ if (!empathy_contact_is_online (priv->contact)) { GdkPixbuf *offline_avatar; offline_avatar = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, gdk_pixbuf_get_height (avatar_pixbuf), gdk_pixbuf_get_width (avatar_pixbuf)); gdk_pixbuf_saturate_and_pixelate (avatar_pixbuf, offline_avatar, 0.0, TRUE); g_object_unref (avatar_pixbuf); avatar_pixbuf = offline_avatar; } gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), avatar_pixbuf); g_object_unref (avatar_pixbuf); }
static GList * log_store_empathy_get_messages_for_file (EmpathyLogStore *self, TpAccount *account, const gchar *filename) { GList *messages = NULL; xmlParserCtxtPtr ctxt; xmlDocPtr doc; xmlNodePtr log_node; xmlNodePtr node; g_return_val_if_fail (EMPATHY_IS_LOG_STORE (self), NULL); g_return_val_if_fail (filename != NULL, NULL); DEBUG ("Attempting to parse filename:'%s'...", filename); if (!g_file_test (filename, G_FILE_TEST_EXISTS)) { DEBUG ("Filename:'%s' does not exist", filename); return NULL; } /* Create parser. */ ctxt = xmlNewParserCtxt (); /* Parse and validate the file. */ doc = xmlCtxtReadFile (ctxt, filename, NULL, 0); if (!doc) { g_warning ("Failed to parse file:'%s'", filename); xmlFreeParserCtxt (ctxt); return NULL; } /* The root node, presets. */ log_node = xmlDocGetRootElement (doc); if (!log_node) { xmlFreeDoc (doc); xmlFreeParserCtxt (ctxt); return NULL; } /* Now get the messages. */ for (node = log_node->children; node; node = node->next) { EmpathyMessage *message; EmpathyContact *sender; gchar *time_; time_t t; gchar *sender_id; gchar *sender_name; gchar *sender_avatar_token; gchar *body; gchar *is_user_str; gboolean is_user = FALSE; gchar *msg_type_str; gchar *cm_id_str; guint cm_id; TpChannelTextMessageType msg_type = TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL; if (strcmp ((const gchar *) node->name, "message") != 0) continue; body = (gchar *) xmlNodeGetContent (node); time_ = (gchar *) xmlGetProp (node, (const xmlChar *) "time"); sender_id = (gchar *) xmlGetProp (node, (const xmlChar *) "id"); sender_name = (gchar *) xmlGetProp (node, (const xmlChar *) "name"); sender_avatar_token = (gchar *) xmlGetProp (node, (const xmlChar *) "token"); is_user_str = (gchar *) xmlGetProp (node, (const xmlChar *) "isuser"); msg_type_str = (gchar *) xmlGetProp (node, (const xmlChar *) "type"); cm_id_str = (gchar *) xmlGetProp (node, (const xmlChar *) "cm_id"); if (is_user_str) is_user = strcmp (is_user_str, "true") == 0; if (msg_type_str) msg_type = empathy_message_type_from_str (msg_type_str); if (cm_id_str) cm_id = atoi (cm_id_str); t = empathy_time_parse (time_); sender = empathy_contact_new_for_log (account, sender_id, sender_name, is_user); if (!EMP_STR_EMPTY (sender_avatar_token)) empathy_contact_load_avatar_cache (sender, sender_avatar_token); message = empathy_message_new (body); empathy_message_set_sender (message, sender); empathy_message_set_timestamp (message, t); empathy_message_set_tptype (message, msg_type); empathy_message_set_is_backlog (message, TRUE); if (cm_id_str) empathy_message_set_id (message, cm_id); messages = g_list_append (messages, message); g_object_unref (sender); xmlFree (time_); xmlFree (sender_id); xmlFree (sender_name); xmlFree (body); xmlFree (is_user_str); xmlFree (msg_type_str); xmlFree (cm_id_str); xmlFree (sender_avatar_token); } DEBUG ("Parsed %d messages", g_list_length (messages)); xmlFreeDoc (doc); xmlFreeParserCtxt (ctxt); return messages; }
static gboolean chat_text_view_find_previous (EmpathyChatView *view, const gchar *search_criteria, gboolean new_search, gboolean match_case) { EmpathyChatTextViewPriv *priv; GtkTextBuffer *buffer; GtkTextIter iter_at_mark; GtkTextIter iter_match_start; GtkTextIter iter_match_end; gboolean found; gboolean from_start = FALSE; g_return_val_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view), FALSE); g_return_val_if_fail (search_criteria != NULL, FALSE); priv = GET_PRIV (view); buffer = priv->buffer; if (EMP_STR_EMPTY (search_criteria)) { if (priv->find_mark_previous) { gtk_text_buffer_get_start_iter (buffer, &iter_at_mark); gtk_text_buffer_move_mark (buffer, priv->find_mark_previous, &iter_at_mark); gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view), priv->find_mark_previous, 0.0, TRUE, 0.0, 0.0); gtk_text_buffer_select_range (buffer, &iter_at_mark, &iter_at_mark); } return FALSE; } if (new_search) { from_start = TRUE; } if (!new_search && priv->find_mark_previous) { gtk_text_buffer_get_iter_at_mark (buffer, &iter_at_mark, priv->find_mark_previous); } else { gtk_text_buffer_get_end_iter (buffer, &iter_at_mark); from_start = TRUE; } priv->find_last_direction = FALSE; /* Use the standard GTK+ method for case sensitive searches. It can't do * case insensitive searches (see bug #61852), so keep the custom method * around for case insensitive searches. */ if (match_case) { found = gtk_text_iter_backward_search (&iter_at_mark, search_criteria, 0, /* no text search flags, we want exact matches */ &iter_match_start, &iter_match_end, NULL); } else { found = empathy_text_iter_backward_search (&iter_at_mark, search_criteria, &iter_match_start, &iter_match_end, NULL); } if (!found) { gboolean result = FALSE; if (from_start) { return result; } /* Here we wrap around. */ if (!new_search && !priv->find_wrapped) { priv->find_wrapped = TRUE; result = chat_text_view_find_previous (view, search_criteria, FALSE, match_case); priv->find_wrapped = FALSE; } return result; } /* Set new mark and show on screen */ if (!priv->find_mark_previous) { priv->find_mark_previous = gtk_text_buffer_create_mark (buffer, NULL, &iter_match_start, TRUE); } else { gtk_text_buffer_move_mark (buffer, priv->find_mark_previous, &iter_match_start); } if (!priv->find_mark_next) { priv->find_mark_next = gtk_text_buffer_create_mark (buffer, NULL, &iter_match_end, TRUE); } else { gtk_text_buffer_move_mark (buffer, priv->find_mark_next, &iter_match_end); } gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view), priv->find_mark_previous, 0.0, TRUE, 0.5, 0.5); gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &iter_match_start); gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter_match_end); return TRUE; }
static gboolean chat_text_view_find_next (EmpathyChatView *view, const gchar *search_criteria, gboolean new_search) { EmpathyChatTextViewPriv *priv; GtkTextBuffer *buffer; GtkTextIter iter_at_mark; GtkTextIter iter_match_start; GtkTextIter iter_match_end; gboolean found; gboolean from_start = FALSE; g_return_val_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view), FALSE); g_return_val_if_fail (search_criteria != NULL, FALSE); priv = GET_PRIV (view); buffer = priv->buffer; if (EMP_STR_EMPTY (search_criteria)) { if (priv->find_mark_next) { gtk_text_buffer_get_start_iter (buffer, &iter_at_mark); gtk_text_buffer_move_mark (buffer, priv->find_mark_next, &iter_at_mark); gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view), priv->find_mark_next, 0.0, TRUE, 0.0, 0.0); gtk_text_buffer_select_range (buffer, &iter_at_mark, &iter_at_mark); } return FALSE; } if (new_search) { from_start = TRUE; } if (priv->find_mark_next) { gtk_text_buffer_get_iter_at_mark (buffer, &iter_at_mark, priv->find_mark_next); } else { gtk_text_buffer_get_start_iter (buffer, &iter_at_mark); from_start = TRUE; } priv->find_last_direction = TRUE; found = empathy_text_iter_forward_search (&iter_at_mark, search_criteria, &iter_match_start, &iter_match_end, NULL); if (!found) { gboolean result = FALSE; if (from_start) { return result; } /* Here we wrap around. */ if (!new_search && !priv->find_wrapped) { priv->find_wrapped = TRUE; result = chat_text_view_find_next (view, search_criteria, FALSE); priv->find_wrapped = FALSE; } return result; } /* Set new mark and show on screen */ if (!priv->find_mark_next) { priv->find_mark_next = gtk_text_buffer_create_mark (buffer, NULL, &iter_match_end, TRUE); } else { gtk_text_buffer_move_mark (buffer, priv->find_mark_next, &iter_match_end); } if (!priv->find_mark_previous) { priv->find_mark_previous = gtk_text_buffer_create_mark (buffer, NULL, &iter_match_start, TRUE); } else { gtk_text_buffer_move_mark (buffer, priv->find_mark_previous, &iter_match_start); } gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view), priv->find_mark_next, 0.0, TRUE, 0.5, 0.5); gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &iter_match_start); gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter_match_end); return TRUE; }
static void contact_list_store_add_contact (EmpathyContactListStore *store, EmpathyContact *contact) { EmpathyContactListStorePriv *priv; GtkTreeIter iter; GList *groups = NULL, *l; priv = GET_PRIV (store); if (EMP_STR_EMPTY (empathy_contact_get_name (contact)) || (!priv->show_offline && !empathy_contact_is_online (contact))) { return; } if (priv->show_groups) { groups = empathy_contact_list_get_groups (priv->list, contact); } /* If no groups just add it at the top level. */ if (!groups) { gtk_tree_store_append (GTK_TREE_STORE (store), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (store), &iter, EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_AUDIO, EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_VIDEO, -1); } /* Else add to each group. */ for (l = groups; l; l = l->next) { GtkTreeIter iter_group; contact_list_store_get_group (store, l->data, &iter_group, NULL, NULL); gtk_tree_store_insert_after (GTK_TREE_STORE (store), &iter, &iter_group, NULL); gtk_tree_store_set (GTK_TREE_STORE (store), &iter, EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_AUDIO, EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_VIDEO, -1); g_free (l->data); } g_list_free (groups); contact_list_store_contact_update (store, contact); }
static void log_window_find_populate (EmpathyLogWindow *window, const gchar *search_criteria) { GList *hits, *l; GtkTreeView *view; GtkTreeModel *model; GtkTreeSelection *selection; GtkListStore *store; GtkTreeIter iter; view = GTK_TREE_VIEW (window->treeview_find); model = gtk_tree_view_get_model (view); selection = gtk_tree_view_get_selection (view); store = GTK_LIST_STORE (model); empathy_chat_view_clear (window->chatview_find); gtk_list_store_clear (store); if (EMP_STR_EMPTY (search_criteria)) { /* Just clear the search. */ return; } hits = empathy_log_manager_search_new (window->log_manager, search_criteria); for (l = hits; l; l = l->next) { EmpathyLogSearchHit *hit; const gchar *account_name; const gchar *account_icon; gchar *date_readable; hit = l->data; /* Protect against invalid data (corrupt or old log files. */ if (!hit->account || !hit->chat_id) { continue; } date_readable = empathy_log_manager_get_date_readable (hit->date); account_name = empathy_account_get_display_name (hit->account); account_icon = empathy_icon_name_from_account (hit->account); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_FIND_ACCOUNT_ICON, account_icon, COL_FIND_ACCOUNT_NAME, account_name, COL_FIND_ACCOUNT, hit->account, COL_FIND_CHAT_NAME, hit->chat_id, /* FIXME */ COL_FIND_CHAT_ID, hit->chat_id, COL_FIND_IS_CHATROOM, hit->is_chatroom, COL_FIND_DATE, hit->date, COL_FIND_DATE_READABLE, date_readable, -1); g_free (date_readable); /* FIXME: Update COL_FIND_CHAT_NAME */ if (hit->is_chatroom) { } else { } } if (hits) { empathy_log_manager_search_free (hits); } }
static void empathy_account_update (EmpathyAccount *account, GHashTable *properties) { EmpathyAccountPriv *priv = GET_PRIV (account); GValueArray *arr; TpConnectionStatus old_s = priv->connection_status; gboolean presence_changed = FALSE; if (g_hash_table_lookup (properties, "ConnectionStatus") != NULL) priv->connection_status = tp_asv_get_int32 (properties, "ConnectionStatus", NULL); if (g_hash_table_lookup (properties, "ConnectionStatusReason") != NULL) priv->reason = tp_asv_get_int32 (properties, "ConnectionStatusReason", NULL); if (g_hash_table_lookup (properties, "CurrentPresence") != NULL) { presence_changed = TRUE; arr = tp_asv_get_boxed (properties, "CurrentPresence", TP_STRUCT_TYPE_SIMPLE_PRESENCE); priv->presence = g_value_get_uint (g_value_array_get_nth (arr, 0)); g_free (priv->status); priv->status = g_value_dup_string (g_value_array_get_nth (arr, 1)); g_free (priv->message); priv->message = g_value_dup_string (g_value_array_get_nth (arr, 2)); } if (g_hash_table_lookup (properties, "DisplayName") != NULL) { g_free (priv->display_name); priv->display_name = g_strdup (tp_asv_get_string (properties, "DisplayName")); g_object_notify (G_OBJECT (account), "display-name"); } if (g_hash_table_lookup (properties, "Icon") != NULL) { const gchar *icon_name; icon_name = tp_asv_get_string (properties, "Icon"); g_free (priv->icon_name); if (EMP_STR_EMPTY (icon_name)) priv->icon_name = empathy_protocol_icon_name (priv->proto_name); else priv->icon_name = g_strdup (icon_name); } if (g_hash_table_lookup (properties, "Enabled") != NULL) { gboolean enabled = tp_asv_get_boolean (properties, "Enabled", NULL); if (priv->enabled != enabled) { priv->enabled = enabled; g_object_notify (G_OBJECT (account), "enabled"); } } if (g_hash_table_lookup (properties, "Valid") != NULL) priv->valid = tp_asv_get_boolean (properties, "Valid", NULL); if (g_hash_table_lookup (properties, "Parameters") != NULL) { GHashTable *parameters; parameters = tp_asv_get_boxed (properties, "Parameters", TP_HASH_TYPE_STRING_VARIANT_MAP); if (priv->parameters != NULL) g_hash_table_unref (priv->parameters); priv->parameters = g_boxed_copy (TP_HASH_TYPE_STRING_VARIANT_MAP, parameters); } if (!priv->ready) { priv->ready = TRUE; g_object_notify (G_OBJECT (account), "ready"); } if (priv->connection_status != old_s) { if (priv->connection_status == TP_CONNECTION_STATUS_CONNECTED) { GTimeVal val; g_get_current_time (&val); priv->connect_time = val.tv_sec; } g_signal_emit (account, signals[STATUS_CHANGED], 0, old_s, priv->connection_status, priv->reason); g_object_notify (G_OBJECT (account), "connection-status"); g_object_notify (G_OBJECT (account), "connection-status-reason"); } if (presence_changed) { g_signal_emit (account, signals[PRESENCE_CHANGED], 0, priv->presence, priv->status, priv->message); g_object_notify (G_OBJECT (account), "presence"); g_object_notify (G_OBJECT (account), "status"); g_object_notify (G_OBJECT (account), "status-message"); } if (g_hash_table_lookup (properties, "Connection") != NULL) { const gchar *conn_path = tp_asv_get_object_path (properties, "Connection"); _empathy_account_set_connection (account, conn_path); } }