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);
}
}
/* 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;
}
/*--------------------------------------------------------------------------*
* 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 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
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);
}
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);
}
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
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);
}
static void *
pidgin_notify_userinfo(PurpleConnection *gc, const char *who,
PurpleNotifyUserInfo *user_info)
{
char *info;
void *ui_handle;
char *key = userinfo_hash(purple_connection_get_account(gc), who);
PidginUserInfo *pinfo = NULL;
if (!userinfo) {
userinfo = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
}
info = purple_notify_user_info_get_text_with_newline(user_info, "<br />");
pinfo = g_hash_table_lookup(userinfo, key);
if (pinfo != NULL) {
GtkIMHtml *imhtml = g_object_get_data(G_OBJECT(pinfo->window), "info-widget");
char *linked_text = purple_markup_linkify(info);
gtk_imhtml_clear(imhtml);
gtk_imhtml_append_text(imhtml, linked_text, notify_imhtml_options());
g_free(linked_text);
g_free(key);
ui_handle = pinfo->window;
pinfo->count++;
} else {
char *primary = g_strdup_printf(_("Info for %s"), who);
ui_handle = pidgin_notify_formatted(_("Buddy Information"), primary, NULL, info);
g_signal_handlers_disconnect_by_func(G_OBJECT(ui_handle), G_CALLBACK(formatted_close_cb), NULL);
g_signal_connect(G_OBJECT(ui_handle), "destroy", G_CALLBACK(remove_userinfo), key);
g_free(primary);
pinfo = g_new0(PidginUserInfo, 1);
pinfo->window = ui_handle;
pinfo->count = 1;
g_hash_table_insert(userinfo, key, pinfo);
}
g_free(info);
return ui_handle;
}
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 void *
pidgin_notify_formatted(const char *title, const char *primary,
const char *secondary, const char *text)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *imhtml;
GtkWidget *frame;
char label_text[2048];
char *linked_text, *primary_esc, *secondary_esc;
window = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(window), title);
gtk_container_set_border_width(GTK_CONTAINER(window), PIDGIN_HIG_BORDER);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(formatted_close_cb), NULL);
/* Setup the main vbox */
vbox = GTK_DIALOG(window)->vbox;
/* Setup the descriptive label */
primary_esc = g_markup_escape_text(primary, -1);
secondary_esc = (secondary != NULL) ? g_markup_escape_text(secondary, -1) : NULL;
g_snprintf(label_text, sizeof(label_text),
"<span weight=\"bold\" size=\"larger\">%s</span>%s%s",
primary_esc,
(secondary ? "\n" : ""),
(secondary ? secondary_esc : ""));
g_free(primary_esc);
g_free(secondary_esc);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), label_text);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
/* Add the imhtml */
frame = pidgin_create_imhtml(FALSE, &imhtml, NULL, NULL);
gtk_widget_set_name(imhtml, "pidgin_notify_imhtml");
gtk_imhtml_set_format_functions(GTK_IMHTML(imhtml),
gtk_imhtml_get_format_functions(GTK_IMHTML(imhtml)) | GTK_IMHTML_IMAGE);
gtk_widget_set_size_request(imhtml, 300, 250);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
gtk_widget_show(frame);
/* Add the Close button. */
button = gtk_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_widget_grab_focus(button);
g_signal_connect_swapped(G_OBJECT(button), "clicked",
G_CALLBACK(formatted_close_cb), window);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(formatted_input_cb), NULL);
/* Make sure URLs are clickable */
linked_text = purple_markup_linkify(text);
gtk_imhtml_append_text(GTK_IMHTML(imhtml), linked_text, notify_imhtml_options());
g_free(linked_text);
g_object_set_data(G_OBJECT(window), "info-widget", imhtml);
/* Show the window */
pidgin_auto_parent_window(window);
gtk_widget_show(window);
return window;
}
static void historize(PurpleConversation *c)
{
PurpleAccount *account = purple_conversation_get_account(c);
const char *name = purple_conversation_get_name(c);
PurpleConversationType convtype;
GList *logs = NULL;
const char *alias = name;
guint flags;
char *history;
PidginConversation *gtkconv;
GtkIMHtmlOptions options = GTK_IMHTML_NO_COLOURS;
char *header;
char *protocol;
char *escaped_alias;
const char *header_date;
convtype = purple_conversation_get_type(c);
gtkconv = PIDGIN_CONVERSATION(c);
g_return_if_fail(gtkconv != NULL);
/* An IM which is the first active conversation. */
g_return_if_fail(gtkconv->convs != NULL);
if (convtype == PURPLE_CONV_TYPE_IM && !gtkconv->convs->next)
{
GSList *buddies;
GSList *cur;
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_ims"))
return;
/* Find buddies for this conversation. */
buddies = purple_find_buddies(account, name);
/* If we found at least one buddy, save the first buddy's alias. */
if (buddies != NULL)
alias = purple_buddy_get_contact_alias((PurpleBuddy *)buddies->data);
for (cur = buddies; cur != NULL; cur = cur->next)
{
PurpleBlistNode *node = cur->data;
if ((node != NULL) && ((node->prev != NULL) || (node->next != NULL)))
{
PurpleBlistNode *node2;
alias = purple_buddy_get_contact_alias((PurpleBuddy *)node);
/* We've found a buddy that matches this conversation. It's part of a
* PurpleContact with more than one PurpleBuddy. Loop through the PurpleBuddies
* in the contact and get all the logs. */
for (node2 = node->parent->child ; node2 != NULL ; node2 = node2->next)
{
logs = g_list_concat(
purple_log_get_logs(PURPLE_LOG_IM,
purple_buddy_get_name((PurpleBuddy *)node2),
purple_buddy_get_account((PurpleBuddy *)node2)),
logs);
}
break;
}
}
g_slist_free(buddies);
if (logs == NULL)
logs = purple_log_get_logs(PURPLE_LOG_IM, name, account);
else
logs = g_list_sort(logs, purple_log_compare);
}
else if (convtype == PURPLE_CONV_TYPE_CHAT)
{
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_chats"))
return;
logs = purple_log_get_logs(PURPLE_LOG_CHAT, name, account);
}
if (logs == NULL)
return;
history = purple_log_read((PurpleLog*)logs->data, &flags);
gtkconv = PIDGIN_CONVERSATION(c);
if (flags & PURPLE_LOG_READ_NO_NEWLINE)
options |= GTK_IMHTML_NO_NEWLINE;
protocol = g_strdup(gtk_imhtml_get_protocol_name(GTK_IMHTML(gtkconv->imhtml)));
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml),
purple_account_get_protocol_name(((PurpleLog*)logs->data)->account));
if (gtk_text_buffer_get_char_count(gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->imhtml))))
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), "<BR>", options);
escaped_alias = g_markup_escape_text(alias, -1);
if (((PurpleLog *)logs->data)->tm)
header_date = purple_date_format_full(((PurpleLog *)logs->data)->tm);
else
header_date = purple_date_format_full(localtime(&((PurpleLog *)logs->data)->time));
header = g_strdup_printf(_("<b>Conversation with %s on %s:</b><br>"), escaped_alias, header_date);
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), header, options);
g_free(header);
g_free(escaped_alias);
g_strchomp(history);
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), history, options);
g_free(history);
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), "<hr>", options);
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml), protocol);
g_free(protocol);
g_object_ref(G_OBJECT(gtkconv->imhtml));
g_idle_add(_scroll_imhtml_to_end, gtkconv->imhtml);
g_list_foreach(logs, (GFunc)purple_log_free, NULL);
g_list_free(logs);
}
/* Widget configuration menu */
static GtkWidget *get_widget_configuration (struct widget *w) {
GtkWidget *config, *hbox, *vbox, *sw;
GtkWidget *label, *button;
GtkWidget *menu;
GString *s;
gchar *output;
config = gtk_vbox_new (FALSE, 0);
/* Title/Description */
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER(hbox), 6);
gtk_box_pack_start (GTK_BOX(config), hbox, FALSE, FALSE, 0);
s = g_string_new ("");
g_string_printf (s, "<b>%s:</b> %s", w->component->name,
w->component->description);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL(label), s->str);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
g_string_free (s, TRUE);
/* Separator */
gtk_box_pack_start (GTK_BOX (config), gtk_hseparator_new (),
FALSE, FALSE, 0);
/* Preview window */
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER(vbox), 6);
gtk_box_pack_start (GTK_BOX(config), vbox, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL(label), _("<b>Preview</b>"));
gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
button = gtk_button_new_with_label (_("Refresh"));
gtk_box_pack_end (GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (refresh_cb), w);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX(vbox), sw, TRUE, TRUE, 0);
dialog_box_preview = gtk_imhtml_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER(sw), dialog_box_preview);
pidgin_setup_imhtml (dialog_box_preview);
output = w->component->generate (w);
gtk_imhtml_append_text (GTK_IMHTML(dialog_box_preview),
output, GTK_IMHTML_NO_SCROLL);
free (output);
dialog_box_widget = w;
/* Separator */
gtk_box_pack_start (GTK_BOX (config), gtk_hseparator_new (),
FALSE, FALSE, 0);
/* Configuration stuff */
vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER(vbox), 6);
gtk_box_pack_start (GTK_BOX(config), vbox, TRUE, TRUE, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL(label), _("<b>Configuration</b>"));
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
if (w->component->pref_menu == NULL ||
(menu = (w->component->pref_menu) (w)) == NULL) {
label = gtk_label_new (_("No options available for this component"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
} else {
gtk_box_pack_start (GTK_BOX (vbox), menu, TRUE, TRUE, 0);
}
return config;
}
static void historize(PurpleConversation *c)
{
PurpleAccount *account = NULL;
PurpleConversationType convtype;
PidginConversation *gtkconv = NULL;
GtkTextIter start;
GtkIMHtmlOptions options;
GList *logs = NULL, *logs_head = NULL;
struct tm *log_tm = NULL, *local_tm = NULL;
time_t t, log_time;
double limit_time = 0.0;
const char *name = NULL, *alias = NULL, *LOG_MODE = NULL;
char *header = NULL, *protocol = NULL, *history = NULL;
int conv_counter = 0;
int limit_offset = 0;
int byte_counter = 0;
int check_time = 0;
int log_size, overshoot;
account = purple_conversation_get_account(c);
name = purple_conversation_get_name(c);
alias = name;
LOG_MODE = purple_prefs_get_string("/purple/logging/format");
/* If logging isn't enabled, don't show any history */
if(!purple_prefs_get_bool("/purple/logging/log_ims") &&
!purple_prefs_get_bool("/purple/logging/log_chats"))
return;
/* If the user wants to show 0 logs, stop now */
if(PREF_NUMBER_VAL == 0) {
return;
}
/* If the logging mode is html, set the output options to include no newline.
* Otherwise, it's normal text, so we don't need extra lines */
if(strcasecmp(LOG_MODE, "html")==0) {
options = GTK_IMHTML_NO_NEWLINE;
} else {
options = GTK_IMHTML_NO_COLOURS;
}
/* Determine whether this is an IM or a chat. In either case, if the user has that
* particular log type disabled, the logs file doesnt not get specified */
convtype = purple_conversation_get_type(c);
if (convtype == PURPLE_CONV_TYPE_IM && PREF_IM_VAL) {
GSList *cur;
GSList *buddies = NULL;
/* Find buddies for this conversation. */
buddies = purple_find_buddies(account, name);
/* If we found at least one buddy, save the first buddy's alias. */
if (buddies != NULL)
alias = purple_buddy_get_contact_alias((PurpleBuddy *)buddies->data);
for(cur = buddies; cur; cur = cur->next) {
PurpleBlistNode *node = cur->data;
if(node && (node->prev || node->next)) {
PurpleBlistNode *node2;
for(node2 = node->parent->child; node2; node2 = node2->next) {
logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM,
purple_buddy_get_name((PurpleBuddy *)node2),
purple_buddy_get_account((PurpleBuddy *)node2)), logs);
}
break;
}
}
g_slist_free(buddies);
if (logs)
logs = g_list_sort(logs, purple_log_compare);
else
logs = purple_log_get_logs(PURPLE_LOG_IM, name, account);
} else if (convtype == PURPLE_CONV_TYPE_CHAT && PREF_CHAT_VAL) {
logs = purple_log_get_logs(PURPLE_LOG_CHAT,
purple_conversation_get_name(c), purple_conversation_get_account(c));
}
gtkconv = PIDGIN_CONVERSATION(c);
/* The logs are non-existant or the user has disabled this type for log displaying. */
if (!logs) {
return;
}
/* Keep a pointer to the head of the logs for freeing later */
logs_head = logs;
/* If all time prefs are not 0, prepare to check times */
if (!(PREF_MINS_VAL == 0 && PREF_HOURS_VAL == 0 && PREF_DAYS_VAL == 0)) {
check_time = 1;
/* Grab current time and normalize it to UTC */
t = time(NULL);
local_tm = gmtime(&t);
t = mktime(local_tm);
limit_time = (PREF_MINS_VAL * 60.0) + (PREF_HOURS_VAL * 60.0 * 60.0) +
(PREF_DAYS_VAL * 60.0 * 60.0 * 24.0);
}
/* The protocol will need to be adjusted for each log for correct display,
so save the current imhtml protocol_name to restore it later */
protocol = g_strdup(gtk_imhtml_get_protocol_name(GTK_IMHTML(gtkconv->imhtml)));
/* Calculate time for the first log */
log_tm = gmtime(&((PurpleLog*)logs->data)->time);
log_time = mktime(log_tm);
/* Continue to add older logs until they run out or the conditions are no
longer met */
while (logs && conv_counter < PREF_NUMBER_VAL
&& byte_counter < PREF_BYTES_VAL
&& (!check_time || difftime(t, log_time) < limit_time)) {
guint flags;
/* Get the current log's contents as a char* */
history = purple_log_read((PurpleLog*)logs->data, &flags);
log_size = strlen(history);
if (flags & PURPLE_LOG_READ_NO_NEWLINE)
options |= GTK_IMHTML_NO_NEWLINE;
else
options &= ~GTK_IMHTML_NO_NEWLINE;
/* Update the overall byte count and determine if this log exceeds the limit */
byte_counter += log_size;
overshoot = byte_counter - PREF_BYTES_VAL;
if (overshoot > 0) {
/* Start looking at the maximum log size for a newline to break at */
limit_offset = overshoot;
/* Find the next \n, or stop if the end of the log is reached */
while (history[limit_offset] && history[limit_offset] != '\n') {
limit_offset++;
}
/* If we're at or very close to the end of the log, forget this log */
if (!history[limit_offset] || (log_size - limit_offset < 3)) {
limit_offset = -1;
}
else {
/* Start at the first character after the newline */
limit_offset++;
}
}
conv_counter++;
/* If this log won't fit at all, don't display it in the conversation */
if (limit_offset != -1) {
/* Set the correct protocol_name for this log */
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml),
purple_account_get_protocol_name(((PurpleLog*)logs->data)->account));
/* Prepend the contents of the log starting at the calculated offset */
gtk_text_buffer_get_iter_at_offset(GTK_IMHTML(gtkconv->imhtml)->text_buffer,
&start, 0);
gtk_imhtml_insert_html_at_iter(GTK_IMHTML(gtkconv->imhtml),
history + limit_offset, options, &start);
/* Prepend the conversation header */
if (PREF_DATES_VAL) {
header = g_strdup_printf(_("<b>Conversation with %s on %s:</b><br>"), alias,
purple_date_format_full(localtime(&((PurpleLog *)logs->data)->time)));
gtk_text_buffer_get_iter_at_offset(GTK_IMHTML(gtkconv->imhtml)->text_buffer,
&start, 0);
gtk_imhtml_insert_html_at_iter(GTK_IMHTML(gtkconv->imhtml),
header, options, &start);
g_free(header);
}
}
g_free(history);
if (limit_offset > 0) {
/* This log had to be chopped to fit, so stop after this one */
break;
}
logs = logs->next;
/* Recalculate log time if we haven't run out of logs */
if (logs) {
log_tm = gmtime(&((PurpleLog*)logs->data)->time);
log_time = mktime(log_tm);
}
}
gtk_imhtml_append_text(GTK_IMHTML(gtkconv->imhtml), "<hr>", options);
/* Restore the original protocol_name */
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml), protocol);
g_free(protocol);
g_object_ref(G_OBJECT(gtkconv->imhtml));
g_idle_add(_scroll_imhtml_to_end, gtkconv->imhtml);
/* Clear the allocated memory that the logs are using */
g_list_foreach(logs_head, (GFunc)purple_log_free, NULL);
g_list_free(logs_head);
}
/* handle empty collection */
void
empty_collection(WindowStruct *curr)
{
gtk_imhtml_clear(GTK_IMHTML(curr->imhtml));
gtk_imhtml_append_text(GTK_IMHTML(curr->imhtml), "<b><font color='#cc0000'>Empty collection!</font></b><br>", 0);
}
void do_away_message(GtkWidget *w, struct away_message *a)
{
GtkWidget *back;
GtkWidget *edit;
GtkWidget *awaytext;
GtkWidget *sw;
GtkWidget *vbox;
GtkWidget *hbox;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
char *buf;
if (!a)
return;
if(imaway)
gtk_widget_destroy(imaway);
GAIM_DIALOG(imaway);
gtk_window_set_role(GTK_WINDOW(imaway), "imaway");
if (strlen(a->name))
gtk_window_set_title(GTK_WINDOW(imaway), a->name);
else
gtk_window_set_title(GTK_WINDOW(imaway), _("Away!"));
g_signal_connect(G_OBJECT(imaway), "destroy",
G_CALLBACK(do_im_back), imaway);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(imaway), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_widget_show(vbox);
hbox = gtk_hbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 0);
gtk_widget_show(hbox);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN);
gtk_widget_set_size_request(sw, 245, 120);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
gtk_widget_show(sw);
awaytext = gtk_imhtml_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(sw), awaytext);
gaim_setup_imhtml(awaytext);
gtk_widget_show(awaytext);
buf = stylize(a->message, BUF_LONG);
gtk_imhtml_append_text(GTK_IMHTML(awaytext), buf, GTK_IMHTML_NO_TITLE |
GTK_IMHTML_NO_COMMENTS | GTK_IMHTML_NO_SCROLL);
g_free(buf);
gtk_imhtml_append_text(GTK_IMHTML(awaytext), "<BR>",
GTK_IMHTML_NO_TITLE | GTK_IMHTML_NO_COMMENTS |
GTK_IMHTML_NO_SCROLL);
awayqueuesw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(awayqueuesw),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(awayqueuesw),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), awayqueuesw, TRUE, TRUE, 0);
awayqueuestore = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
awayqueue = gtk_tree_view_new_with_model(GTK_TREE_MODEL(awayqueuestore));
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(awayqueue), FALSE);
column = gtk_tree_view_column_new_with_attributes (NULL, renderer,
"text", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(awayqueue), column);
column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"text", 1,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(awayqueue), column);
column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"text", 2,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(awayqueue), column);
gtk_container_add(GTK_CONTAINER(awayqueuesw), awayqueue);
g_signal_connect(G_OBJECT(awayqueue), "button_press_event", G_CALLBACK(dequeue_cb), NULL);
if (gaim_prefs_get_bool("/gaim/gtk/away/queue_messages")) {
gtk_widget_show(awayqueuesw);
gtk_widget_show(awayqueue);
}
awaymessage = a;
edit = gaim_pixbuf_button_from_stock(_("Edit This Message"), GTK_STOCK_CONVERT, GAIM_BUTTON_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(hbox), edit, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(edit), "clicked", G_CALLBACK(create_away_mess), awaymessage);
gtk_widget_show(edit);
back = gaim_pixbuf_button_from_stock(_("I'm Back!"), GTK_STOCK_JUMP_TO, GAIM_BUTTON_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(hbox), back, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(back), "clicked", G_CALLBACK(do_im_back), imaway);
gtk_window_set_focus(GTK_WINDOW(imaway), back);
gtk_widget_show(back);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(imaway);
serv_set_away_all(awaymessage->message);
}
/*--------------------------------------------------------------------------*
* Info Tab *
*--------------------------------------------------------------------------*/
static GtkWidget *get_info_page () {
GtkWidget *page;
GtkWidget *label;
GtkWidget *aboutwin;
GtkWidget *text;
gchar *labeltext, *str;
/* Make the box */
page = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (page), 5);
/* AutoProfile title */
labeltext = g_strdup_printf (
_("<span weight=\"bold\" size=\"larger\">AutoProfile %s</span>"),
PP_VERSION);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL(label), labeltext);
gtk_label_set_line_wrap (GTK_LABEL(label), TRUE);
gtk_misc_set_alignment (GTK_MISC(label), 0.5, 0);
gtk_box_pack_start (GTK_BOX(page), label, FALSE, FALSE, 0);
g_free(labeltext);
/* Window with info */
aboutwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(aboutwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
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),
_("Use the <b>Autoprofile</b> portion of the <b>Tools</b> "
"menu in the <b>"
"buddy list</b> to configure the actual content that will go in your "
"status messages and profiles and set options.<br><br>"),
GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("<u>DOCUMENTATION / HELP</u><br>"), GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("Complete documentation can be found at:<br> <a href="
"\"http://hkn.eecs.berkeley.edu/~casey/autoprofile/documentation.php\">"
"hkn.eecs.berkeley.edu/~casey/autoprofile/documentation.php</a><br>"),
GTK_IMHTML_NO_SCROLL);
gtk_imhtml_append_text (GTK_IMHTML(text),
_("<br><u>ABOUT</u><br>"), GTK_IMHTML_NO_SCROLL);
str = g_strconcat(
"<font size=\"3\"><b>", _("Developers"), ":</b></font><br>"
" Casey Ho (Lead Developer)<br>"
" Mitchell Harwell<br>", NULL);
gtk_imhtml_append_text(GTK_IMHTML(text), str, GTK_IMHTML_NO_SCROLL);
g_free(str);
str = g_strconcat(
"<font size=\"3\"><b>", _("Contributors/Patchers"), ":</b></font><br>"
" Onime Clement<br>"
" Michael Milligan<br>"
" Mark Painter<br>", NULL);
gtk_imhtml_append_text(GTK_IMHTML(text), str, GTK_IMHTML_NO_SCROLL);
g_free(str);
str = g_strconcat(
"<font size=\"3\"><b>", _("Website"), ":</b></font><br>"
" <a href=\"http://autoprofile.sourceforge.net\">"
"autoprofile.sourceforge.net<br>", NULL);
gtk_imhtml_append_text(GTK_IMHTML(text), str, GTK_IMHTML_NO_SCROLL);
g_free(str);
return page;
}
static void *
gaim_gtk_notify_formatted(const char *title, const char *primary,
const char *secondary, const char *text,
GCallback cb, void *user_data)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *imhtml;
GtkWidget *sw;
int options = 0;
char label_text[2048];
char *linked_text;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), title);
gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_container_set_border_width(GTK_CONTAINER(window), 12);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(formatted_close_cb), NULL);
/* Setup the main vbox */
vbox = gtk_vbox_new(FALSE, 12);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
/* Setup the descriptive label */
g_snprintf(label_text, sizeof(label_text),
"<span weight=\"bold\" size=\"larger\">%s</span>%s%s",
primary,
(secondary ? "\n" : ""),
(secondary ? secondary : ""));
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), label_text);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
/* Setup the scrolled window that we're putting the gtkimhtml in. */
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER,
GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_widget_set_size_request(sw, 300, 250);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
gtk_widget_show(sw);
/* Now build that gtkimhtml */
imhtml = gtk_imhtml_new(NULL, NULL);
gtk_widget_set_name(imhtml, "gaim_gtknotify_imhtml");
gtk_container_add(GTK_CONTAINER(sw), imhtml);
gtk_widget_show(imhtml);
gaim_setup_imhtml(imhtml);
/* Add the Close button. */
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
g_signal_connect_swapped(G_OBJECT(button), "clicked",
G_CALLBACK(formatted_close_cb), window);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(formatted_input_cb), NULL);
/* Add the text to the gtkimhtml */
if (gaim_prefs_get_bool("/gaim/gtk/conversations/ignore_colors"))
options ^= GTK_IMHTML_NO_COLOURS;
if (gaim_prefs_get_bool("/gaim/gtk/conversations/ignore_fonts"))
options ^= GTK_IMHTML_NO_FONTS;
if (gaim_prefs_get_bool("/gaim/gtk/conversations/ignore_font_sizes"))
options ^= GTK_IMHTML_NO_SIZES;
options ^= GTK_IMHTML_NO_COMMENTS;
options ^= GTK_IMHTML_NO_TITLE;
options ^= GTK_IMHTML_NO_NEWLINE;
options ^= GTK_IMHTML_NO_SCROLL;
/* Make sure URLs are clickable */
linked_text = gaim_markup_linkify(text);
gtk_imhtml_append_text(GTK_IMHTML(imhtml), linked_text,
options);
g_free(linked_text);
/* Show the window */
gtk_widget_show(window);
return window;
}
static void
create_console(PurplePluginAction *action)
{
GtkWidget *vbox = gtk_vbox_new(FALSE, 6);
GtkWidget *label;
GtkTextBuffer *buffer;
GtkWidget *toolbar;
GList *connections;
GtkToolItem *button;
if (console) {
gtk_window_present(GTK_WINDOW(console->window));
return;
}
console = g_new0(XmppConsole, 1);
console->window = pidgin_create_window(_("XMPP Console"), PIDGIN_HIG_BORDER, NULL, TRUE);
g_signal_connect(G_OBJECT(console->window), "destroy", G_CALLBACK(console_destroy), NULL);
gtk_window_set_default_size(GTK_WINDOW(console->window), 580, 400);
gtk_container_add(GTK_CONTAINER(console->window), vbox);
console->hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), console->hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Account: "));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(console->hbox), label, FALSE, FALSE, 0);
console->dropdown = gtk_combo_box_new_text();
for (connections = purple_connections_get_all(); connections; connections = connections->next) {
PurpleConnection *gc = connections->data;
if (!strcmp(purple_account_get_protocol_id(purple_connection_get_account(gc)), "prpl-jabber")) {
console->count++;
console->accounts = g_list_append(console->accounts, gc);
gtk_combo_box_append_text(GTK_COMBO_BOX(console->dropdown),
purple_account_get_username(purple_connection_get_account(gc)));
if (!console->gc)
console->gc = gc;
}
}
gtk_combo_box_set_active(GTK_COMBO_BOX(console->dropdown),0);
gtk_box_pack_start(GTK_BOX(console->hbox), console->dropdown, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(console->dropdown), "changed", G_CALLBACK(dropdown_changed_cb), NULL);
console->imhtml = gtk_imhtml_new(NULL, NULL);
if (console->count == 0)
gtk_imhtml_append_text(GTK_IMHTML(console->imhtml),
_("<font color='#c8c8c8'>Not connected to XMPP</font>"), 0);
gtk_box_pack_start(GTK_BOX(vbox),
pidgin_make_scrollable(console->imhtml, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_ETCHED_IN, -1, -1),
TRUE, TRUE, 0);
toolbar = gtk_toolbar_new();
button = gtk_tool_button_new(NULL, "<iq/>");
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(iq_clicked_cb), NULL);
gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(button));
button = gtk_tool_button_new(NULL, "<presence/>");
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(presence_clicked_cb), NULL);
gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(button));
button = gtk_tool_button_new(NULL, "<message/>");
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(message_clicked_cb), NULL);
gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(button));
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
console->entry = gtk_imhtml_new(NULL, NULL);
gtk_imhtml_set_whole_buffer_formatting_only(GTK_IMHTML(console->entry), TRUE);
g_signal_connect(G_OBJECT(console->entry),"message_send", G_CALLBACK(message_send_cb), console);
console->sw = pidgin_make_scrollable(console->entry, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_ETCHED_IN, -1, -1);
gtk_box_pack_start(GTK_BOX(vbox), console->sw, FALSE, FALSE, 0);
gtk_imhtml_set_editable(GTK_IMHTML(console->entry), TRUE);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(console->entry));
g_signal_connect(G_OBJECT(buffer), "changed", G_CALLBACK(entry_changed_cb), NULL);
entry_changed_cb(buffer, NULL);
gtk_widget_show_all(console->window);
if (console->count < 2)
gtk_widget_hide(console->hbox);
}
static void
gaim_gtk_debug_print(GaimDebugLevel level, const char *category,
const char *format, va_list args)
{
gchar *arg_s, *ts_s;
gboolean timestamps;
timestamps = gaim_prefs_get_bool("/gaim/gtk/debug/timestamps");
arg_s = g_strdup_vprintf(format, args);
if (category == NULL) {
ts_s = g_strdup("");
}
else {
/*
* If the category is not NULL, then do timestamps.
* This IS right. :)
*/
if (timestamps) {
gchar mdate[64];
time_t mtime = time(NULL);
strftime(mdate, sizeof(mdate), "%H:%M:%S", localtime(&mtime));
ts_s = g_strdup_printf("(%s) ", mdate);
}
else
ts_s = g_strdup("");
}
if (gaim_prefs_get_bool("/gaim/gtk/debug/enabled") &&
debug_win != NULL && !debug_win->paused) {
gchar *esc_s, *cat_s, *utf8_s, *s;
if (category == NULL)
cat_s = g_strdup("");
else
cat_s = g_strdup_printf("<b>%s:</b> ", category);
esc_s = g_markup_escape_text(arg_s, -1);
s = g_strdup_printf("<font color=\"%s\">%s%s%s</font>",
debug_fg_colors[level], ts_s, cat_s, esc_s);
g_free(esc_s);
utf8_s = gaim_utf8_try_convert(s);
g_free(s);
s = utf8_s;
if (level == GAIM_DEBUG_FATAL) {
gchar *temp = s;
s = g_strdup_printf("<b>%s</b>", temp);
g_free(temp);
}
g_free(cat_s);
gtk_imhtml_append_text(GTK_IMHTML(debug_win->text), s, 0);
g_free(s);
}
if (opt_debug) {
if (category == NULL)
g_print("%s%s", ts_s, arg_s);
else
g_print("%s%s: %s", ts_s, category, arg_s);
}
g_free(ts_s);
g_free(arg_s);
}
