annotate src/gtkdebug.c @ 9490:a5aa8c659974

[gaim-migrate @ 10315] Mooga. committer: Tailor Script <[e-mail]>

 1 /**
 2  * @file gtkdebug.c GTK+ Debug API
 3  * @ingroup gtkui
 4  *
 5  * gaim
 6  *
 7  * Gaim is the legal property of its developers, whose names are too numerous
 8  * to list here.  Please refer to the COPYRIGHT file distributed with this
 9  * source distribution.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24  */
25 #include "gtkinternal.h"
26 
27 #include "notify.h"
28 #include "prefs.h"
29 #include "request.h"
30 #include "util.h"
31 
32 #include "gtkdebug.h"
33 #include "gtkimhtml.h"
34 #include "gtkutils.h"
35 #include "stock.h"
36 
37 #include "ui.h"
38 
39 extern int opt_debug;
40 
41 typedef struct
42 {
43 	GtkWidget *window;
44 	GtkWidget *text;
45 	GtkWidget *find;
46 	GtkWidget *save;
47 
48 	gboolean timestamps;
49 	gboolean paused;
50 
51 	guint timestamps_handle;
52 
53 } DebugWindow;
54 
55 static char debug_fg_colors[][8] = {
56 	"#000000",    /**< All debug levels. */
57 	"#666666",    /**< Misc.             */
58 	"#000000",    /**< Information.      */
59 	"#660000",    /**< Warnings.         */
60 	"#FF0000",    /**< Errors.           */
61 	"#FF0000",    /**< Fatal errors.     */
62 };
63 
64 static DebugWindow *debug_win = NULL;
65 
66 struct _find {
67 	DebugWindow *window;
68 	GtkWidget *entry;
69 };
70 
71 static gint
72 debug_window_destroy(GtkWidget *w, GdkEvent *event, void *unused)
73 {
74 	if (debug_win->timestamps_handle != 0)
75 		gaim_prefs_disconnect_callback(debug_win->timestamps_handle);
76 	if (debug_win->save != NULL) {
77 		gaim_notify_close_with_handle(debug_win->save);
78 		gaim_request_close_with_handle(debug_win->save);
79 		gtk_widget_destroy(debug_win->save);
80 	}
81 
82 	g_free(debug_win);
83 	debug_win = NULL;
84 
85 	gaim_prefs_set_bool("/gaim/gtk/debug/enabled", FALSE);
86 
87 	return FALSE;
88 }
89 
90 static gboolean
91 configure_cb(GtkWidget *w, GdkEventConfigure *event, DebugWindow *win)
92 {
93 	if (GTK_WIDGET_VISIBLE(w)) {
94 		gaim_prefs_set_int("/gaim/gtk/debug/width",  event->width);
95 		gaim_prefs_set_int("/gaim/gtk/debug/height", event->height);
96 	}
97 
98 	return FALSE;
99 }
100 
101 static void
102 do_find_cb(GtkWidget *widget, gint response, struct _find *f)
103 {
104 	switch (response) {
105 	case GTK_RESPONSE_OK:
106 	    gtk_imhtml_search_find(GTK_IMHTML(f->window->text),
107 							   gtk_entry_get_text(GTK_ENTRY(f->entry)));
108 		break;
109 
110 	case GTK_RESPONSE_DELETE_EVENT:
111 	case GTK_RESPONSE_CLOSE:
112 		gtk_imhtml_search_clear(GTK_IMHTML(f->window->text));
113 		gtk_widget_destroy(f->window->find);
114 		f->window->find = NULL;
115 		g_free(f);
116 		break;
117 	}
118 }
119 
120 static void
121 find_cb(GtkWidget *w, DebugWindow *win)
122 {
123 	GtkWidget *hbox, *img, *label;
124 	struct _find *f;
125 
126 	if(win->find)
127 	{
128 		gtk_window_present(GTK_WINDOW(win->find));
129 		return;
130 	}
131 
132 	f = g_malloc(sizeof(struct _find));
133 	f->window = win;
134 	win->find = gtk_dialog_new_with_buttons(_("Find"),
135 					GTK_WINDOW(win->window), GTK_DIALOG_DESTROY_WITH_PARENT,
136 					GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
137 					GTK_STOCK_FIND, GTK_RESPONSE_OK, NULL);
138 	gtk_dialog_set_default_response(GTK_DIALOG(win->find),
139 					 GTK_RESPONSE_OK);
140 	g_signal_connect(G_OBJECT(win->find), "response",
141 					G_CALLBACK(do_find_cb), f);
142 
143 	gtk_container_set_border_width(GTK_CONTAINER(win->find), 6);
144 	gtk_window_set_resizable(GTK_WINDOW(win->find), FALSE);
145 	gtk_dialog_set_has_separator(GTK_DIALOG(win->find), FALSE);
146 	gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(win->find)->vbox), 12);
147 	gtk_container_set_border_width(
148 		GTK_CONTAINER(GTK_DIALOG(win->find)->vbox), 6);
149 
150 	hbox = gtk_hbox_new(FALSE, 12);
151 	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(win->find)->vbox),
152 					  hbox);
153 	img = gtk_image_new_from_stock(GAIM_STOCK_DIALOG_QUESTION,
154 								   GTK_ICON_SIZE_DIALOG);
155 	gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
156 
157 	gtk_misc_set_alignment(GTK_MISC(img), 0, 0);
158 	gtk_dialog_set_response_sensitive(GTK_DIALOG(win->find),
159 									  GTK_RESPONSE_OK, FALSE);
160 
161 	label = gtk_label_new(NULL);
162 	gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("_Search for:"));
163 	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
164 
165 	f->entry = gtk_entry_new();
166 	gtk_entry_set_activates_default(GTK_ENTRY(f->entry), TRUE);
167 	gtk_label_set_mnemonic_widget(GTK_LABEL(label), GTK_WIDGET(f->entry));
168 	g_signal_connect(G_OBJECT(f->entry), "changed",
169 					 G_CALLBACK(gaim_gtk_set_sensitive_if_input),
170 					 win->find);
171 	gtk_box_pack_start(GTK_BOX(hbox), f->entry, FALSE, FALSE, 0);
172 
173 	gtk_widget_show_all(win->find);
174 	gtk_widget_grab_focus(f->entry);
175 }
176 
177 static void
178 save_writefile_cb(DebugWindow *win, gint id)
179 {
180 	const char *filename;
181 	FILE *fp;
182 	char *tmp;
183 
184 #if GTK_CHECK_VERSION(2,4,0) /* FILECHOOSER */
185 	filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(win->save));
186 #else /* FILECHOOSER */
187 	filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(win->save));
188 #endif /* FILECHOOSER */
189 
190 	gaim_notify_close_with_handle(win->save);
191 
192 	if (filename == NULL) {
193 		gaim_notify_error(win->save, NULL, _("Invalid file name."), NULL);
194 		return;
195 	}
196 
197 	if ((fp = fopen(filename, "w+")) == NULL) {
198 		gaim_notify_error(win->save, NULL, _("Unable to open file."), NULL);
199 		return;
200 	}
201 
202 	tmp = gtk_imhtml_get_text(GTK_IMHTML(win->text), NULL, NULL);
203 	fprintf(fp, "Gaim Debug log : %s\n", gaim_date_full());
204 	fprintf(fp, "%s", tmp);
205 	g_free(tmp);
206 
207 	fclose(fp);
208 
209 	gtk_widget_destroy(win->save);
210 	win->save = NULL;
211 }
212 
213 #if GTK_CHECK_VERSION(2,4,0) /* FILECHOOSER */
214 static void
215 save_checkfile_cb(GtkWidget *widget, gint response, DebugWindow *win)
216 {
217 	const char *filename;
218 
219 	if (response != GTK_RESPONSE_ACCEPT) {
220 		gaim_notify_close_with_handle(win->save);
221 		gaim_request_close_with_handle(win->save);
222 		if (response == GTK_RESPONSE_CANCEL)
223 			gtk_widget_destroy(win->save);
224 		win->save = NULL;
225 		return;
226 	}
227 
228 	filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(win->save));
229 #else /* FILECHOOSER */
230 static void
231 save_checkfile_cb(GtkWidget *widget, DebugWindow *win)
232 {
233 	const char *filename;
234 
235 	filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(win->save));
236 	if (gaim_gtk_check_if_dir(filename, GTK_FILE_SELECTION(win->save))) {
237 		/* Descend into directory? */
238 		return;
239 	}
240 #endif /* FILECHOOSER */
241 
242 	gaim_request_close_with_handle(win->save);
243 
244 	if (g_file_test(filename, G_FILE_TEST_EXISTS))
245 	{
246 		gaim_request_yes_no(win->save, NULL, _("That file already exists"),
247 							_("Would you like to overwrite it?"), 1,
248 							win, G_CALLBACK(save_writefile_cb), NULL);
249 	}
250 	else
251 		save_writefile_cb(win, 1);
252 }
253 
254 #if !GTK_CHECK_VERSION(2,4,0) /* FILECHOOSER */
255 static void
256 save_destroy_cb(GtkWidget *widget, DebugWindow *win)
257 {
258 	if (win->save != NULL) {
259 		gaim_notify_close_with_handle(win->save);
260 		gaim_request_close_with_handle(win->save);
261 		gtk_widget_destroy(win->save);
262 		win->save = NULL;
263 	}
264 }
265 #endif
266 
267 static void
268 save_cb(GtkWidget *w, DebugWindow *win)
269 {
270 #if !GTK_CHECK_VERSION(2,4,0)
271 	gchar *buf;
272 #endif
273 
274 	if (win->save != NULL) {
275 		gtk_window_present(GTK_WINDOW(win->save));
276 		return;
277 	}
278 
279 #if GTK_CHECK_VERSION(2,4,0) /* FILECHOOSER */
280 	win->save = gtk_file_chooser_dialog_new(_("Save Conversation"),
281 					GTK_WINDOW(win->window),
282 					GTK_FILE_CHOOSER_ACTION_SAVE,
283 					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
284 					GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
285 					NULL);
286 	gtk_dialog_set_default_response(GTK_DIALOG(win->save), GTK_RESPONSE_ACCEPT);
287 	gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(win->save),
288 									  "gaim-debug.log");
289 	g_signal_connect(G_OBJECT(win->save), "response",
290 					 G_CALLBACK(save_checkfile_cb), win);
291 #else /* FILECHOOSER */
292 	buf = g_strdup_printf("%s" G_DIR_SEPARATOR_S "gaim-debug.log",
293 						  gaim_home_dir());
294 	win->save = gtk_file_selection_new(_("Save Debug Log"));
295 	gtk_file_selection_set_filename(GTK_FILE_SELECTION(win->save), buf);
296 	g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(win->save)->ok_button),
297 					 "clicked", G_CALLBACK(save_checkfile_cb), win);
298 	g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(win->save)->cancel_button),
299 					 "clicked", G_CALLBACK(save_destroy_cb), win);
300 	g_signal_connect(G_OBJECT(win->save),
301 					 "destroy", G_CALLBACK(save_destroy_cb), win);
302 	g_free(buf);
303 #endif /* FILECHOOSER */
304 
305 	gtk_widget_show_all(GTK_WIDGET(win->save));
306 }
307 
308 static void
309 clear_cb(GtkWidget *w, DebugWindow *win)
310 {
311 	gtk_imhtml_clear(GTK_IMHTML(win->text));
312 }
313 
314 static void
315 pause_cb(GtkWidget *w, DebugWindow *win)
316 {
317 	win->paused = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
318 }
319 
320 static void
321 timestamps_cb(GtkWidget *w, DebugWindow *win)
322 {
323 	win->timestamps = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
324 
325 	gaim_prefs_set_bool("/gaim/gtk/debug/timestamps", win->timestamps);
326 }
327 
328 static void
329 timestamps_pref_cb(const char *name, GaimPrefType type, gpointer value,
330 				   gpointer data)
331 {
332 	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data), GPOINTER_TO_INT(value));
333 }
334 
335 static DebugWindow *
336 debug_window_new(void)
337 {
338 	DebugWindow *win;
339 	GtkWidget *vbox;
340 	GtkWidget *toolbar;
341 	GtkWidget *sw;
342 	GtkWidget *button;
343 	GtkWidget *image;
344 	int width, height;
345 
346 	win = g_new0(DebugWindow, 1);
347 
348 	width  = gaim_prefs_get_int("/gaim/gtk/debug/width");
349 	height = gaim_prefs_get_int("/gaim/gtk/debug/height");
350 
351 	GAIM_DIALOG(win->window);
352 	gaim_debug(GAIM_DEBUG_INFO, "gtkdebug", "Setting dimensions to %d, %d\n",
353 			   width, height);
354 
355 	gtk_window_set_default_size(GTK_WINDOW(win->window), width, height);
356 	gtk_window_set_role(GTK_WINDOW(win->window), "debug");
357 	gtk_window_set_title(GTK_WINDOW(win->window), _("Debug Window"));
358 
359 	g_signal_connect(G_OBJECT(win->window), "delete_event",
360 					 G_CALLBACK(debug_window_destroy), NULL);
361 	g_signal_connect(G_OBJECT(win->window), "configure_event",
362 					 G_CALLBACK(configure_cb), win);
363 
364 	/* Setup the vbox */
365 	vbox = gtk_vbox_new(FALSE, 0);
366 	gtk_container_add(GTK_CONTAINER(win->window), vbox);
367 
368 	if (gaim_prefs_get_bool("/gaim/gtk/debug/toolbar")) {
369 		/* Setup our top button bar thingie. */
370 		toolbar = gtk_toolbar_new();
371 		gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
372 		gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar),
373 								  GTK_ICON_SIZE_SMALL_TOOLBAR);
374 
375 		gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
376 
377 		/* Find button */
378 		gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar), GTK_STOCK_FIND,
379 								 NULL, NULL, G_CALLBACK(find_cb), win, -1);
380 
381 		/* Save */
382 		gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar), GTK_STOCK_SAVE,
383 								 NULL, NULL, G_CALLBACK(save_cb), win, -1);
384 
385 		/* Clear button */
386 		gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar), GTK_STOCK_CLEAR,
387 								 NULL, NULL, G_CALLBACK(clear_cb), win, -1);
388 
389 		gtk_toolbar_insert_space(GTK_TOOLBAR(toolbar), -1);
390 
391 		/* Pause */
392 		image = gtk_image_new_from_stock(GAIM_STOCK_PAUSE, GTK_ICON_SIZE_MENU);
393 		button = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar),
394 											GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
395 											NULL, _("Pause"), NULL, NULL,
396 											image, G_CALLBACK(pause_cb), win);
397 
398 		/* Timestamps */
399 		button = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar),
400 											GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
401 											NULL, _("Timestamps"), NULL, NULL,
402 											NULL, G_CALLBACK(timestamps_cb),
403 											win);
404 
405 		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
406 						gaim_prefs_get_bool("/gaim/gtk/debug/timestamps"));
407 
408 		win->timestamps_handle =
409 			gaim_prefs_connect_callback("/gaim/gtk/debug/timestamps",
410 										timestamps_pref_cb, button);
411 	}
412 
413 	/* Now our scrolled window... */
414 	sw = gtk_scrolled_window_new(NULL, NULL);
415 	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
416 								   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
417 	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
418 										GTK_SHADOW_IN);
419 
420 	/* ... which has a gtkimhtml in it. */
421 	win->text = gtk_imhtml_new(NULL, NULL);
422 
423 	gtk_container_add(GTK_CONTAINER(sw), win->text);
424 
425 	/* Pack it in... Not like that, sicko. */
426 	gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
427 
428 	gtk_widget_show_all(win->window);
429 
430 	return win;
431 }
432 
433 static void
434 debug_enabled_cb(const char *name, GaimPrefType type, gpointer value,
435 				 gpointer data)
436 {
437 	if (value)
438 		gaim_gtk_debug_window_show();
439 	else
440 		gaim_gtk_debug_window_hide();
441 }
442 
443 static void
444 gaim_glib_log_handler(const gchar *domain, GLogLevelFlags flags,
445 					  const gchar *msg, gpointer user_data)
446 {
447 	GaimDebugLevel level;
448 	char *new_msg = NULL;
449 	char *new_domain = NULL;
450 
451 	if ((flags & G_LOG_LEVEL_ERROR) == G_LOG_LEVEL_ERROR)
452 		level = GAIM_DEBUG_ERROR;
453 	else if ((flags & G_LOG_LEVEL_CRITICAL) == G_LOG_LEVEL_CRITICAL)
454 		level = GAIM_DEBUG_FATAL;
455 	else if ((flags & G_LOG_LEVEL_WARNING) == G_LOG_LEVEL_WARNING)
456 		level = GAIM_DEBUG_WARNING;
457 	else if ((flags & G_LOG_LEVEL_MESSAGE) == G_LOG_LEVEL_MESSAGE)
458 		level = GAIM_DEBUG_INFO;
459 	else if ((flags & G_LOG_LEVEL_INFO) == G_LOG_LEVEL_INFO)
460 		level = GAIM_DEBUG_INFO;
461 	else if ((flags & G_LOG_LEVEL_DEBUG) == G_LOG_LEVEL_DEBUG)
462 		level = GAIM_DEBUG_MISC;
463 	else
464 	{
465 		gaim_debug_warning("gtkdebug",
466 				   "Unknown glib logging level in %d\n", flags);
467 
468 		level = GAIM_DEBUG_MISC; /* This will never happen. */
469 	}
470 
471 	if (msg != NULL)
472 		new_msg = gaim_utf8_try_convert(msg);
473 
474 	if (domain != NULL)
475 		new_domain = gaim_utf8_try_convert(domain);
476 
477 	if (new_msg != NULL)
478 	{
479 		gaim_debug(level, (new_domain != NULL ? new_domain : "g_log"),
480 				   "%s\n", new_msg);
481 
482 		g_free(new_msg);
483 	}
484 
485 	if (new_domain != NULL)
486 		g_free(new_domain);
487 }
488 
489 #ifdef _WIN32
490 static void
491 gaim_glib_dummy_print_handler(const gchar *string)
492 {
493 }
494 #endif
495 
496 void
497 gaim_gtk_debug_init(void)
498 {
499 	/* Debug window preferences. */
500 	/*
501 	 * NOTE: This must be set before prefs are loaded, and the callbacks
502 	 *       set after they are loaded, since prefs sets the enabled
503 	 *       preference here and that loads the window, which calls the
504 	 *       configure event, which overrides the width and height! :P
505 	 */
506 
507 	gaim_prefs_add_none("/gaim/gtk/debug");
508 	gaim_prefs_add_bool("/gaim/gtk/debug/enabled", FALSE);
509 	gaim_prefs_add_bool("/gaim/gtk/debug/timestamps", FALSE);
510 	gaim_prefs_add_bool("/gaim/gtk/debug/toolbar", TRUE);
511 	gaim_prefs_add_int("/gaim/gtk/debug/width",  450);
512 	gaim_prefs_add_int("/gaim/gtk/debug/height", 250);
513 
514 	gaim_prefs_connect_callback("/gaim/gtk/debug/enabled",
515 								debug_enabled_cb, NULL);
516 
517 #define REGISTER_G_LOG_HANDLER(name) \
518 	g_log_set_handler((name), G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL \
519 					  | G_LOG_FLAG_RECURSION, \
520 					  gaim_glib_log_handler, NULL)
521 
522 	/* Register the glib/gtk log handlers. */
523 	REGISTER_G_LOG_HANDLER(NULL);
524 	REGISTER_G_LOG_HANDLER("Gdk");
525 	REGISTER_G_LOG_HANDLER("Gtk");
526 	REGISTER_G_LOG_HANDLER("GdkPixbuf");
527 	REGISTER_G_LOG_HANDLER("GLib");
528 	REGISTER_G_LOG_HANDLER("GModule");
529 	REGISTER_G_LOG_HANDLER("GLib-GObject");
530 	REGISTER_G_LOG_HANDLER("GThread");
531 
532 #ifdef _WIN32
533 	if (!opt_debug)
534 		g_set_print_handler(gaim_glib_dummy_print_handler);
535 #endif
536 }
537 
538 void
539 gaim_gtk_debug_window_show(void)
540 {
541 	if (debug_win == NULL)
542 		debug_win = debug_window_new();
543 
544 	gtk_widget_show(debug_win->window);
545 
546 	gaim_prefs_set_bool("/gaim/gtk/debug/enabled", TRUE);
547 }
548 
549 void
550 gaim_gtk_debug_window_hide(void)
551 {
552 	if (debug_win != NULL) {
553 		gtk_widget_destroy(debug_win->window);
554 		debug_window_destroy(NULL, NULL, NULL);
555 	}
556 }
557 
558 static void
559 gaim_gtk_debug_print(GaimDebugLevel level, const char *category,
560 					 const char *format, va_list args)
561 {
562 	gchar *arg_s, *ts_s;
563 	gboolean timestamps;
564 
565 	timestamps = gaim_prefs_get_bool("/gaim/gtk/debug/timestamps");
566 
567 	arg_s = g_strdup_vprintf(format, args);
568 
569 	if (category == NULL) {
570 		ts_s = g_strdup("");
571 	}
572 	else {
573 		/*
574 		 * If the category is not NULL, then do timestamps.
575 		 * This IS right. :)
576 		 */
577 		if (timestamps) {
578 			gchar mdate[64];
579 			time_t mtime = time(NULL);
580 
581 			strftime(mdate, sizeof(mdate), "%H:%M:%S", localtime(&mtime));
582 
583 			ts_s = g_strdup_printf("(%s) ", mdate);
584 		}
585 		else
586 			ts_s = g_strdup("");
587 	}
588 
589 	if (gaim_prefs_get_bool("/gaim/gtk/debug/enabled") &&
590 		debug_win != NULL && !debug_win->paused) {
591 
592 		gchar *esc_s, *cat_s, *utf8_s, *s;
593 
594 		if (category == NULL)
595 			cat_s = g_strdup("");
596 		else
597 			cat_s = g_strdup_printf("<b>%s:</b> ", category);
598 
599 		esc_s = g_markup_escape_text(arg_s, -1);
600 
601 		s = g_strdup_printf("<font color=\"%s\">%s%s%s</font>",
602 							debug_fg_colors[level], ts_s, cat_s, esc_s);
603 
604 		g_free(esc_s);
605 
606 		utf8_s = gaim_utf8_try_convert(s);
607 		g_free(s);
608 		s = utf8_s;
609 
610 		if (level == GAIM_DEBUG_FATAL) {
611 			gchar *temp = s;
612 
613 			s = g_strdup_printf("<b>%s</b>", temp);
614 			g_free(temp);
615 		}
616 
617 		g_free(cat_s);
618 
619 		gtk_imhtml_append_text(GTK_IMHTML(debug_win->text), s, 0);
620 
621 		g_free(s);
622 	}
623 
624 	if (opt_debug) {
625 		if (category == NULL)
626 			g_print("%s%s", ts_s, arg_s);
627 		else
628 			g_print("%s%s: %s", ts_s, category, arg_s);
629 	}
630 
631 	g_free(ts_s);
632 	g_free(arg_s);
633 }
634 
635 static GaimDebugUiOps ops =
636 {
637 	gaim_gtk_debug_print
638 };
639 
640 GaimDebugUiOps *
641 gaim_gtk_debug_get_ui_ops(void)
642 {
643 	return &ops;
644 }