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         gint 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 remove_green_bg(LogWindow *logwin)
 132 {
 133         GtkTextIter start_find;
 134         GtkTextIter start_match;
 135         GtkTextIter end_match;
 136         GtkTextBuffer *buffer;
 137         GSList *list;
 138         const gchar *text;
 139         gchar *tag_name;
 140         gint offset;
 141
 142         text = gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 143         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 144         gtk_text_buffer_get_start_iter(buffer, &start_find);
 145
 146         while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, NULL))
 147                 {
 148                 list = gtk_text_iter_get_tags(&start_match);
 149                 while (list)
 150                         {
 151                         g_object_get(list->data, "name", &tag_name, NULL);
 152                         if (g_strcmp0(tag_name, "green_bg") == 0)
 153                                 {
 154                                 gtk_text_buffer_remove_tag_by_name(buffer, "green_bg", &start_match, &end_match);
 155                                 }
 156                         list = list->next;
 157                         }
 158                 g_slist_free(list);
 159
 160                 offset = gtk_text_iter_get_offset(&end_match);
 161                 gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 162                 }
 163 }
 164
 165 static void search_activate_event(GtkEntry *widget, LogWindow *logwin)
 166 {
 167         GtkTextIter start_find;
 168         GtkTextIter start_match;
 169         GtkTextIter end_match;
 170         GtkTextBuffer *buffer;
 171         GtkTextMark *cursor_mark;
 172         GtkTextIter cursor_iter;
 173         const gchar *text;
 174         gint offset;
 175
 176         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 177         text = gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 178
 179         if (logwin->highlight_all)
 180                 {
 181                 gtk_text_buffer_get_start_iter(buffer, &start_find);
 182
 183                 while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
 184                         {
 185                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 186                         offset = gtk_text_iter_get_offset(&end_match);
 187                         gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 188                         }
 189                 }
 190         else
 191                 {
 192                 cursor_mark = gtk_text_buffer_get_insert(buffer);
 193                 gtk_text_buffer_get_iter_at_mark(buffer, &cursor_iter, cursor_mark);
 194
 195                 if (gtk_text_iter_forward_search(&cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
 196                         {
 197                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 198                         }
 199                 }
 200 }
 201
 202 static gboolean search_keypress_event(GtkWidget *widget, GdkEventKey *event, LogWindow *logwin, LogWindowSearchDirection direction)
 203 {
 204         GtkTextIter start_find;
 205         GtkTextIter start_match;
 206         GtkTextIter end_match;
 207         GtkTextIter start_sel;
 208         GtkTextIter end_sel;
 209         const gchar *text;
 210         GtkTextBuffer *buffer;
 211         GtkTextMark *cursor_mark;
 212         GtkTextIter cursor_iter;
 213         gint offset;
 214         gboolean match_found = FALSE;
 215         gboolean selected;
 216
 217         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 218         gtk_text_buffer_get_start_iter(buffer, &start_find);
 219
 220         text = gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 221         if (strlen(text) == 0)
 222                 {
 223                 selected = gtk_text_buffer_get_selection_bounds(buffer, &start_sel, &end_sel);
 224                 if (selected)
 225                         {
 226                         text = gtk_text_buffer_get_text(buffer, &start_sel, &end_sel, FALSE);
 227                         gtk_entry_set_text(GTK_ENTRY(logwin->search_entry_box), text);
 228                         }
 229                 }
 230
 231         if (logwin->highlight_all)
 232                 {
 233                 while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
 234                         {
 235                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 236                         offset = gtk_text_iter_get_offset(&end_match);
 237                         gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 238                         }
 239                 }
 240
 241         cursor_mark = gtk_text_buffer_get_insert(buffer);
 242         gtk_text_buffer_get_iter_at_mark(buffer, &cursor_iter, cursor_mark);
 243
 244         if (direction == LOGWINDOW_SEARCH_BACKWARDS)
 245                 {
 246                 match_found = gtk_text_iter_backward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, NULL);
 247                 }
 248         else
 249                 {
 250                 match_found = gtk_text_iter_forward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, NULL);
 251                 }
 252
 253         if (match_found)
 254                 {
 255                 remove_green_bg(logwin);
 256
 257                 gtk_text_buffer_apply_tag_by_name(buffer, "green_bg",  &start_match, &end_match);
 258
 259                 if (direction == LOGWINDOW_SEARCH_BACKWARDS)
 260                         {
 261                         gtk_text_buffer_place_cursor(buffer, &start_match);
 262                         }
 263                 else
 264                         {
 265                         gtk_text_buffer_place_cursor(buffer, &end_match);
 266                         }
 267
 268                 cursor_mark = gtk_text_buffer_get_insert(buffer);
 269                 gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(logwin->text), cursor_mark, 0.2, FALSE, 0.0, 0.0);
 270         }
 271
 272         return FALSE;
 273 }
 274
 275 static gboolean backwards_keypress_event_cb(GtkWidget *widget, GdkEventKey *event, LogWindow *logwin)
 276 {
 277         search_keypress_event(widget, event, logwin, LOGWINDOW_SEARCH_BACKWARDS);
 278
 279         return FALSE;
 280 }
 281
 282 static gboolean forwards_keypress_event_cb(GtkWidget *widget, GdkEventKey *event, LogWindow *logwin)
 283 {
 284         search_keypress_event(widget, event, logwin, LOGWINDOW_SEARCH_FORWARDS);
 285
 286         return FALSE;
 287 }
 288
 289 static gboolean all_keypress_event_cb(GtkToggleButton *widget, LogWindow *logwin)
 290 {
 291         logwin->highlight_all = gtk_toggle_button_get_active(widget);
 292
 293         return FALSE;
 294 }
 295
 296 static gboolean debug_changed_cb(GtkSpinButton *widget, LogWindow *logwin)
 297 {
 298         set_debug_level((gtk_spin_button_get_value(widget)));
 299
 300         return FALSE;
 301 }
 302
 303 static void search_entry_icon_cb(GtkEntry *entry, GtkEntryIconPosition pos, GdkEvent *event, gpointer userdata)
 304 {
 305         LogWindow *logwin = userdata;
 306         GtkTextIter start_find;
 307         GtkTextIter end_find;
 308         GtkTextBuffer *buffer;
 309
 310         if (pos == GTK_ENTRY_ICON_SECONDARY)
 311                 {
 312                 gtk_entry_set_text(GTK_ENTRY(logwin->search_entry_box), "");
 313
 314                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 315                 gtk_text_buffer_get_start_iter(buffer, &start_find);
 316                 gtk_text_buffer_get_end_iter(buffer, &end_find);
 317                 gtk_text_buffer_remove_tag_by_name(buffer, "gray_bg", &start_find, &end_find);
 318                 gtk_text_buffer_remove_tag_by_name(buffer, "green_bg", &start_find, &end_find);
 319                 }
 320 }
 321
 322 static void filter_entry_icon_cb(GtkEntry *entry, GtkEntryIconPosition pos, GdkEvent *event, gpointer userdata)
 323 {
 324         gtk_entry_set_text(entry, "");
 325         set_regexp("");
 326 }
 327
 328 static LogWindow *log_window_create(LayoutWindow *lw)
 329 {
 330         LogWindow *logwin;
 331         GtkWidget *window;
 332         GtkWidget *scrolledwin;
 333         GtkWidget *text;
 334         GtkTextBuffer *buffer;
 335         GtkTextIter iter;
 336         GtkWidget *win_vbox;
 337         GtkWidget *textbox;
 338         GtkWidget *hbox;
 339         GtkWidget *label = NULL;
 340         GtkWidget *search_box;
 341         GtkWidget *backwards_button;
 342         GtkWidget *forwards_button;
 343         GtkWidget *all_button;
 344         GtkIconTheme *theme;
 345         GdkPixbuf *pixbuf;
 346         GtkWidget *image = NULL;
 347
 348         logwin = g_new0(LogWindow, 1);
 349
 350         window = window_new(GTK_WINDOW_TOPLEVEL, "log", NULL, NULL, _("Log"));
 351         DEBUG_NAME(window);
 352         win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
 353         gtk_container_add(GTK_CONTAINER(window), win_vbox);
 354         gtk_widget_show(win_vbox);
 355
 356         gtk_window_resize(GTK_WINDOW(window), lw->options.log_window.w,
 357                                                                                         lw->options.log_window.h);
 358         gtk_window_move(GTK_WINDOW(window), lw->options.log_window.x, lw->options.log_window.y);
 359
 360         g_signal_connect(G_OBJECT(window), "delete_event",
 361                          G_CALLBACK(gtk_widget_hide_on_delete), NULL);
 362         g_signal_connect(G_OBJECT(window), "key_press_event",
 363                          G_CALLBACK(key_pressed), logwin);
 364         g_signal_connect(G_OBJECT(window), "hide",
 365                          G_CALLBACK(hide_cb), logwin);
 366         gtk_widget_realize(window);
 367
 368         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 369         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 370                                        GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
 371         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
 372                                             GTK_SHADOW_IN);
 373
 374         gtk_box_pack_start(GTK_BOX(win_vbox), scrolledwin, TRUE, TRUE, 0);
 375         gtk_widget_show(scrolledwin);
 376
 377         text = gtk_text_view_new();
 378         gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
 379         if (options->log_window.line_wrap)
 380                 {
 381                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
 382                 }
 383         else
 384                 {
 385                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_NONE);
 386                 }
 387         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
 388         gtk_text_buffer_get_start_iter(buffer, &iter);
 389         gtk_text_buffer_create_mark(buffer, "end", &iter, FALSE);
 390         gtk_container_add(GTK_CONTAINER(scrolledwin), text);
 391         gtk_widget_show(text);
 392
 393 #ifdef DEBUG
 394         gtk_text_buffer_create_tag(buffer, "gray_bg", "background", "gray", NULL);
 395         gtk_text_buffer_create_tag(buffer, "green_bg", "background", "#00FF00", NULL);
 396
 397         hbox = pref_box_new(win_vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
 398
 399         gtk_widget_show(hbox);
 400         logwin->debug_level = pref_spin_new_int(hbox, _("Debug level:"), NULL, 0, 4, 1, get_debug_level(), &logwin->debug_value);
 401         g_signal_connect(logwin->debug_level, "value-changed", G_CALLBACK(debug_changed_cb), logwin);
 402
 403         logwin->pause = gtk_toggle_button_new();
 404         label = gtk_label_new("Pause");
 405         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->pause), _("Pause scrolling"));
 406         gtk_container_add(GTK_CONTAINER(logwin->pause), label) ;
 407         gtk_box_pack_start(GTK_BOX(hbox),logwin->pause, FALSE, FALSE, 0) ;
 408         g_signal_connect(logwin->pause, "toggled", G_CALLBACK(log_window_pause_cb), logwin);
 409         gtk_widget_show_all(logwin->pause);
 410
 411         logwin->wrap = gtk_toggle_button_new();
 412         label = gtk_label_new("Wrap");
 413         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->wrap), _("Enable line wrap"));
 414         gtk_container_add(GTK_CONTAINER(logwin->wrap), label) ;
 415         gtk_box_pack_start(GTK_BOX(hbox),logwin->wrap, FALSE, FALSE, 0) ;
 416         g_signal_connect(logwin->wrap, "toggled", G_CALLBACK(log_window_line_wrap_cb), logwin);
 417         gtk_widget_show_all(logwin->wrap);
 418
 419         logwin->timer_data = gtk_toggle_button_new();
 420         label = gtk_label_new("Timer");
 421         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->timer_data), _("Enable timer data"));
 422         gtk_container_add(GTK_CONTAINER(logwin->timer_data), label) ;
 423         gtk_box_pack_start(GTK_BOX(hbox),logwin->timer_data, FALSE, FALSE, 0) ;
 424         if (options->log_window.timer_data)
 425                 {
 426                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(logwin->timer_data), TRUE);
 427                 }
 428         g_signal_connect(logwin->timer_data, "toggled", G_CALLBACK(log_window_timer_data_cb), logwin);
 429         gtk_widget_show_all(logwin->timer_data);
 430
 431         search_box = gtk_hbox_new(FALSE, 0);
 432         gtk_container_add(GTK_CONTAINER(hbox), search_box);
 433         gtk_widget_show(search_box);
 434
 435         logwin->search_entry_box = gtk_entry_new();
 436         gtk_box_pack_start(GTK_BOX(search_box), logwin->search_entry_box, FALSE, FALSE, 0);
 437         gtk_widget_show(logwin->search_entry_box);
 438         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(logwin->search_entry_box), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND);
 439         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(logwin->search_entry_box), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
 440         gtk_widget_show(search_box);
 441         gtk_widget_set_tooltip_text(logwin->search_entry_box, _("Search for text in log window"));
 442         g_signal_connect(logwin->search_entry_box, "icon-press", G_CALLBACK(search_entry_icon_cb), logwin);
 443         g_signal_connect(logwin->search_entry_box, "activate", G_CALLBACK(search_activate_event), logwin);
 444
 445         theme = gtk_icon_theme_get_default();
 446         pixbuf = gtk_icon_theme_load_icon(theme, "pan-up-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
 447         image = gtk_image_new_from_pixbuf(pixbuf);
 448         backwards_button = gtk_button_new();
 449         gtk_button_set_image(GTK_BUTTON(backwards_button), GTK_WIDGET(image));
 450         gtk_widget_set_tooltip_text(backwards_button, _("Search backwards"));
 451         gtk_box_pack_start(GTK_BOX(search_box), backwards_button, FALSE, FALSE, 0);
 452         gtk_widget_show(backwards_button);
 453         g_signal_connect(backwards_button, "button_release_event", G_CALLBACK(backwards_keypress_event_cb), logwin);
 454         g_object_unref(pixbuf);
 455
 456         pixbuf = gtk_icon_theme_load_icon(theme, "pan-down-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
 457         image = gtk_image_new_from_pixbuf(pixbuf);
 458         forwards_button = gtk_button_new();
 459         gtk_button_set_image(GTK_BUTTON(forwards_button), GTK_WIDGET(image));
 460         gtk_widget_set_tooltip_text(forwards_button, _("Search forwards"));
 461         gtk_box_pack_start(GTK_BOX(search_box), forwards_button, FALSE, FALSE, 0);
 462         gtk_widget_show(forwards_button);
 463         g_signal_connect(forwards_button, "button_release_event", G_CALLBACK(forwards_keypress_event_cb), logwin);
 464         g_object_unref(pixbuf);
 465
 466         pixbuf = gtk_icon_theme_load_icon(theme, "edit-select-all-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
 467         image = gtk_image_new_from_pixbuf(pixbuf);
 468         all_button = gtk_toggle_button_new();
 469         gtk_button_set_image(GTK_BUTTON(all_button), GTK_WIDGET(image));
 470         gtk_widget_set_tooltip_text(GTK_WIDGET(all_button), _("Highlight all"));
 471         gtk_box_pack_start(GTK_BOX(search_box), all_button, FALSE, FALSE, 0) ;
 472         g_signal_connect(all_button, "toggled", G_CALLBACK(all_keypress_event_cb), logwin);
 473         gtk_widget_show_all(all_button);
 474         g_object_unref(pixbuf);
 475
 476         pref_label_new(hbox, _("Filter regexp"));
 477
 478         textbox = gtk_entry_new();
 479         gtk_box_pack_start(GTK_BOX(hbox), textbox, FALSE, FALSE, 0);
 480         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(textbox), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
 481         gtk_widget_show(textbox);
 482         g_signal_connect(G_OBJECT(textbox), "activate",
 483                          G_CALLBACK(log_window_regexp_cb), logwin);
 484         g_signal_connect(textbox, "icon-press", G_CALLBACK(filter_entry_icon_cb), logwin);
 485 #endif
 486
 487         logwin->window = window;
 488         logwin->scrolledwin = scrolledwin;
 489         logwin->text = text;
 490         logwin->lines = 1;
 491         logwin->regexp_box = textbox;
 492         lw->log_window = logwin->window;
 493         return logwin;
 494 }
 495
 496 static void log_window_init(LogWindow *logwin)
 497 {
 498         GtkTextBuffer *buffer;
 499 #if !GTK_CHECK_VERSION(3,0,0)
 500         GdkColormap *colormap;
 501         gboolean success[LOG_COUNT];
 502         gint i;
 503
 504         g_assert(logwin != NULL);
 505         g_assert(logwin->colors != NULL);
 506         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 507                 {
 508                 gboolean ok = gdk_color_parse(logdefs[i].color, &logwin->colors[i]);
 509                 if (ok == TRUE) continue;
 510
 511                 if (i == LOG_NORMAL) return;
 512                 memcpy(&logwin->colors[i], &logwin->colors[LOG_NORMAL], sizeof(GdkColor));
 513                 }
 514
 515         colormap = gdk_drawable_get_colormap(gtk_widget_get_window(logwin->window));
 516         gdk_colormap_alloc_colors(colormap, logwin->colors, LOG_COUNT, FALSE, TRUE, success);
 517
 518         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 519                 {
 520                 if (success[i] == FALSE)
 521                         {
 522                         GtkStyle *style;
 523                         gint j;
 524
 525                         g_warning("LogWindow: color allocation failed\n");
 526                         style = gtk_widget_get_style(logwin->window);
 527                         for (j = LOG_NORMAL; j < LOG_COUNT; j++)
 528                                 logwin->colors[j] = style->black;
 529                         break;
 530                         }
 531                 }
 532
 533         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 534         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 535                 gtk_text_buffer_create_tag(buffer, logdefs[i].tag,
 536                                            "foreground-gdk", &logwin->colors[i],
 537                                            "family", "MonoSpace",
 538                                            NULL);
 539 #else
 540         g_assert(logwin != NULL);
 541
 542         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 543
 544         logwin->color_tags[LOG_NORMAL] = gtk_text_buffer_create_tag (buffer,
 545                                                         "black_foreground", "foreground", "black",
 546                                                         "family", "MonoSpace", NULL);
 547         logwin->color_tags[LOG_MSG] = gtk_text_buffer_create_tag (buffer,
 548                                                         "blue_foreground", "foreground", "blue",
 549                                                         "family", "MonoSpace", NULL);
 550         logwin->color_tags[LOG_WARN] = gtk_text_buffer_create_tag (buffer,
 551                                                         "orange_foreground", "foreground", "orange",
 552                                                         "family", "MonoSpace", NULL);
 553         logwin->color_tags[LOG_ERROR] = gtk_text_buffer_create_tag (buffer,
 554                                                         "red_foreground", "foreground", "red",
 555                                                         "family", "MonoSpace", NULL);
 556 #endif
 557 }
 558
 559 static void log_window_show(LogWindow *logwin)
 560 {
 561         GtkTextView *text = GTK_TEXT_VIEW(logwin->text);
 562         GtkTextBuffer *buffer;
 563         GtkTextMark *mark;
 564         gchar *regexp;
 565
 566         buffer = gtk_text_view_get_buffer(text);
 567         mark = gtk_text_buffer_get_mark(buffer, "end");
 568         gtk_text_view_scroll_mark_onscreen(text, mark);
 569
 570         gtk_window_present(GTK_WINDOW(logwin->window));
 571
 572         log_window_append("", LOG_NORMAL); // to flush memorized lines
 573
 574         regexp = g_strdup(get_regexp());
 575         if (regexp != NULL)
 576                 {
 577                 gtk_entry_set_text(GTK_ENTRY(logwin->regexp_box), regexp);
 578                 g_free(regexp);
 579                 }
 580 }
 581
 582 void log_window_new(LayoutWindow *lw)
 583 {
 584         if (logwindow == NULL)
 585                 {
 586                 LogWindow *logwin;
 587
 588                 logwin = log_window_create(lw);
 589                 log_window_init(logwin);
 590                 logwindow = logwin;
 591                 }
 592
 593         log_window_show(logwindow);
 594 }
 595
 596 typedef struct _LogMsg LogMsg;
 597
 598 struct _LogMsg {
 599         gchar *text;
 600         LogType type;
 601 };
 602
 603 #if !GTK_CHECK_VERSION(3,0,0)
 604 static void log_window_insert_text(GtkTextBuffer *buffer, GtkTextIter *iter,
 605                                    const gchar *text, const gchar *tag)
 606 {
 607         gchar *str_utf8;
 608
 609         if (!text || !*text) return;
 610
 611         str_utf8 = utf8_validate_or_convert(text);
 612         gtk_text_buffer_insert_with_tags_by_name(buffer, iter, str_utf8, -1, tag, NULL);
 613         g_free(str_utf8);
 614 }
 615 #else
 616 static void log_window_insert_text(GtkTextBuffer *buffer, GtkTextIter *iter,
 617                                    const gchar *text, GtkTextTag *tag)
 618 {
 619         gchar *str_utf8;
 620
 621         if (!text || !*text) return;
 622
 623         str_utf8 = utf8_validate_or_convert(text);
 624         gtk_text_buffer_insert_with_tags(buffer, iter, str_utf8, -1, tag, NULL);
 625         g_free(str_utf8);
 626 }
 627 #endif
 628
 629 void log_window_append(const gchar *str, LogType type)
 630 {
 631         GtkTextView *text;
 632         GtkTextBuffer *buffer;
 633         GtkTextIter iter;
 634         static GList *memory = NULL;
 635
 636         if (logwindow == NULL)
 637                 {
 638                 if (*str) {
 639                         LogMsg *msg = g_new(LogMsg, 1);
 640
 641                         msg->text = g_strdup(str);
 642                         msg->type = type;
 643
 644                         memory = g_list_prepend(memory, msg);
 645
 646                         while (g_list_length(memory) >= (guint)options->log_window_lines)
 647                                 {
 648                                 GList *work = g_list_last(memory);
 649                                 LogMsg *oldest_msg = work->data;
 650
 651                                 g_free(oldest_msg->text);
 652                                 memory = g_list_delete_link(memory, work);
 653                                 }
 654                         }
 655                 return;
 656                 }
 657
 658         text = GTK_TEXT_VIEW(logwindow->text);
 659         buffer = gtk_text_view_get_buffer(text);
 660
 661         if (options->log_window_lines > 0 && logwindow->lines >= options->log_window_lines)
 662                 {
 663                 GtkTextIter start, end;
 664
 665                 gtk_text_buffer_get_start_iter(buffer, &start);
 666                 end = start;
 667                 gtk_text_iter_forward_lines(&end, logwindow->lines - options->log_window_lines);
 668                 gtk_text_buffer_delete(buffer, &start, &end);
 669                 }
 670
 671         gtk_text_buffer_get_end_iter(buffer, &iter);
 672
 673         {
 674         GList *work = g_list_last(memory);
 675
 676         while (work)
 677                 {
 678                 GList *prev;
 679                 LogMsg *oldest_msg = work->data;
 680
 681 #if !GTK_CHECK_VERSION(3,0,0)
 682                 log_window_insert_text(buffer, &iter, oldest_msg->text, logdefs[oldest_msg->type].tag);
 683 #else
 684                 log_window_insert_text(buffer, &iter, oldest_msg->text,
 685                                                                         logwindow->color_tags[oldest_msg->type]);
 686 #endif
 687
 688                 prev = work->prev;
 689                 memory = g_list_delete_link(memory, work);
 690                 work = prev;
 691                 }
 692         }
 693
 694 #if !GTK_CHECK_VERSION(3,0,0)
 695         log_window_insert_text(buffer, &iter, str, logdefs[type].tag);
 696 #else
 697         log_window_insert_text(buffer, &iter, str, logwindow->color_tags[type]);
 698 #endif
 699
 700         if (!options->log_window.paused)
 701                 {
 702                 if (gtk_widget_get_visible(GTK_WIDGET(text)))
 703                         {
 704                         GtkTextMark *mark;
 705
 706                         mark = gtk_text_buffer_get_mark(buffer, "end");
 707                         gtk_text_view_scroll_mark_onscreen(text, mark);
 708                         }
 709                 }
 710
 711         logwindow->lines = gtk_text_buffer_get_line_count(buffer);
 712 }
 713 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */