src/logwindow.c

   1 /*
   2  * Copyright (C) 2008 - 2016 The Geeqie Team
   3  *
   4  * Authors: Vladimir Nadvornik, Laurent Monin
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include "main.h"
  22 #include "logwindow.h"
  23
  24 #include "misc.h"
  25 #include "secure_save.h"
  26 #include "ui_misc.h"
  27 #include "window.h"
  28
  29 #include <gdk/gdkkeysyms.h>
  30
  31
  32 typedef struct _LogWindow LogWindow;
  33
  34 struct _LogWindow
  35 {
  36         GtkWidget *window;
  37         GtkWidget *scrolledwin;
  38         GtkWidget *text;
  39
  40 #if !GTK_CHECK_VERSION(3,0,0)
  41         GdkColor colors[LOG_COUNT];
  42 #else
  43         GtkTextTag *color_tags[LOG_COUNT];
  44 #endif
  45
  46         guint lines;
  47         GtkWidget *regexp_box;
  48         GtkWidget *bar;
  49         GtkWidget *pause;
  50         GtkWidget *wrap;
  51         GtkWidget *timer_data;
  52         GtkWidget *debug_level;
  53         gint debug_value; /**< Not used */
  54         GtkWidget *search_entry_box;
  55         gboolean highlight_all;
  56 };
  57
  58 #if !GTK_CHECK_VERSION(3,0,0)
  59 typedef struct _LogDef LogDef;
  60 struct _LogDef
  61 {
  62         LogType type;
  63         const gchar *tag;
  64         const gchar *color;
  65 };
  66
  67 /* Keep LogType order !! */
  68 static LogDef logdefs[LOG_COUNT] = {
  69         { LOG_NORMAL,   "normal",       "black"  },
  70         { LOG_MSG,      "message",      "blue"   },
  71         { LOG_WARN,     "warning",      "orange" },
  72         { LOG_ERROR,    "error",        "red"    },
  73 };
  74 #endif
  75
  76 typedef enum {
  77         LOGWINDOW_SEARCH_BACKWARDS,
  78         LOGWINDOW_SEARCH_FORWARDS
  79 } LogWindowSearchDirection;
  80
  81 static LogWindow *logwindow = NULL;
  82
  83 static void hide_cb(GtkWidget *widget, LogWindow *logwin)
  84 {
  85 }
  86
  87 static gboolean key_pressed(GtkWidget *widget, GdkEventKey *event,
  88                             LogWindow *logwin)
  89 {
  90         if (event && event->keyval == GDK_KEY_Escape)
  91                 gtk_widget_hide(logwin->window);
  92         return FALSE;
  93 }
  94
  95
  96 static void log_window_pause_cb(GtkWidget *widget, gpointer data)
  97 {
  98         options->log_window.paused = !options->log_window.paused;
  99 }
 100
 101 static void log_window_line_wrap_cb(GtkWidget *widget, gpointer data)
 102 {
 103         LogWindow *logwin = data;
 104
 105         options->log_window.line_wrap = !options->log_window.line_wrap;
 106
 107         if (options->log_window.line_wrap)
 108                 {
 109                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(logwin->text), GTK_WRAP_WORD);
 110                 }
 111         else
 112                 {
 113                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(logwin->text), GTK_WRAP_NONE);
 114                 }
 115 }
 116
 117 static void log_window_timer_data_cb(GtkWidget *widget, gpointer data)
 118 {
 119         options->log_window.timer_data = !options->log_window.timer_data;
 120 }
 121
 122 static void log_window_regexp_cb(GtkWidget *text_entry, gpointer data)
 123 {
 124         gchar *new_regexp;
 125
 126         new_regexp = g_strdup(gtk_entry_get_text(GTK_ENTRY(text_entry)));
 127         set_regexp(new_regexp);
 128         g_free(new_regexp);
 129 }
 130
 131 static void log_window_debug_spin_cb(GtkSpinButton *debug_level, gpointer data)
 132 {
 133         set_debug_level(gtk_spin_button_get_value(debug_level));
 134 }
 135
 136 static void remove_green_bg(LogWindow *logwin)
 137 {
 138         GtkTextIter start_find;
 139         GtkTextIter start_match;
 140         GtkTextIter end_match;
 141         GtkTextBuffer *buffer;
 142         GSList *list;
 143         const gchar *text;
 144         gchar *tag_name;
 145         gint offset;
 146
 147         text = gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 148         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 149         gtk_text_buffer_get_start_iter(buffer, &start_find);
 150
 151         while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, NULL))
 152                 {
 153                 list = gtk_text_iter_get_tags(&start_match);
 154                 while (list)
 155                         {
 156                         g_object_get(list->data, "name", &tag_name, NULL);
 157                         if (g_strcmp0(tag_name, "green_bg") == 0)
 158                                 {
 159                                 gtk_text_buffer_remove_tag_by_name(buffer, "green_bg", &start_match, &end_match);
 160                                 }
 161                         list = list->next;
 162                         }
 163                 g_slist_free(list);
 164
 165                 offset = gtk_text_iter_get_offset(&end_match);
 166                 gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 167                 }
 168 }
 169
 170 static void search_activate_event(GtkEntry *widget, LogWindow *logwin)
 171 {
 172         GtkTextIter start_find;
 173         GtkTextIter start_match;
 174         GtkTextIter end_match;
 175         GtkTextBuffer *buffer;
 176         GtkTextMark *cursor_mark;
 177         GtkTextIter cursor_iter;
 178         const gchar *text;
 179         gint offset;
 180
 181         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 182         text = gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 183
 184         if (logwin->highlight_all)
 185                 {
 186                 gtk_text_buffer_get_start_iter(buffer, &start_find);
 187
 188                 while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
 189                         {
 190                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 191                         offset = gtk_text_iter_get_offset(&end_match);
 192                         gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 193                         }
 194                 }
 195         else
 196                 {
 197                 cursor_mark = gtk_text_buffer_get_insert(buffer);
 198                 gtk_text_buffer_get_iter_at_mark(buffer, &cursor_iter, cursor_mark);
 199
 200                 if (gtk_text_iter_forward_search(&cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
 201                         {
 202                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 203                         }
 204                 }
 205 }
 206
 207 static gboolean search_keypress_event(GtkWidget *widget, GdkEventKey *event, LogWindow *logwin, LogWindowSearchDirection direction)
 208 {
 209         GtkTextIter start_find;
 210         GtkTextIter start_match;
 211         GtkTextIter end_match;
 212         GtkTextIter start_sel;
 213         GtkTextIter end_sel;
 214         const gchar *text;
 215         GtkTextBuffer *buffer;
 216         GtkTextMark *cursor_mark;
 217         GtkTextIter cursor_iter;
 218         gint offset;
 219         gboolean match_found = FALSE;
 220         gboolean selected;
 221
 222         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 223         gtk_text_buffer_get_start_iter(buffer, &start_find);
 224
 225         text = gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 226         if (strlen(text) == 0)
 227                 {
 228                 selected = gtk_text_buffer_get_selection_bounds(buffer, &start_sel, &end_sel);
 229                 if (selected)
 230                         {
 231                         text = gtk_text_buffer_get_text(buffer, &start_sel, &end_sel, FALSE);
 232                         gtk_entry_set_text(GTK_ENTRY(logwin->search_entry_box), text);
 233                         }
 234                 }
 235
 236         if (logwin->highlight_all)
 237                 {
 238                 while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
 239                         {
 240                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 241                         offset = gtk_text_iter_get_offset(&end_match);
 242                         gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 243                         }
 244                 }
 245
 246         cursor_mark = gtk_text_buffer_get_insert(buffer);
 247         gtk_text_buffer_get_iter_at_mark(buffer, &cursor_iter, cursor_mark);
 248
 249         if (direction == LOGWINDOW_SEARCH_BACKWARDS)
 250                 {
 251                 match_found = gtk_text_iter_backward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, NULL);
 252                 }
 253         else
 254                 {
 255                 match_found = gtk_text_iter_forward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, NULL);
 256                 }
 257
 258         if (match_found)
 259                 {
 260                 remove_green_bg(logwin);
 261
 262                 gtk_text_buffer_apply_tag_by_name(buffer, "green_bg",  &start_match, &end_match);
 263
 264                 if (direction == LOGWINDOW_SEARCH_BACKWARDS)
 265                         {
 266                         gtk_text_buffer_place_cursor(buffer, &start_match);
 267                         }
 268                 else
 269                         {
 270                         gtk_text_buffer_place_cursor(buffer, &end_match);
 271                         }
 272
 273                 cursor_mark = gtk_text_buffer_get_insert(buffer);
 274                 gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(logwin->text), cursor_mark, 0.2, FALSE, 0.0, 0.0);
 275         }
 276
 277         return FALSE;
 278 }
 279
 280 static gboolean backwards_keypress_event_cb(GtkWidget *widget, GdkEventKey *event, LogWindow *logwin)
 281 {
 282         search_keypress_event(widget, event, logwin, LOGWINDOW_SEARCH_BACKWARDS);
 283
 284         return FALSE;
 285 }
 286
 287 static gboolean forwards_keypress_event_cb(GtkWidget *widget, GdkEventKey *event, LogWindow *logwin)
 288 {
 289         search_keypress_event(widget, event, logwin, LOGWINDOW_SEARCH_FORWARDS);
 290
 291         return FALSE;
 292 }
 293
 294 static gboolean all_keypress_event_cb(GtkToggleButton *widget, LogWindow *logwin)
 295 {
 296         logwin->highlight_all = gtk_toggle_button_get_active(widget);
 297
 298         return FALSE;
 299 }
 300
 301 static gboolean debug_changed_cb(GtkSpinButton *widget, LogWindow *logwin)
 302 {
 303         set_debug_level((gtk_spin_button_get_value(widget)));
 304
 305         return FALSE;
 306 }
 307
 308 static void search_entry_icon_cb(GtkEntry *entry, GtkEntryIconPosition pos, GdkEvent *event, gpointer userdata)
 309 {
 310         LogWindow *logwin = userdata;
 311         GtkTextIter start_find;
 312         GtkTextIter end_find;
 313         GtkTextBuffer *buffer;
 314
 315         if (pos == GTK_ENTRY_ICON_SECONDARY)
 316                 {
 317                 gtk_entry_set_text(GTK_ENTRY(logwin->search_entry_box), "");
 318
 319                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 320                 gtk_text_buffer_get_start_iter(buffer, &start_find);
 321                 gtk_text_buffer_get_end_iter(buffer, &end_find);
 322                 gtk_text_buffer_remove_tag_by_name(buffer, "gray_bg", &start_find, &end_find);
 323                 gtk_text_buffer_remove_tag_by_name(buffer, "green_bg", &start_find, &end_find);
 324                 }
 325 }
 326
 327 static void filter_entry_icon_cb(GtkEntry *entry, GtkEntryIconPosition pos, GdkEvent *event, gpointer userdata)
 328 {
 329         gtk_entry_set_text(entry, "");
 330         set_regexp("");
 331 }
 332
 333 static LogWindow *log_window_create(LayoutWindow *lw)
 334 {
 335         LogWindow *logwin;
 336         GtkWidget *window;
 337         GtkWidget *scrolledwin;
 338         GtkWidget *text;
 339         GtkTextBuffer *buffer;
 340         GtkTextIter iter;
 341         GtkWidget *win_vbox;
 342         GtkWidget *textbox;
 343         GtkWidget *hbox;
 344         GtkWidget *label = NULL;
 345         GtkWidget *search_box;
 346         GtkWidget *backwards_button;
 347         GtkWidget *forwards_button;
 348         GtkWidget *all_button;
 349         GtkIconTheme *theme;
 350         GdkPixbuf *pixbuf;
 351         GtkWidget *image = NULL;
 352
 353         logwin = g_new0(LogWindow, 1);
 354
 355         window = window_new(GTK_WINDOW_TOPLEVEL, "log", NULL, NULL, _("Log"));
 356         DEBUG_NAME(window);
 357         win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
 358         gtk_container_add(GTK_CONTAINER(window), win_vbox);
 359         gtk_widget_show(win_vbox);
 360
 361         gtk_window_resize(GTK_WINDOW(window), lw->options.log_window.w,
 362                                                                                         lw->options.log_window.h);
 363         gtk_window_move(GTK_WINDOW(window), lw->options.log_window.x, lw->options.log_window.y);
 364
 365         g_signal_connect(G_OBJECT(window), "delete_event",
 366                          G_CALLBACK(gtk_widget_hide_on_delete), NULL);
 367         g_signal_connect(G_OBJECT(window), "key_press_event",
 368                          G_CALLBACK(key_pressed), logwin);
 369         g_signal_connect(G_OBJECT(window), "hide",
 370                          G_CALLBACK(hide_cb), logwin);
 371         gtk_widget_realize(window);
 372
 373         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 374         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 375                                        GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
 376         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
 377                                             GTK_SHADOW_IN);
 378
 379         gtk_box_pack_start(GTK_BOX(win_vbox), scrolledwin, TRUE, TRUE, 0);
 380         gtk_widget_show(scrolledwin);
 381
 382         text = gtk_text_view_new();
 383         gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
 384         if (options->log_window.line_wrap)
 385                 {
 386                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
 387                 }
 388         else
 389                 {
 390                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_NONE);
 391                 }
 392         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
 393         gtk_text_buffer_get_start_iter(buffer, &iter);
 394         gtk_text_buffer_create_mark(buffer, "end", &iter, FALSE);
 395         gtk_container_add(GTK_CONTAINER(scrolledwin), text);
 396         gtk_widget_show(text);
 397
 398 #ifdef DEBUG
 399         gtk_text_buffer_create_tag(buffer, "gray_bg", "background", "gray", NULL);
 400         gtk_text_buffer_create_tag(buffer, "green_bg", "background", "#00FF00", NULL);
 401
 402         hbox = pref_box_new(win_vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
 403
 404         gtk_widget_show(hbox);
 405         logwin->debug_level = pref_spin_new_int(hbox, _("Debug level:"), NULL, 0, 4, 1, get_debug_level(), &logwin->debug_value);
 406         g_signal_connect(logwin->debug_level, "value-changed", G_CALLBACK(debug_changed_cb), logwin);
 407
 408         logwin->pause = gtk_toggle_button_new();
 409         label = gtk_label_new("Pause");
 410         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->pause), _("Pause scrolling"));
 411         gtk_container_add(GTK_CONTAINER(logwin->pause), label) ;
 412         gtk_box_pack_start(GTK_BOX(hbox),logwin->pause, FALSE, FALSE, 0) ;
 413         g_signal_connect(logwin->pause, "toggled", G_CALLBACK(log_window_pause_cb), logwin);
 414         gtk_widget_show_all(logwin->pause);
 415
 416         logwin->wrap = gtk_toggle_button_new();
 417         label = gtk_label_new("Wrap");
 418         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->wrap), _("Enable line wrap"));
 419         gtk_container_add(GTK_CONTAINER(logwin->wrap), label) ;
 420         gtk_box_pack_start(GTK_BOX(hbox),logwin->wrap, FALSE, FALSE, 0) ;
 421         g_signal_connect(logwin->wrap, "toggled", G_CALLBACK(log_window_line_wrap_cb), logwin);
 422         gtk_widget_show_all(logwin->wrap);
 423
 424         logwin->timer_data = gtk_toggle_button_new();
 425         label = gtk_label_new("Timer");
 426         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->timer_data), _("Enable timer data"));
 427         gtk_container_add(GTK_CONTAINER(logwin->timer_data), label) ;
 428         gtk_box_pack_start(GTK_BOX(hbox),logwin->timer_data, FALSE, FALSE, 0) ;
 429         if (options->log_window.timer_data)
 430                 {
 431                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(logwin->timer_data), TRUE);
 432                 }
 433         g_signal_connect(logwin->timer_data, "toggled", G_CALLBACK(log_window_timer_data_cb), logwin);
 434         gtk_widget_show_all(logwin->timer_data);
 435
 436         search_box = gtk_hbox_new(FALSE, 0);
 437         gtk_container_add(GTK_CONTAINER(hbox), search_box);
 438         gtk_widget_show(search_box);
 439
 440         logwin->search_entry_box = gtk_entry_new();
 441         gtk_box_pack_start(GTK_BOX(search_box), logwin->search_entry_box, FALSE, FALSE, 0);
 442         gtk_widget_show(logwin->search_entry_box);
 443         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(logwin->search_entry_box), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND);
 444         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(logwin->search_entry_box), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
 445         gtk_widget_show(search_box);
 446         gtk_widget_set_tooltip_text(logwin->search_entry_box, _("Search for text in log window"));
 447         g_signal_connect(logwin->search_entry_box, "icon-press", G_CALLBACK(search_entry_icon_cb), logwin);
 448         g_signal_connect(logwin->search_entry_box, "activate", G_CALLBACK(search_activate_event), logwin);
 449
 450         theme = gtk_icon_theme_get_default();
 451         pixbuf = gtk_icon_theme_load_icon(theme, "pan-up-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
 452         image = gtk_image_new_from_pixbuf(pixbuf);
 453         backwards_button = gtk_button_new();
 454         gtk_button_set_image(GTK_BUTTON(backwards_button), GTK_WIDGET(image));
 455         gtk_widget_set_tooltip_text(backwards_button, _("Search backwards"));
 456         gtk_box_pack_start(GTK_BOX(search_box), backwards_button, FALSE, FALSE, 0);
 457         gtk_widget_show(backwards_button);
 458         g_signal_connect(backwards_button, "button_release_event", G_CALLBACK(backwards_keypress_event_cb), logwin);
 459         g_object_unref(pixbuf);
 460
 461         pixbuf = gtk_icon_theme_load_icon(theme, "pan-down-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
 462         image = gtk_image_new_from_pixbuf(pixbuf);
 463         forwards_button = gtk_button_new();
 464         gtk_button_set_image(GTK_BUTTON(forwards_button), GTK_WIDGET(image));
 465         gtk_widget_set_tooltip_text(forwards_button, _("Search forwards"));
 466         gtk_box_pack_start(GTK_BOX(search_box), forwards_button, FALSE, FALSE, 0);
 467         gtk_widget_show(forwards_button);
 468         g_signal_connect(forwards_button, "button_release_event", G_CALLBACK(forwards_keypress_event_cb), logwin);
 469         g_object_unref(pixbuf);
 470
 471         pixbuf = gtk_icon_theme_load_icon(theme, "edit-select-all-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
 472         image = gtk_image_new_from_pixbuf(pixbuf);
 473         all_button = gtk_toggle_button_new();
 474         gtk_button_set_image(GTK_BUTTON(all_button), GTK_WIDGET(image));
 475         gtk_widget_set_tooltip_text(GTK_WIDGET(all_button), _("Highlight all"));
 476         gtk_box_pack_start(GTK_BOX(search_box), all_button, FALSE, FALSE, 0) ;
 477         g_signal_connect(all_button, "toggled", G_CALLBACK(all_keypress_event_cb), logwin);
 478         gtk_widget_show_all(all_button);
 479         g_object_unref(pixbuf);
 480
 481         pref_label_new(hbox, _("Filter regexp"));
 482
 483         textbox = gtk_entry_new();
 484         gtk_box_pack_start(GTK_BOX(hbox), textbox, FALSE, FALSE, 0);
 485         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(textbox), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
 486         gtk_widget_show(textbox);
 487         g_signal_connect(G_OBJECT(textbox), "activate",
 488                          G_CALLBACK(log_window_regexp_cb), logwin);
 489         g_signal_connect(textbox, "icon-press", G_CALLBACK(filter_entry_icon_cb), logwin);
 490 #endif
 491
 492         logwin->window = window;
 493         logwin->scrolledwin = scrolledwin;
 494         logwin->text = text;
 495         logwin->lines = 1;
 496         logwin->regexp_box = textbox;
 497         lw->log_window = logwin->window;
 498         return logwin;
 499 }
 500
 501 static void log_window_init(LogWindow *logwin)
 502 {
 503         GtkTextBuffer *buffer;
 504 #if !GTK_CHECK_VERSION(3,0,0)
 505         GdkColormap *colormap;
 506         gboolean success[LOG_COUNT];
 507         gint i;
 508
 509         g_assert(logwin != NULL);
 510         g_assert(logwin->colors != NULL);
 511         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 512                 {
 513                 gboolean ok = gdk_color_parse(logdefs[i].color, &logwin->colors[i]);
 514                 if (ok == TRUE) continue;
 515
 516                 if (i == LOG_NORMAL) return;
 517                 memcpy(&logwin->colors[i], &logwin->colors[LOG_NORMAL], sizeof(GdkColor));
 518                 }
 519
 520         colormap = gdk_drawable_get_colormap(gtk_widget_get_window(logwin->window));
 521         gdk_colormap_alloc_colors(colormap, logwin->colors, LOG_COUNT, FALSE, TRUE, success);
 522
 523         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 524                 {
 525                 if (success[i] == FALSE)
 526                         {
 527                         GtkStyle *style;
 528                         gint j;
 529
 530                         g_warning("LogWindow: color allocation failed\n");
 531                         style = gtk_widget_get_style(logwin->window);
 532                         for (j = LOG_NORMAL; j < LOG_COUNT; j++)
 533                                 logwin->colors[j] = style->black;
 534                         break;
 535                         }
 536                 }
 537
 538         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 539         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 540                 gtk_text_buffer_create_tag(buffer, logdefs[i].tag,
 541                                            "foreground-gdk", &logwin->colors[i],
 542                                            "family", "MonoSpace",
 543                                            NULL);
 544 #else
 545         g_assert(logwin != NULL);
 546
 547         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 548
 549         logwin->color_tags[LOG_NORMAL] = gtk_text_buffer_create_tag (buffer,
 550                                                         "black_foreground", "foreground", "black",
 551                                                         "family", "MonoSpace", NULL);
 552         logwin->color_tags[LOG_MSG] = gtk_text_buffer_create_tag (buffer,
 553                                                         "blue_foreground", "foreground", "blue",
 554                                                         "family", "MonoSpace", NULL);
 555         logwin->color_tags[LOG_WARN] = gtk_text_buffer_create_tag (buffer,
 556                                                         "orange_foreground", "foreground", "orange",
 557                                                         "family", "MonoSpace", NULL);
 558         logwin->color_tags[LOG_ERROR] = gtk_text_buffer_create_tag (buffer,
 559                                                         "red_foreground", "foreground", "red",
 560                                                         "family", "MonoSpace", NULL);
 561 #endif
 562 }
 563
 564 static void log_window_show(LogWindow *logwin)
 565 {
 566         GtkTextView *text = GTK_TEXT_VIEW(logwin->text);
 567         GtkTextBuffer *buffer;
 568         GtkTextMark *mark;
 569         gchar *regexp;
 570
 571         buffer = gtk_text_view_get_buffer(text);
 572         mark = gtk_text_buffer_get_mark(buffer, "end");
 573         gtk_text_view_scroll_mark_onscreen(text, mark);
 574
 575         gtk_window_present(GTK_WINDOW(logwin->window));
 576
 577         log_window_append("", LOG_NORMAL); // to flush memorized lines
 578
 579         regexp = g_strdup(get_regexp());
 580         if (regexp != NULL)
 581                 {
 582                 gtk_entry_set_text(GTK_ENTRY(logwin->regexp_box), regexp);
 583                 g_free(regexp);
 584                 }
 585 }
 586
 587 void log_window_new(LayoutWindow *lw)
 588 {
 589         if (logwindow == NULL)
 590                 {
 591                 LogWindow *logwin;
 592
 593                 logwin = log_window_create(lw);
 594                 log_window_init(logwin);
 595                 logwindow = logwin;
 596                 }
 597
 598         log_window_show(logwindow);
 599 }
 600
 601 typedef struct _LogMsg LogMsg;
 602
 603 struct _LogMsg {
 604         gchar *text;
 605         LogType type;
 606 };
 607
 608 #if !GTK_CHECK_VERSION(3,0,0)
 609 static void log_window_insert_text(GtkTextBuffer *buffer, GtkTextIter *iter,
 610                                    const gchar *text, const gchar *tag)
 611 {
 612         gchar *str_utf8;
 613
 614         if (!text || !*text) return;
 615
 616         str_utf8 = utf8_validate_or_convert(text);
 617         gtk_text_buffer_insert_with_tags_by_name(buffer, iter, str_utf8, -1, tag, NULL);
 618         g_free(str_utf8);
 619 }
 620 #else
 621 static void log_window_insert_text(GtkTextBuffer *buffer, GtkTextIter *iter,
 622                                    const gchar *text, GtkTextTag *tag)
 623 {
 624         gchar *str_utf8;
 625
 626         if (!text || !*text) return;
 627
 628         str_utf8 = utf8_validate_or_convert(text);
 629         gtk_text_buffer_insert_with_tags(buffer, iter, str_utf8, -1, tag, NULL);
 630         g_free(str_utf8);
 631 }
 632 #endif
 633
 634 void log_window_append(const gchar *str, LogType type)
 635 {
 636         GtkTextView *text;
 637         GtkTextBuffer *buffer;
 638         GtkTextIter iter;
 639         static GList *memory = NULL;
 640
 641         if (logwindow == NULL)
 642                 {
 643                 if (*str) {
 644                         LogMsg *msg = g_new(LogMsg, 1);
 645
 646                         msg->text = g_strdup(str);
 647                         msg->type = type;
 648
 649                         memory = g_list_prepend(memory, msg);
 650
 651                         while (g_list_length(memory) >= options->log_window_lines)
 652                                 {
 653                                 GList *work = g_list_last(memory);
 654                                 LogMsg *oldest_msg = work->data;
 655
 656                                 g_free(oldest_msg->text);
 657                                 memory = g_list_delete_link(memory, work);
 658                                 }
 659                         }
 660                 return;
 661                 }
 662
 663         text = GTK_TEXT_VIEW(logwindow->text);
 664         buffer = gtk_text_view_get_buffer(text);
 665
 666         if (options->log_window_lines > 0 && logwindow->lines >= options->log_window_lines)
 667                 {
 668                 GtkTextIter start, end;
 669
 670                 gtk_text_buffer_get_start_iter(buffer, &start);
 671                 end = start;
 672                 gtk_text_iter_forward_lines(&end, logwindow->lines - options->log_window_lines);
 673                 gtk_text_buffer_delete(buffer, &start, &end);
 674                 }
 675
 676         gtk_text_buffer_get_end_iter(buffer, &iter);
 677
 678         {
 679         GList *work = g_list_last(memory);
 680
 681         while (work)
 682                 {
 683                 GList *prev;
 684                 LogMsg *oldest_msg = work->data;
 685
 686 #if !GTK_CHECK_VERSION(3,0,0)
 687                 log_window_insert_text(buffer, &iter, oldest_msg->text, logdefs[oldest_msg->type].tag);
 688 #else
 689                 log_window_insert_text(buffer, &iter, oldest_msg->text,
 690                                                                         logwindow->color_tags[oldest_msg->type]);
 691 #endif
 692
 693                 prev = work->prev;
 694                 memory = g_list_delete_link(memory, work);
 695                 work = prev;
 696                 }
 697         }
 698
 699 #if !GTK_CHECK_VERSION(3,0,0)
 700         log_window_insert_text(buffer, &iter, str, logdefs[type].tag);
 701 #else
 702         log_window_insert_text(buffer, &iter, str, logwindow->color_tags[type]);
 703 #endif
 704
 705         if (!options->log_window.paused)
 706                 {
 707                 if (gtk_widget_get_visible(GTK_WIDGET(text)))
 708                         {
 709                         GtkTextMark *mark;
 710
 711                         mark = gtk_text_buffer_get_mark(buffer, "end");
 712                         gtk_text_view_scroll_mark_onscreen(text, mark);
 713                         }
 714                 }
 715
 716         logwindow->lines = gtk_text_buffer_get_line_count(buffer);
 717 }
 718 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */