static void _pidgin_themes_smiley_themeize(GtkWidget *imhtml, gboolean custom)
{
struct smiley_list *list;
if (!current_smiley_theme)
return;
gtk_imhtml_remove_smileys(GTK_IMHTML(imhtml));
list = current_smiley_theme->list;
while (list) {
char *sml = !strcmp(list->sml, "default") ? NULL : list->sml;
GSList *icons = list->smileys;
while (icons) {
gtk_imhtml_associate_smiley(GTK_IMHTML(imhtml), sml, icons->data);
icons = icons->next;
}
if (custom == TRUE) {
icons = pidgin_smileys_get_all();
while (icons) {
gtk_imhtml_associate_smiley(GTK_IMHTML(imhtml), sml, icons->data);
icons = icons->next;
}
}
list = list->next;
}
}
static void message_send_cb(GtkWidget *widget, gpointer p)
{
GtkTextIter start, end;
PurplePluginProtocolInfo *prpl_info = NULL;
PurpleConnection *gc;
GtkTextBuffer *buffer;
char *text;
gc = console->gc;
if (gc)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(console->entry));
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
text = gtk_imhtml_get_text(GTK_IMHTML(console->entry), &start, &end);
if (prpl_info && prpl_info->send_raw != NULL)
prpl_info->send_raw(gc, text, strlen(text));
g_free(text);
gtk_imhtml_clear(GTK_IMHTML(console->entry));
}
static void log_select_cb(GtkTreeSelection *sel, PidginLogViewer *viewer) {
GtkTreeIter iter;
GValue val;
GtkTreeModel *model = GTK_TREE_MODEL(viewer->treestore);
PurpleLog *log = NULL;
PurpleLogReadFlags flags;
char *read = NULL;
if (!gtk_tree_selection_get_selected(sel, &model, &iter))
return;
val.g_type = 0;
gtk_tree_model_get_value (model, &iter, 1, &val);
log = g_value_get_pointer(&val);
g_value_unset(&val);
if (log == NULL)
return;
pidgin_set_cursor(viewer->window, GDK_WATCH);
if (log->type != PURPLE_LOG_SYSTEM) {
char *title;
if (log->type == PURPLE_LOG_CHAT)
title = g_strdup_printf(_("<span size='larger' weight='bold'>Conversation in %s on %s</span>"),
log->name, log_get_date(log));
else
title = g_strdup_printf(_("<span size='larger' weight='bold'>Conversation with %s on %s</span>"),
log->name, log_get_date(log));
gtk_label_set_markup(GTK_LABEL(viewer->label), title);
g_free(title);
}
read = purple_log_read(log, &flags);
viewer->flags = flags;
gtk_imhtml_clear(GTK_IMHTML(viewer->imhtml));
gtk_imhtml_set_protocol_name(GTK_IMHTML(viewer->imhtml),
purple_account_get_protocol_name(log->account));
purple_signal_emit(pidgin_log_get_handle(), "log-displaying", viewer, log);
gtk_imhtml_append_text(GTK_IMHTML(viewer->imhtml), read,
GTK_IMHTML_NO_COMMENTS | GTK_IMHTML_NO_TITLE | GTK_IMHTML_NO_SCROLL |
((flags & PURPLE_LOG_READ_NO_NEWLINE) ? GTK_IMHTML_NO_NEWLINE : 0));
g_free(read);
if (viewer->search != NULL) {
gtk_imhtml_search_clear(GTK_IMHTML(viewer->imhtml));
g_idle_add(search_find_cb, viewer);
}
pidgin_clear_cursor(viewer->window);
}
static void entry_changed_cb(GtkTextBuffer *buffer, void *data)
{
char *xmlstr, *str;
GtkTextIter iter;
int wrapped_lines;
int lines;
GdkRectangle oneline;
int height;
int pad_top, pad_inside, pad_bottom;
GtkTextIter start, end;
xmlnode *node;
wrapped_lines = 1;
gtk_text_buffer_get_start_iter(buffer, &iter);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(console->entry), &iter, &oneline);
while (gtk_text_view_forward_display_line(GTK_TEXT_VIEW(console->entry), &iter))
wrapped_lines++;
lines = gtk_text_buffer_get_line_count(buffer);
/* Show a maximum of 64 lines */
lines = MIN(lines, 6);
wrapped_lines = MIN(wrapped_lines, 6);
pad_top = gtk_text_view_get_pixels_above_lines(GTK_TEXT_VIEW(console->entry));
pad_bottom = gtk_text_view_get_pixels_below_lines(GTK_TEXT_VIEW(console->entry));
pad_inside = gtk_text_view_get_pixels_inside_wrap(GTK_TEXT_VIEW(console->entry));
height = (oneline.height + pad_top + pad_bottom) * lines;
height += (oneline.height + pad_inside) * (wrapped_lines - lines);
gtk_widget_set_size_request(console->sw, -1, height + 6);
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
if (!str)
return;
xmlstr = g_strdup_printf("<xml>%s</xml>", str);
node = xmlnode_from_str(xmlstr, -1);
if (node) {
gtk_imhtml_clear_formatting(GTK_IMHTML(console->entry));
} else {
gtk_imhtml_toggle_background(GTK_IMHTML(console->entry), "#ffcece");
}
g_free(str);
g_free(xmlstr);
if (node)
xmlnode_free(node);
}
void ap_widget_prefs_updated (struct widget *w) {
gchar *output;
if (dialog_box_preview == NULL) return;
if (w != dialog_box_widget) return;
// TODO: Investigate how laggy this is, possibly add a timeout
output = w->component->generate (w);
g_static_mutex_lock (&preview_mutex);
gtk_imhtml_clear (GTK_IMHTML(dialog_box_preview));
gtk_imhtml_append_text (GTK_IMHTML(dialog_box_preview), output,
GTK_IMHTML_NO_SCROLL);
g_static_mutex_unlock (&preview_mutex);
free (output);
}
static void search_cb(GtkWidget *button, PidginLogViewer *lv)
{
const char *search_term = gtk_entry_get_text(GTK_ENTRY(lv->entry));
GList *logs;
if (!(*search_term)) {
/* reset the tree */
gtk_tree_store_clear(lv->treestore);
populate_log_tree(lv);
g_free(lv->search);
lv->search = NULL;
gtk_imhtml_search_clear(GTK_IMHTML(lv->imhtml));
select_first_log(lv);
return;
}
if (lv->search != NULL && !strcmp(lv->search, search_term))
{
/* Searching for the same term acts as "Find Next" */
gtk_imhtml_search_find(GTK_IMHTML(lv->imhtml), lv->search);
return;
}
pidgin_set_cursor(lv->window, GDK_WATCH);
g_free(lv->search);
lv->search = g_strdup(search_term);
gtk_tree_store_clear(lv->treestore);
gtk_imhtml_clear(GTK_IMHTML(lv->imhtml));
for (logs = lv->logs; logs != NULL; logs = logs->next) {
char *read = purple_log_read((PurpleLog*)logs->data, NULL);
if (read && *read && purple_strcasestr(read, search_term)) {
GtkTreeIter iter;
PurpleLog *log = logs->data;
gtk_tree_store_append (lv->treestore, &iter, NULL);
gtk_tree_store_set(lv->treestore, &iter,
0, log_get_date(log),
1, log, -1);
}
g_free(read);
}
select_first_log(lv);
pidgin_clear_cursor(lv->window);
}
static void
signed_off_cb(PurpleConnection *gc)
{
int i = 0;
GList *l;
if (!console)
return;
l = console->accounts;
while (l) {
PurpleConnection *g = l->data;
if (gc == g)
break;
i++;
l = l->next;
}
if (l == NULL)
return;
gtk_combo_box_remove_text(GTK_COMBO_BOX(console->dropdown), i);
console->accounts = g_list_remove(console->accounts, gc);
console->count--;
if (gc == console->gc) {
console->gc = NULL;
gtk_imhtml_append_text(GTK_IMHTML(console->imhtml),
_("<font color='#c8c8c8'>Logged out.</font>"), 0);
}
}
/**
* \fn add_message_iter
* \brief Stores the current position in the chat window
*/
void add_message_iter(PurpleConnection *gc, const char* to, const gchar* messageid, int newlines)
{
#ifdef DEBUG
printf("to: %s \n", to);
#endif
PurpleAccount *acct = purple_connection_get_account (gc);
if(!acct) return;
PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY, to, acct);
if(!conv) return;
PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
GtkIMHtml *imhtml = GTK_IMHTML(gtkconv->imhtml);
message_info *info = g_new(message_info, 1);
info->textbuffer = imhtml->text_buffer;
GtkTextIter location;
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &location);
info->offset = gtk_text_iter_get_offset (&location);
info->lines = newlines;
//Insert the location to the table, use messageid as key
g_hash_table_insert(ht_locations, strdup(messageid), info);
#ifdef DEBUG
printf("attached key: %s, table size now %d \n", messageid, g_hash_table_size(ht_locations));
#endif
}
static gboolean
displaying_im_cb(PurpleAccount *account, const char *who, char **message,
PurpleConversation *conv, PurpleMessageFlags flags,
void *unused)
{
GtkIMHtml *imhtml;
GtkTextBuffer *text_buffer;
gint service = get_service_type(conv);
gint linenumber = 0;
twitter_debug("called\n");
if(service == unknown_service) {
twitter_debug("neither twitter nor wassr conv\n");
return FALSE;
}
/* get text buffer */
imhtml = GTK_IMHTML(PIDGIN_CONVERSATION(conv)->imhtml);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
/* store number of lines */
linenumber = gtk_text_buffer_get_line_count(text_buffer);
g_hash_table_insert(conv_hash, conv, GINT_TO_POINTER(linenumber));
twitter_debug("conv = %p linenumber = %d\n", conv, linenumber);
return FALSE;
}
static gboolean twitter_conv_icon_displaying_chat_cb(PurpleAccount * account, const char *who, char **message, PurpleConversation * conv, PurpleMessageFlags flags, void *account_signal)
{
GtkIMHtml *imhtml;
GtkTextBuffer *text_buffer;
gint linenumber = 0;
if (account != account_signal)
return FALSE;
purple_debug_info(PLUGIN_ID, "called %s\n", G_STRFUNC);
/* get text buffer */
imhtml = GTK_IMHTML(PIDGIN_CONVERSATION(conv)->imhtml);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
/* store number of lines */
linenumber = gtk_text_buffer_get_line_count(text_buffer);
//this is just used to pass the current line number (before the insertion of the new text)
//to the _displayed_chat_cb func.
//Since pidgin is (mostly) single threaded, this is probably overkill and we could just use
//a single global int.
//On another note, we don't insert the icon here because the message may not end up being displayed
//based on what other plugins do
purple_conversation_set_data(conv, PLUGIN_ID "-icon-ln", GINT_TO_POINTER(linenumber));
return FALSE;
}
static gboolean _scroll_imhtml_to_end(gpointer data)
{
GtkIMHtml *imhtml = data;
gtk_imhtml_scroll_to_end(GTK_IMHTML(imhtml), FALSE);
g_object_unref(G_OBJECT(imhtml));
return FALSE;
}
static void formatting_toggle_cb (GtkIMHtml *imhtml,
GtkIMHtmlButtons buttons, struct widget *w)
{
ap_prefs_set_string (w, "timestamp_format",
gtk_imhtml_get_markup (GTK_IMHTML(entry)));
}
static void
timestamp_display(PurpleConversation *conv, time_t then, time_t now)
{
PidginConversation *gtk_conv = PIDGIN_CONVERSATION(conv);
GtkWidget *imhtml = gtk_conv->imhtml;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
GtkTextIter iter;
const char *mdate;
int y, height;
GdkRectangle rect;
/* display timestamp */
mdate = purple_utf8_strftime(then == 0 ? "%H:%M" : "\n%H:%M",
localtime(&now));
gtk_text_buffer_get_end_iter(buffer, &iter);
if (gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "TIMESTAMP") == NULL)
gtk_text_buffer_create_tag(buffer, "TIMESTAMP",
"foreground", "#888888", "justification", GTK_JUSTIFY_CENTER,
"weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, mdate,
strlen(mdate), "TIMESTAMP", NULL);
/* scroll view if necessary */
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect);
gtk_text_view_get_line_yrange(
GTK_TEXT_VIEW(imhtml), &iter, &y, &height);
if (((y + height) - (rect.y + rect.height)) > height &&
gtk_text_buffer_get_char_count(buffer)) {
gboolean smooth = purple_prefs_get_bool(
PIDGIN_PREFS_ROOT "/conversations/use_smooth_scrolling");
gtk_imhtml_scroll_to_end(GTK_IMHTML(imhtml), smooth);
}
}
static void
attach_to_conv(PurpleConversation *conv, gpointer null)
{
PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
GtkWidget *box, *sep, *counter, *menus;
GtkIMHtml *imhtml;
box = gtkconv->toolbar;
imhtml = GTK_IMHTML(gtkconv->imhtml);
/* Disable widgets that decorate or add link to composing text
* because Twitter cannot receive marked up string. For lean-view
* and wide-view, see pidgin/gtkimhtmltoolbar.c.
*/
menus = g_object_get_data(G_OBJECT(box), "lean-view");
if(menus) {
gtk_widget_set_sensitive(GTK_WIDGET(menus), FALSE);
}
menus = g_object_get_data(G_OBJECT(box), "wide-view");
if(menus) {
gtk_widget_set_sensitive(GTK_WIDGET(menus), FALSE);
}
purple_conversation_set_features(
gtkconv->active_conv,
purple_conversation_get_features(gtkconv->active_conv) &
~PURPLE_CONNECTION_HTML);
/* check if the counter is enabled */
if(!purple_prefs_get_bool(OPT_COUNTER))
return;
/* get counter object */
counter = g_object_get_data(G_OBJECT(box), PLUGIN_ID "-counter");
g_return_if_fail(counter == NULL);
/* make counter object */
counter = gtk_label_new(NULL);
gtk_widget_set_name(counter, "counter_label");
gtk_label_set_text(GTK_LABEL(counter), "0");
gtk_box_pack_end(GTK_BOX(box), counter, FALSE, FALSE, 0);
gtk_widget_show_all(counter);
g_object_set_data(G_OBJECT(box), PLUGIN_ID "-counter", counter);
/* make separator object */
sep = gtk_vseparator_new();
gtk_box_pack_end(GTK_BOX(box), sep, FALSE, FALSE, 0);
gtk_widget_show_all(sep);
g_object_set_data(G_OBJECT(box), PLUGIN_ID "-sep", sep);
/* connect to signals */
g_signal_connect(G_OBJECT(gtkconv->entry_buffer), "insert_text",
G_CALLBACK(insert_text_cb), conv);
g_signal_connect(G_OBJECT(gtkconv->entry_buffer), "delete_range",
G_CALLBACK(delete_text_cb), conv);
/* redraw window */
gtk_widget_queue_draw(pidgin_conv_get_window(gtkconv)->window);
}
void smiley_themeize(GtkWidget *imhtml)
{
struct smiley_list *list;
if (!current_smiley_theme)
return;
gtk_imhtml_remove_smileys(GTK_IMHTML(imhtml));
list = current_smiley_theme->list;
while (list) {
char *sml = !strcmp(list->sml, "default") ? NULL : list->sml;
GSList *icons = list->smileys;
while (icons) {
gtk_imhtml_associate_smiley(GTK_IMHTML(imhtml), sml, icons->data);
icons = icons->next;
}
list = list->next;
}
}
static void
do_find_cb(GtkWidget *widget, gint response, struct _find *f)
{
switch (response) {
case GTK_RESPONSE_OK:
gtk_imhtml_search_find(GTK_IMHTML(f->window->text),
gtk_entry_get_text(GTK_ENTRY(f->entry)));
break;
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CLOSE:
gtk_imhtml_search_clear(GTK_IMHTML(f->window->text));
gtk_widget_destroy(f->window->find);
f->window->find = NULL;
g_free(f);
break;
}
}
/* Info message */
static GtkWidget *get_info_message () {
GtkWidget *page;
GtkWidget *aboutwin;
GtkWidget *text;
/* Make the box */
page = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (page), 12);
/* Window with info */
aboutwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(aboutwin),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(aboutwin),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX(page), aboutwin, TRUE, TRUE, 0);
text = gtk_imhtml_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER(aboutwin), text);
pidgin_setup_imhtml (text);
/* Info text */
gtk_imhtml_append_text (GTK_IMHTML(text),
_("<b><u>Basic info</u></b><br>"), GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("A <b>widget</b> is a little piece/snippet of automatically "
"generated text. There are all sorts of widgets; each type has "
"different content (i.e. a random quote, text from a blog, the "
"song currently playing, etc).<br><br>"), GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("To use a widget, simply drag it from the list on the left and "
"drop it into a profile or status message. <i>It's that easy!</i>"
"<br><br>"), GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("<b>To edit your profile:</b> "
"Use the \"Info/profile\" tab in this window.<br>"),
GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("<b>To edit your available/away/status message:</b> "
"Use the regular Purple interface built into the bottom of the buddy "
"list.<br><br>"), GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("<b><u>Advanced Tips</u></b><br>"), GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("You can insert a widget into a profile or status by typing its name. "
"To do this, just type \"[widget-name]\" wherever you want to "
"place a widget (names of widgets are listed on the left). <br><br>"
"<b>You type:</b> The song I am playing now is [iTunesInfo].<br>"
"<b>AutoProfile result:</b> The song I am playing now is "
"The Beatles - Yellow Submarine.<br><br>"), GTK_IMHTML_NO_SCROLL);
return page;
}
static void insert_icon_at_mark(GtkTextMark * requested_mark, gpointer user_data)
{
GList *win_list;
GtkIMHtml *target_imhtml = NULL;
GtkTextBuffer *target_buffer = NULL;
GtkTextIter insertion_point;
TwitterConvIcon *conv_icon = user_data;
/* find the conversation that contains the mark */
for (win_list = pidgin_conv_windows_get_list(); win_list; win_list = win_list->next) {
PidginWindow *win = win_list->data;
GList *conv_list;
for (conv_list = pidgin_conv_window_get_gtkconvs(win); conv_list; conv_list = conv_list->next) {
PidginConversation *conv = conv_list->data;
GtkIMHtml *current_imhtml = GTK_IMHTML(conv->imhtml);
GtkTextBuffer *current_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(current_imhtml));
if (current_buffer == gtk_text_mark_get_buffer(requested_mark)) {
target_imhtml = current_imhtml;
target_buffer = current_buffer;
break;
}
}
}
if (!(target_imhtml && target_buffer)) {
purple_debug_warning(PLUGIN_ID, "No target imhtml/target buffer\n");
return;
}
/* insert icon to the mark */
gtk_text_buffer_get_iter_at_mark(target_buffer, &insertion_point, requested_mark);
/* in this function, we put an icon for pending marks. we should
* not invalidate the icon here, otherwise it may result in
* thrashing. --yaz */
if (!conv_icon || !conv_icon->pixbuf) {
purple_debug_warning(PLUGIN_ID, "No pixbuf\n");
return;
}
/* We only want to add the icon if the mark is still on screen. If the user cleared the screen with a ctrl-L, this won't be true. TODO -- can we get a callback at the clear and just delete the mark there? */
if (TRUE == gtk_text_iter_is_end(&insertion_point)) {
purple_debug_warning(PLUGIN_ID, "Not adding the icon, since the insertion point is no longer in the buffer\n");
} else {
/* insert icon actually */
gtk_text_buffer_insert_pixbuf(target_buffer, &insertion_point, conv_icon->pixbuf);
}
gtk_text_buffer_delete_mark(target_buffer, requested_mark);
requested_mark = NULL;
purple_debug_info(PLUGIN_ID, "inserted icon into conv\n");
}
/*--------------------------------------------------------------------------*
* Displayed message stuff *
*--------------------------------------------------------------------------*/
static void display_diff_msg (GtkTreeSelection *select, gpointer data)
{
GtkTreeModel *model;
GtkTreeIter iter;
const gchar *string;
GtkWidget *imhtml = (GtkWidget *) data;
if (gtk_tree_selection_get_selected (select, &model, &iter))
{
gtk_tree_model_get (model, &iter, 3, &string, -1);
gtk_imhtml_clear (GTK_IMHTML(imhtml));
if (string != NULL) {
gtk_imhtml_append_text (GTK_IMHTML(imhtml), string,
GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(imhtml), "<BR>",
GTK_IMHTML_NO_SCROLL);
}
}
}
static void twitter_conv_icon_displayed_chat_cb(PurpleAccount * account, const char *who, char *message, PurpleConversation * conv, PurpleMessageFlags flags, void *account_signal)
{
GtkIMHtml *imhtml;
GtkTextBuffer *text_buffer;
GtkTextIter insertion_point;
gint linenumber;
TwitterConvIcon *conv_icon;
PurpleConnection *gc;
TwitterConnectionData *twitter;
if (account != account_signal)
return;
gc = purple_account_get_connection(account);
if (!gc) {
return;
}
twitter = gc->proto_data;
purple_debug_info(PLUGIN_ID, "%s\n", G_STRFUNC);
/* insert icon */
imhtml = GTK_IMHTML(PIDGIN_CONVERSATION(conv)->imhtml);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
/* get GtkTextIter in the target line */
linenumber = GPOINTER_TO_INT(purple_conversation_get_data(conv, PLUGIN_ID "-icon-ln"));
gtk_text_buffer_get_iter_at_line(text_buffer, &insertion_point, linenumber);
conv_icon = twitter_conv_icon_find(account, who);
/* if we don't have the icon for this user, put a mark instead and
* request the icon */
if (!conv_icon) {
conv_icon = twitter_conv_icon_new(account, who);
twitter_conv_icon_add_conv(conv_icon, conv);
g_hash_table_insert(twitter->icons, g_strdup(purple_normalize(account, who)), conv_icon);
mark_icon_for_user(gtk_text_buffer_create_mark(text_buffer, NULL, &insertion_point, FALSE), conv_icon);
return;
}
twitter_conv_icon_add_conv(conv_icon, conv);
/* if we have the icon for this user, insert the icon immediately */
if (TRUE) {
if (conv_icon->pixbuf) {
gtk_text_buffer_insert_pixbuf(text_buffer, &insertion_point, conv_icon->pixbuf);
} else {
mark_icon_for_user(gtk_text_buffer_create_mark(text_buffer, NULL, &insertion_point, FALSE), conv_icon);
}
}
purple_debug_info(PLUGIN_ID, "end %s\n", G_STRFUNC);
}
/**
* \fn deleting_conversation_cb
* \brief Deletes all references to this conversation from the hashtable
*/
static void
deleting_conversation_cb(PurpleConversation *conv)
{
g_hash_table_foreach_remove(ht_locations,
deleting_conversation_remove_items,
GTK_IMHTML(PIDGIN_CONVERSATION(conv)->imhtml)->text_buffer);
#ifdef DEBUG
printf("conversation closed, table size now %d \n", g_hash_table_size(ht_locations));
#endif
}
static void
xmlnode_received_cb(PurpleConnection *gc, xmlnode **packet, gpointer null)
{
char *str, *formatted;
if (!console || console->gc != gc)
return;
str = xmlnode_to_pretty_str(*packet, NULL, 0);
formatted = g_strdup_printf("<body bgcolor='#ffcece'><pre>%s</pre></body>", str);
gtk_imhtml_append_text(GTK_IMHTML(console->imhtml), formatted, 0);
g_free(formatted);
g_free(str);
}
static void
jump_to_markerline(PurpleConversation *conv, gpointer null)
{
PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
int offset;
GtkTextIter iter;
if (!gtkconv)
return;
offset = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(gtkconv->imhtml), "markerline"));
gtk_text_buffer_get_iter_at_offset(GTK_IMHTML(gtkconv->imhtml)->text_buffer, &iter, offset);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(gtkconv->imhtml), &iter, 0, TRUE, 0, 0);
}
void SendMsgDlgTab::onRecvMessage(time_t when, const char *text)
{
char mdate[64];
strftime(mdate, sizeof(mdate), "%H:%M:%S", localtime(&when));
std::string str;
str = "<FONT SIZE=\"2\">(";
str += mdate;
str += ") </FONT><B>";
str += name;
str += ": ";
str += text;
str += "</B><BR>";
gtk_imhtml_append_text(GTK_IMHTML(imhtml), str.c_str(), str.length(), (GtkIMHtmlOptions)0);
}
static void
dropdown_changed_cb(GtkComboBox *widget, gpointer nul)
{
PurpleAccount *account;
if (!console)
return;
account = purple_accounts_find(gtk_combo_box_get_active_text(GTK_COMBO_BOX(console->dropdown)),
"prpl-jabber");
if (!account || !account->gc)
return;
console->gc = account->gc;
gtk_imhtml_clear(GTK_IMHTML(console->imhtml));
}
Gtk::VPaned *SendMsgDlgTab::setup_im_pane()
{
Gtk::VPaned *paned;
paned = Gtk::manage(new Gtk::VPaned);
Gtk::VBox *vbox;
vbox = Gtk::manage(new Gtk::VBox(false, 5));
paned->pack1(*vbox, true, true);
Gtk::ScrolledWindow *sw;
sw = Gtk::manage(new Gtk::ScrolledWindow());
sw->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_ALWAYS);
sw->set_shadow_type(Gtk::SHADOW_IN);
vbox->pack_start(*sw, true, true, 0);
sw->set_size_request(230, 150);
imhtml = gtk_imhtml_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(sw->gobj()), imhtml);
gtk_imhtml_show_comments(GTK_IMHTML(imhtml), true);
Gtk::VBox *vbox2;
vbox2 = Gtk::manage(new Gtk::VBox(false, 5));
paned->pack2(*vbox2, false, false);
Gtk::VBox *tool_vbox;
tool_vbox = build_conv_toolbutton_vbox();
vbox2->pack_start(*tool_vbox, false, false, 0);
Gtk::Frame *frame;
frame = Gtk::manage(new Gtk::Frame());
frame->set_shadow_type(Gtk::SHADOW_IN);
vbox2->pack_start(*frame, true, true, 0);
m_input_textview.set_wrap_mode(Gtk::WRAP_WORD);
m_input_textview.set_size_request(-1, 45);
frame->add(m_input_textview);
//m_input_textview.grab_focus();
m_input_textview.signal_event().connect(SigC::slot(*this, &SendMsgDlgTab::on_input_textview_event));
Gtk::HBox *hbox;
hbox = Gtk::manage(new Gtk::HBox(false, 5));
vbox2->pack_start(*hbox, false, false, 0);
setup_im_buttons(hbox);
return paned;
}
static void
save_writefile_cb(void *user_data, const char *filename)
{
DebugWindow *win = (DebugWindow *)user_data;
FILE *fp;
char *tmp;
if ((fp = g_fopen(filename, "w+")) == NULL) {
gaim_notify_error(win, NULL, _("Unable to open file."), NULL);
return;
}
tmp = gtk_imhtml_get_text(GTK_IMHTML(win->text), NULL, NULL);
fprintf(fp, "Gaim Debug log : %s\n", gaim_date_full());
fprintf(fp, "%s", tmp);
g_free(tmp);
fclose(fp);
}
static void
xmlnode_sent_cb(PurpleConnection *gc, char **packet, gpointer null)
{
char *str;
char *formatted;
xmlnode *node;
if (!console || console->gc != gc)
return;
node = xmlnode_from_str(*packet, -1);
if (!node)
return;
str = xmlnode_to_pretty_str(node, NULL, 0);
formatted = g_strdup_printf("<body bgcolor='#dcecc4'><pre>%s</pre></body>", str);
gtk_imhtml_append_text(GTK_IMHTML(console->imhtml), formatted, 0);
g_free(formatted);
g_free(str);
xmlnode_free(node);
}
void SendMsgDlgTab::on_send_button_clicked()
{
m_bold_button.set_active(false);
m_italic_button.set_active(false);
m_underline_button.set_active(false);
m_bigfont_button.set_active(false);
m_normalfont_button.set_active(false);
m_smallfont_button.set_active(false);
m_selectfont_button.set_active(false);
m_fgcolor_button.set_active(false);
m_bgcolor_button.set_active(false);
m_smilies_button.set_active(false);
Glib::RefPtr<Gtk::TextBuffer> buffer;
buffer = m_input_textview.get_buffer();
if (buffer->size() != 0) {
Glib::ustring text = buffer->get_text(false);
linqMain->getUDPSession()->sendMessage(MSG_TEXT, name.c_str(), text.c_str());
m_input_textview.get_buffer()->erase(buffer->begin(), buffer->end());
time_t when;
when = time(NULL);
char mdate[64];
strftime(mdate, sizeof(mdate), "%H:%M:%S", localtime(&when));
std::string str;
str = "<FONT SIZE=\"2\">(";
str += mdate;
str += ") </FONT><B>";
str += linqMain->myInfo.name;
str += ": ";
str += text;
str += "</B><BR>";
gtk_imhtml_append_text(GTK_IMHTML(imhtml), str.c_str(), str.length(), (GtkIMHtmlOptions)0);
}
m_input_textview.grab_focus();
}
static GtkWidget *timestamp_menu (struct widget *w)
{
GtkWidget *ret = gtk_vbox_new (FALSE, 5);
GtkWidget *label, *sw;
GtkWidget *entry_window, *toolbar;
GtkTextBuffer *text_buffer;
entry_window = pidgin_create_imhtml (TRUE, &entry, &toolbar, &sw);
gtk_box_pack_start (GTK_BOX (ret), entry_window, FALSE, FALSE, 0); gtk_imhtml_append_text_with_images (GTK_IMHTML(entry),
ap_prefs_get_string (w, "timestamp_format"),
0, NULL);
text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (entry));
g_signal_connect (G_OBJECT (text_buffer), "changed",
G_CALLBACK (event_cb), w);
g_signal_connect_after(G_OBJECT(entry), "format_function_toggle",
G_CALLBACK(formatting_toggle_cb), w);
g_signal_connect_after(G_OBJECT(entry), "format_function_clear",
G_CALLBACK(formatting_clear_cb), w);
label = gtk_label_new (_(
"Insert the following characters where time is to be displayed:\n\n"
"%H\thour (24-hour clock)\n"
"%I\thour (12-hour clock)\n"
"%p\tAM or PM\n"
"%M\tminute\n"
"%S\tsecond\n"
"%a\tabbreviated weekday name\n"
"%A\tfull weekday name\n"
"%b\tabbreviated month name\n"
"%B\tfull month name\n"
"%m\tmonth (numerical)\n"
"%d\tday of the month\n"
"%j\tday of the year\n"
"%W\tweek number of the year\n"
"%w\tweekday (numerical)\n"
"%y\tyear without century\n"
"%Y\tyear with century\n"
"%z\ttime zone name, if any\n"
"%%\t%" ));
sw = gtk_scrolled_window_new (NULL,NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (ret), sw, TRUE, TRUE , 0);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(sw), label);
return ret;
}
