finch/gntdebug.c

   1 /*
   2  * finch
   3  *
   4  * Finch is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  */
  22
  23 #include <internal.h>
  24
  25 #include <gnt.h>
  26 #include <gntbox.h>
  27 #include <gntbutton.h>
  28 #include <gntcheckbox.h>
  29 #include <gntentry.h>
  30 #include <gntfilesel.h>
  31 #include <gntlabel.h>
  32 #include <gntline.h>
  33 #include <gnttextview.h>
  34
  35 #include "gntdebug.h"
  36 #include "finch.h"
  37 #include "notify.h"
  38 #include "util.h"
  39
  40 #include <stdio.h>
  41 #include <string.h>
  42
  43 #define PREF_ROOT "/finch/debug"
  44
  45 struct _FinchDebugUi
  46 {
  47         GObject parent;
  48
  49         /* Other members, including private data. */
  50 };
  51
  52 static void finch_debug_ui_finalize(GObject *gobject);
  53 static void finch_debug_ui_interface_init(PurpleDebugUiInterface *iface);
  54
  55 G_DEFINE_TYPE_WITH_CODE(FinchDebugUi, finch_debug_ui, G_TYPE_OBJECT,
  56                         G_IMPLEMENT_INTERFACE(PURPLE_TYPE_DEBUG_UI,
  57                                               finch_debug_ui_interface_init));
  58
  59 static gboolean
  60 handle_fprintf_stderr_cb(GIOChannel *source, GIOCondition cond, gpointer null)
  61 {
  62         gssize size;
  63         char message[1024];
  64
  65         size = read(g_io_channel_unix_get_fd(source), message, sizeof(message) - 1);
  66         if (size <= 0) {
  67                 /* Something bad probably happened elsewhere ... let's ignore */
  68         } else {
  69                 message[size] = '\0';
  70                 g_log("stderr", G_LOG_LEVEL_WARNING, "%s", message);
  71         }
  72
  73         return TRUE;
  74 }
  75
  76 static void
  77 handle_fprintf_stderr(gboolean stop)
  78 {
  79         GIOChannel *stderrch;
  80         static int readhandle = -1;
  81         int pipes[2];
  82
  83         if (stop) {
  84                 if (readhandle >= 0) {
  85                         g_source_remove(readhandle);
  86                         readhandle = -1;
  87                 }
  88                 return;
  89         }
  90         if (purple_input_pipe(pipes)) {
  91                 readhandle = -1;
  92                 return;
  93         };
  94         dup2(pipes[1], STDERR_FILENO);
  95
  96         stderrch = g_io_channel_unix_new(pipes[0]);
  97         g_io_channel_set_close_on_unref(stderrch, TRUE);
  98         readhandle = g_io_add_watch_full(stderrch, G_PRIORITY_HIGH,
  99                         G_IO_IN | G_IO_ERR | G_IO_PRI,
 100                         handle_fprintf_stderr_cb, NULL, NULL);
 101         g_io_channel_unref(stderrch);
 102 }
 103
 104 static struct
 105 {
 106         GntWidget *window;
 107         GntWidget *tview;
 108         GntWidget *search;
 109         gboolean paused;
 110 } debug;
 111
 112 static gboolean
 113 match_string(const char *category, const char *args)
 114 {
 115         const char *str = gnt_entry_get_text(GNT_ENTRY(debug.search));
 116         if (!str || !*str)
 117                 return TRUE;
 118         if (g_strrstr(category, str) != NULL)
 119                 return TRUE;
 120         if (g_strrstr(args, str) != NULL)
 121                 return TRUE;
 122         return FALSE;
 123 }
 124
 125 static void
 126 finch_debug_print(PurpleDebugUi *self,
 127                   PurpleDebugLevel level, const char *category,
 128                   const char *args)
 129 {
 130         if (debug.window && !debug.paused && match_string(category, args))
 131         {
 132                 int pos = gnt_text_view_get_lines_below(GNT_TEXT_VIEW(debug.tview));
 133                 GntTextFormatFlags flag = GNT_TEXT_FLAG_NORMAL;
 134                 const char *mdate;
 135                 time_t mtime = time(NULL);
 136                 mdate = purple_utf8_strftime("%H:%M:%S ", localtime(&mtime));
 137                 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview),
 138                                 mdate, flag);
 139
 140                 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview),
 141                                 category, GNT_TEXT_FLAG_BOLD);
 142                 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview),
 143                                 ": ", GNT_TEXT_FLAG_BOLD);
 144
 145                 switch (level)
 146                 {
 147                         case PURPLE_DEBUG_WARNING:
 148                                 flag |= GNT_TEXT_FLAG_UNDERLINE;
 149                                 /* fall through */
 150                         case PURPLE_DEBUG_ERROR:
 151                         case PURPLE_DEBUG_FATAL:
 152                                 flag |= GNT_TEXT_FLAG_BOLD;
 153                                 break;
 154                         default:
 155                                 break;
 156                 }
 157
 158                 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview), args, flag);
 159                 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(debug.tview), "\n", GNT_TEXT_FLAG_NORMAL);
 160                 if (pos <= 1)
 161                         gnt_text_view_scroll(GNT_TEXT_VIEW(debug.tview), 0);
 162         }
 163 }
 164
 165 static gboolean
 166 finch_debug_is_enabled(PurpleDebugUi *self, PurpleDebugLevel level, const char *category)
 167 {
 168         return debug.window && !debug.paused;
 169 }
 170
 171 static void
 172 finch_debug_ui_interface_init(PurpleDebugUiInterface *iface)
 173 {
 174         iface->print = finch_debug_print;
 175         iface->is_enabled = finch_debug_is_enabled;
 176 }
 177
 178 static void
 179 reset_debug_win(GntWidget *w, gpointer null)
 180 {
 181         debug.window = debug.tview = debug.search = NULL;
 182 }
 183
 184 static void
 185 clear_debug_win(GntWidget *w, GntTextView *tv)
 186 {
 187         gnt_text_view_clear(tv);
 188 }
 189
 190 static void
 191 print_stderr(const char *string)
 192 {
 193         g_printerr("%s", string);
 194 }
 195
 196 static void
 197 toggle_pause(GntWidget *w, gpointer n)
 198 {
 199         debug.paused = !debug.paused;
 200 }
 201
 202 /* Xerox */
 203 static void
 204 purple_glib_log_handler(const gchar *domain, GLogLevelFlags flags,
 205                                           const gchar *msg, gpointer user_data)
 206 {
 207         PurpleDebugLevel level;
 208         char *new_msg = NULL;
 209         char *new_domain = NULL;
 210
 211         if ((flags & G_LOG_LEVEL_ERROR) == G_LOG_LEVEL_ERROR)
 212                 level = PURPLE_DEBUG_ERROR;
 213         else if ((flags & G_LOG_LEVEL_CRITICAL) == G_LOG_LEVEL_CRITICAL)
 214                 level = PURPLE_DEBUG_FATAL;
 215         else if ((flags & G_LOG_LEVEL_WARNING) == G_LOG_LEVEL_WARNING)
 216                 level = PURPLE_DEBUG_WARNING;
 217         else if ((flags & G_LOG_LEVEL_MESSAGE) == G_LOG_LEVEL_MESSAGE)
 218                 level = PURPLE_DEBUG_INFO;
 219         else if ((flags & G_LOG_LEVEL_INFO) == G_LOG_LEVEL_INFO)
 220                 level = PURPLE_DEBUG_INFO;
 221         else if ((flags & G_LOG_LEVEL_DEBUG) == G_LOG_LEVEL_DEBUG)
 222                 level = PURPLE_DEBUG_MISC;
 223         else
 224         {
 225                 purple_debug_warning("gntdebug",
 226                                    "Unknown glib logging level in %d\n", flags);
 227
 228                 level = PURPLE_DEBUG_MISC; /* This will never happen. */
 229         }
 230
 231         if (msg != NULL)
 232                 new_msg = purple_utf8_try_convert(msg);
 233
 234         if (domain != NULL)
 235                 new_domain = purple_utf8_try_convert(domain);
 236
 237         if (new_msg != NULL)
 238         {
 239                 purple_debug(level, (new_domain != NULL ? new_domain : "g_log"),
 240                                    "%s\n", new_msg);
 241
 242                 g_free(new_msg);
 243         }
 244
 245         g_free(new_domain);
 246 }
 247
 248 static void
 249 size_changed_cb(GntWidget *widget, int oldw, int oldh)
 250 {
 251         int w, h;
 252         gnt_widget_get_size(widget, &w, &h);
 253         purple_prefs_set_int(PREF_ROOT "/size/width", w);
 254         purple_prefs_set_int(PREF_ROOT "/size/height", h);
 255 }
 256
 257 static gboolean
 258 for_real(gpointer entry)
 259 {
 260         purple_prefs_set_string(PREF_ROOT "/filter", gnt_entry_get_text(entry));
 261         return FALSE;
 262 }
 263
 264 static void
 265 update_filter_string(GntEntry *entry, gpointer null)
 266 {
 267         int id = g_timeout_add(1000, for_real, entry);
 268         g_object_set_data_full(G_OBJECT(entry), "update-filter", GINT_TO_POINTER(id),
 269                                         (GDestroyNotify)g_source_remove);
 270 }
 271
 272 static void
 273 file_save(GntFileSel *fs, const char *path, const char *file, GntTextView *tv)
 274 {
 275         FILE *fp;
 276
 277         if ((fp = g_fopen(path, "w+")) == NULL) {
 278                 purple_notify_error(NULL, NULL, _("Unable to open file."), NULL, NULL);
 279                 return;
 280         }
 281
 282         fprintf(fp, "Finch Debug Log : %s\n", purple_date_format_full(NULL));
 283         fprintf(fp, "%s", gnt_text_view_get_text(tv));
 284         fclose(fp);
 285         gnt_widget_destroy(GNT_WIDGET(fs));
 286 }
 287
 288 static void
 289 save_debug_win(GntWidget *w, GntTextView *tv)
 290 {
 291         GntWidget *window = gnt_file_sel_new();
 292         GntFileSel *sel = GNT_FILE_SEL(window);
 293         gnt_file_sel_set_current_location(sel, purple_home_dir());
 294         gnt_file_sel_set_suggested_filename(sel, "debug.txt");
 295         g_signal_connect(G_OBJECT(sel), "file_selected", G_CALLBACK(file_save), tv);
 296         g_signal_connect(G_OBJECT(sel), "cancelled", G_CALLBACK(gnt_widget_destroy), NULL);
 297         gnt_widget_show(window);
 298 }
 299
 300 void finch_debug_window_show()
 301 {
 302         GntWidget *wid, *box, *label;
 303
 304         debug.paused = FALSE;
 305         if (debug.window) {
 306                 gnt_window_present(debug.window);
 307                 return;
 308         }
 309
 310         debug.window = gnt_vbox_new(FALSE);
 311         gnt_box_set_toplevel(GNT_BOX(debug.window), TRUE);
 312         gnt_box_set_title(GNT_BOX(debug.window), _("Debug Window"));
 313         gnt_box_set_pad(GNT_BOX(debug.window), 0);
 314         gnt_box_set_alignment(GNT_BOX(debug.window), GNT_ALIGN_MID);
 315
 316         debug.tview = gnt_text_view_new();
 317         gnt_box_add_widget(GNT_BOX(debug.window), debug.tview);
 318         gnt_widget_set_size(debug.tview,
 319                         purple_prefs_get_int(PREF_ROOT "/size/width"),
 320                         purple_prefs_get_int(PREF_ROOT "/size/height"));
 321         g_signal_connect(G_OBJECT(debug.tview), "size_changed", G_CALLBACK(size_changed_cb), NULL);
 322
 323         gnt_box_add_widget(GNT_BOX(debug.window), gnt_line_new(FALSE));
 324
 325         box = gnt_hbox_new(FALSE);
 326         gnt_box_set_alignment(GNT_BOX(box), GNT_ALIGN_MID);
 327         gnt_box_set_fill(GNT_BOX(box), FALSE);
 328
 329         /* XXX: Setting the GROW_Y for the following widgets don't make sense. But right now
 330          * it's necessary to make the width of the debug window resizable ... like I said,
 331          * it doesn't make sense. The bug is likely in the packing in gntbox.c.
 332          */
 333         wid = gnt_button_new(_("Clear"));
 334         g_signal_connect(G_OBJECT(wid), "activate", G_CALLBACK(clear_debug_win), debug.tview);
 335         gnt_widget_set_grow_y(wid, TRUE);
 336         gnt_box_add_widget(GNT_BOX(box), wid);
 337
 338         wid = gnt_button_new(_("Save"));
 339         g_signal_connect(G_OBJECT(wid), "activate", G_CALLBACK(save_debug_win), debug.tview);
 340         gnt_widget_set_grow_y(wid, TRUE);
 341         gnt_box_add_widget(GNT_BOX(box), wid);
 342
 343         debug.search = gnt_entry_new(purple_prefs_get_string(PREF_ROOT "/filter"));
 344         label = gnt_label_new(_("Filter:"));
 345         gnt_widget_set_grow_x(label, FALSE);
 346         gnt_box_add_widget(GNT_BOX(box), label);
 347         gnt_box_add_widget(GNT_BOX(box), debug.search);
 348         g_signal_connect(G_OBJECT(debug.search), "text_changed", G_CALLBACK(update_filter_string), NULL);
 349
 350         wid = gnt_check_box_new(_("Pause"));
 351         g_signal_connect(G_OBJECT(wid), "toggled", G_CALLBACK(toggle_pause), NULL);
 352         gnt_widget_set_grow_y(wid, TRUE);
 353         gnt_box_add_widget(GNT_BOX(box), wid);
 354
 355         gnt_box_add_widget(GNT_BOX(debug.window), box);
 356         gnt_widget_set_grow_y(box, TRUE);
 357
 358         gnt_widget_set_name(debug.window, "debug-window");
 359
 360         g_signal_connect(G_OBJECT(debug.window), "destroy", G_CALLBACK(reset_debug_win), NULL);
 361         gnt_text_view_attach_scroll_widget(GNT_TEXT_VIEW(debug.tview), debug.window);
 362         gnt_text_view_attach_pager_widget(GNT_TEXT_VIEW(debug.tview), debug.window);
 363
 364         gnt_widget_show(debug.window);
 365 }
 366
 367 static gboolean
 368 start_with_debugwin(gpointer null)
 369 {
 370         finch_debug_window_show();
 371         return FALSE;
 372 }
 373
 374 static void
 375 finch_debug_ui_class_init(FinchDebugUiClass *klass)
 376 {
 377         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 378
 379         object_class->finalize = finch_debug_ui_finalize;
 380 }
 381
 382 static void
 383 finch_debug_ui_init(FinchDebugUi *self)
 384 {
 385 /* Xerox */
 386 #define REGISTER_G_LOG_HANDLER(name) \
 387         g_log_set_handler((name), G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL \
 388                                           | G_LOG_FLAG_RECURSION, \
 389                                           purple_glib_log_handler, NULL)
 390
 391         /* Register the glib log handlers. */
 392         REGISTER_G_LOG_HANDLER(NULL);
 393         REGISTER_G_LOG_HANDLER("GLib");
 394         REGISTER_G_LOG_HANDLER("GModule");
 395         REGISTER_G_LOG_HANDLER("GLib-GObject");
 396         REGISTER_G_LOG_HANDLER("GThread");
 397         REGISTER_G_LOG_HANDLER("Gnt");
 398 #ifdef USE_GSTREAMER
 399         REGISTER_G_LOG_HANDLER("GStreamer");
 400 #endif
 401         REGISTER_G_LOG_HANDLER("stderr");
 402
 403         g_set_print_handler(print_stderr);   /* Redirect the debug messages to stderr */
 404         if (!purple_debug_is_enabled())
 405                 handle_fprintf_stderr(FALSE);
 406
 407         purple_prefs_add_none(PREF_ROOT);
 408         purple_prefs_add_string(PREF_ROOT "/filter", "");
 409         purple_prefs_add_none(PREF_ROOT "/size");
 410         purple_prefs_add_int(PREF_ROOT "/size/width", 60);
 411         purple_prefs_add_int(PREF_ROOT "/size/height", 15);
 412
 413         if (purple_debug_is_enabled())
 414                 g_timeout_add(0, start_with_debugwin, NULL);
 415 }
 416
 417 static void
 418 finch_debug_ui_finalize(GObject *gobject)
 419 {
 420         handle_fprintf_stderr(TRUE);
 421         G_OBJECT_CLASS(finch_debug_ui_parent_class)->finalize(gobject);
 422 }
 423
 424 FinchDebugUi *
 425 finch_debug_ui_new(void)
 426 {
 427         return g_object_new(FINCH_TYPE_DEBUG_UI, NULL);
 428 }