src/logwindow.cc

   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 "logwindow.h"
  22
  23 #include <algorithm>
  24 #include <cstring>
  25 #include <deque>
  26 #include <string>
  27
  28 #include <gdk-pixbuf/gdk-pixbuf.h>
  29 #include <gdk/gdk.h>
  30 #include <glib-object.h>
  31 #include <gtk/gtk.h>
  32
  33 #include <config.h>
  34
  35 #include "compat.h"
  36 #include "debug.h"
  37 #include "intl.h"
  38 #include "layout.h"
  39 #include "main-defines.h"
  40 #include "misc.h"
  41 #include "options.h"
  42 #include "ui-misc.h"
  43 #include "window.h"
  44
  45 struct LogWindow
  46 {
  47         GtkWidget *window;
  48         GtkWidget *scrolledwin;
  49         GtkWidget *text;
  50         GtkTextTag *color_tags[LOG_COUNT];
  51         gint lines;
  52         GtkWidget *regexp_box;
  53         GtkWidget *bar;
  54         GtkWidget *pause;
  55         GtkWidget *wrap;
  56         GtkWidget *timer_data;
  57         GtkWidget *debug_level;
  58         gint debug_value; /**< Not used */
  59         GtkWidget *search_entry_box;
  60         gboolean highlight_all;
  61 };
  62
  63 enum LogWindowSearchDirection {
  64         LOGWINDOW_SEARCH_BACKWARDS,
  65         LOGWINDOW_SEARCH_FORWARDS
  66 };
  67
  68 static LogWindow *logwindow = nullptr;
  69
  70 static void hide_cb(GtkWidget *, LogWindow *)
  71 {
  72 }
  73
  74 /**
  75  * @brief Handle escape and F1 keys
  76  * @param UNUSED
  77  * @param event
  78  * @param logwin
  79  * @returns
  80  *
  81  * If escape key pressed, hide log window. \n
  82  * If no text selected, select the entire line. \n
  83  * If F1 pressed, execute command line program: \n
  84  * <options->log_window.action> <selected text>
  85  *
  86 */
  87 static gboolean key_pressed(GtkWidget *, GdkEventKey *event, LogWindow *logwin)
  88 {
  89         gchar *cmd_line;
  90         gchar *sel_text;
  91         GtkTextBuffer *buffer;
  92         GtkTextIter chr_end;
  93         GtkTextIter chr_marker;
  94         GtkTextIter chr_start;
  95         GtkTextIter cursor_iter;
  96         GtkTextIter line_end;
  97         GtkTextIter line_start;
  98         GtkTextMark *cursor_mark;
  99
 100         if (event && event->keyval == GDK_KEY_Escape)
 101                 gtk_widget_hide(logwin->window);
 102
 103         if (event && event->keyval == GDK_KEY_F1)
 104                 {
 105                 if (strlen(options->log_window.action) > 0)
 106                         {
 107                         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 108
 109                         if (!gtk_text_buffer_get_has_selection(buffer))
 110                                 {
 111                                 cursor_mark = gtk_text_buffer_get_insert(buffer);
 112                                 gtk_text_buffer_get_iter_at_mark(buffer, &cursor_iter, cursor_mark);
 113
 114                                 line_start = cursor_iter;
 115                                 gtk_text_iter_set_line_offset(&line_start, 0);
 116                                 line_end = cursor_iter;
 117                                 gtk_text_iter_forward_to_line_end(&line_end);
 118                                 chr_marker = line_end;
 119                                 gtk_text_buffer_select_range(buffer, &line_start, &line_end);
 120                                 }
 121
 122                         if (gtk_text_buffer_get_selection_bounds(gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text)), &chr_start, &chr_end))
 123                                 {
 124                                 sel_text = gtk_text_buffer_get_text( gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text)), &chr_start, &chr_end, FALSE);
 125
 126                                 cmd_line = g_strconcat(options->log_window.action, " \"", sel_text, "\"", NULL);
 127
 128                                 runcmd(cmd_line);
 129
 130                                 g_free(sel_text);
 131                                 g_free(cmd_line);
 132                                 }
 133                         }
 134                 }
 135
 136         return FALSE;
 137 }
 138
 139
 140 static void log_window_pause_cb(GtkWidget *, gpointer)
 141 {
 142         options->log_window.paused = !options->log_window.paused;
 143 }
 144
 145 static void log_window_line_wrap_cb(GtkWidget *, gpointer data)
 146 {
 147         auto logwin = static_cast<LogWindow *>(data);
 148
 149         options->log_window.line_wrap = !options->log_window.line_wrap;
 150
 151         if (options->log_window.line_wrap)
 152                 {
 153                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(logwin->text), GTK_WRAP_WORD);
 154                 }
 155         else
 156                 {
 157                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(logwin->text), GTK_WRAP_NONE);
 158                 }
 159 }
 160
 161 static void log_window_timer_data_cb(GtkWidget *, gpointer)
 162 {
 163         options->log_window.timer_data = !options->log_window.timer_data;
 164 }
 165
 166 static void log_window_regexp_cb(GtkWidget *text_entry, gpointer)
 167 {
 168         gchar *new_regexp;
 169
 170         new_regexp = g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(text_entry)));
 171         set_regexp(new_regexp);
 172         g_free(new_regexp);
 173 }
 174
 175 static void remove_green_bg(LogWindow *logwin)
 176 {
 177         GtkTextIter start_find;
 178         GtkTextIter start_match;
 179         GtkTextIter end_match;
 180         GtkTextBuffer *buffer;
 181         GSList *list;
 182         const gchar *text;
 183         gchar *tag_name;
 184         gint offset;
 185
 186         text = gq_gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 187         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 188         gtk_text_buffer_get_start_iter(buffer, &start_find);
 189
 190         while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, nullptr))
 191                 {
 192                 list = gtk_text_iter_get_tags(&start_match);
 193                 while (list)
 194                         {
 195                         g_object_get(list->data, "name", &tag_name, NULL);
 196                         if (g_strcmp0(tag_name, "green_bg") == 0)
 197                                 {
 198                                 gtk_text_buffer_remove_tag_by_name(buffer, "green_bg", &start_match, &end_match);
 199                                 }
 200                         list = list->next;
 201                         }
 202                 g_slist_free(list);
 203
 204                 offset = gtk_text_iter_get_offset(&end_match);
 205                 gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 206                 }
 207 }
 208
 209 static void search_activate_event(GtkEntry *, LogWindow *logwin)
 210 {
 211         GtkTextIter start_find;
 212         GtkTextIter start_match;
 213         GtkTextIter end_match;
 214         GtkTextBuffer *buffer;
 215         GtkTextMark *cursor_mark;
 216         GtkTextIter cursor_iter;
 217         const gchar *text;
 218         gint offset;
 219
 220         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 221         text = gq_gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 222
 223         if (logwin->highlight_all)
 224                 {
 225                 gtk_text_buffer_get_start_iter(buffer, &start_find);
 226
 227                 while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr))
 228                         {
 229                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 230                         offset = gtk_text_iter_get_offset(&end_match);
 231                         gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 232                         }
 233                 }
 234         else
 235                 {
 236                 cursor_mark = gtk_text_buffer_get_insert(buffer);
 237                 gtk_text_buffer_get_iter_at_mark(buffer, &cursor_iter, cursor_mark);
 238
 239                 if (gtk_text_iter_forward_search(&cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr))
 240                         {
 241                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 242                         }
 243                 }
 244 }
 245
 246 static gboolean search_keypress_event(GtkWidget *, GdkEventKey *, LogWindow *logwin, LogWindowSearchDirection direction)
 247 {
 248         GtkTextIter start_find;
 249         GtkTextIter start_match;
 250         GtkTextIter end_match;
 251         GtkTextIter start_sel;
 252         GtkTextIter end_sel;
 253         const gchar *text;
 254         GtkTextBuffer *buffer;
 255         GtkTextMark *cursor_mark;
 256         GtkTextIter cursor_iter;
 257         gint offset;
 258         gboolean match_found = FALSE;
 259         gboolean selected;
 260
 261         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 262         gtk_text_buffer_get_start_iter(buffer, &start_find);
 263
 264         text = gq_gtk_entry_get_text(GTK_ENTRY(logwin->search_entry_box));
 265         if (strlen(text) == 0)
 266                 {
 267                 selected = gtk_text_buffer_get_selection_bounds(buffer, &start_sel, &end_sel);
 268                 if (selected)
 269                         {
 270                         text = gtk_text_buffer_get_text(buffer, &start_sel, &end_sel, FALSE);
 271                         gq_gtk_entry_set_text(GTK_ENTRY(logwin->search_entry_box), text);
 272                         }
 273                 }
 274
 275         if (logwin->highlight_all)
 276                 {
 277                 while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr))
 278                         {
 279                         gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
 280                         offset = gtk_text_iter_get_offset(&end_match);
 281                         gtk_text_buffer_get_iter_at_offset(buffer, &start_find, offset);
 282                         }
 283                 }
 284
 285         cursor_mark = gtk_text_buffer_get_insert(buffer);
 286         gtk_text_buffer_get_iter_at_mark(buffer, &cursor_iter, cursor_mark);
 287
 288         if (direction == LOGWINDOW_SEARCH_BACKWARDS)
 289                 {
 290                 match_found = gtk_text_iter_backward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, nullptr);
 291                 }
 292         else
 293                 {
 294                 match_found = gtk_text_iter_forward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY,  &start_match, &end_match, nullptr);
 295                 }
 296
 297         if (match_found)
 298                 {
 299                 remove_green_bg(logwin);
 300
 301                 gtk_text_buffer_apply_tag_by_name(buffer, "green_bg",  &start_match, &end_match);
 302
 303                 if (direction == LOGWINDOW_SEARCH_BACKWARDS)
 304                         {
 305                         gtk_text_buffer_place_cursor(buffer, &start_match);
 306                         }
 307                 else
 308                         {
 309                         gtk_text_buffer_place_cursor(buffer, &end_match);
 310                         }
 311
 312                 cursor_mark = gtk_text_buffer_get_insert(buffer);
 313                 gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(logwin->text), cursor_mark, 0.2, FALSE, 0.0, 0.0);
 314         }
 315
 316         return FALSE;
 317 }
 318
 319 static gboolean backwards_keypress_event_cb(GtkWidget *widget, GdkEventKey *event, LogWindow *logwin)
 320 {
 321         search_keypress_event(widget, event, logwin, LOGWINDOW_SEARCH_BACKWARDS);
 322
 323         return FALSE;
 324 }
 325
 326 static gboolean forwards_keypress_event_cb(GtkWidget *widget, GdkEventKey *event, LogWindow *logwin)
 327 {
 328         search_keypress_event(widget, event, logwin, LOGWINDOW_SEARCH_FORWARDS);
 329
 330         return FALSE;
 331 }
 332
 333 static gboolean all_keypress_event_cb(GtkToggleButton *widget, LogWindow *logwin)
 334 {
 335         logwin->highlight_all = gtk_toggle_button_get_active(widget);
 336
 337         return FALSE;
 338 }
 339
 340 static gboolean debug_changed_cb(GtkSpinButton *widget, LogWindow *)
 341 {
 342         set_debug_level((gtk_spin_button_get_value(widget)));
 343
 344         return FALSE;
 345 }
 346
 347 static void search_entry_icon_cb(GtkEntry *, GtkEntryIconPosition pos, GdkEvent *, gpointer userdata)
 348 {
 349         auto logwin = static_cast<LogWindow *>(userdata);
 350         GtkTextIter start_find;
 351         GtkTextIter end_find;
 352         GtkTextBuffer *buffer;
 353
 354         if (pos == GTK_ENTRY_ICON_SECONDARY)
 355                 {
 356                 gq_gtk_entry_set_text(GTK_ENTRY(logwin->search_entry_box), "");
 357
 358                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 359                 gtk_text_buffer_get_start_iter(buffer, &start_find);
 360                 gtk_text_buffer_get_end_iter(buffer, &end_find);
 361                 gtk_text_buffer_remove_tag_by_name(buffer, "gray_bg", &start_find, &end_find);
 362                 gtk_text_buffer_remove_tag_by_name(buffer, "green_bg", &start_find, &end_find);
 363                 }
 364 }
 365
 366 static void filter_entry_icon_cb(GtkEntry *entry, GtkEntryIconPosition, GdkEvent *, gpointer)
 367 {
 368         const gchar *blank = "";
 369         gq_gtk_entry_set_text(entry, blank);
 370         set_regexp(blank);
 371 }
 372
 373 static LogWindow *log_window_create(LayoutWindow *lw)
 374 {
 375         LogWindow *logwin;
 376         GtkWidget *window;
 377         GtkWidget *scrolledwin;
 378         GtkWidget *text;
 379         GtkTextBuffer *buffer;
 380         GtkTextIter iter;
 381         GtkWidget *win_vbox;
 382         GtkWidget *textbox;
 383         GtkWidget *hbox;
 384         GtkWidget *label = nullptr;
 385         GtkWidget *search_box;
 386         GtkWidget *backwards_button;
 387         GtkWidget *forwards_button;
 388         GtkWidget *all_button;
 389         GtkIconTheme *theme;
 390         GdkPixbuf *pixbuf;
 391         GtkWidget *image = nullptr;
 392
 393         logwin = g_new0(LogWindow, 1);
 394
 395         window = window_new("log", nullptr, nullptr, _("Log"));
 396         DEBUG_NAME(window);
 397         win_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_SPACE);
 398         gq_gtk_container_add(GTK_WIDGET(window), win_vbox);
 399         gtk_widget_show(win_vbox);
 400
 401         gtk_window_resize(GTK_WINDOW(window), lw->options.log_window.width, lw->options.log_window.height);
 402         gq_gtk_window_move(GTK_WINDOW(window), lw->options.log_window.x, lw->options.log_window.y);
 403
 404         g_signal_connect(G_OBJECT(window), "delete_event",
 405                          G_CALLBACK(gtk_widget_hide_on_delete), NULL);
 406         g_signal_connect(G_OBJECT(window), "key_press_event",
 407                          G_CALLBACK(key_pressed), logwin);
 408         g_signal_connect(G_OBJECT(window), "hide",
 409                          G_CALLBACK(hide_cb), logwin);
 410         gtk_widget_realize(window);
 411
 412         scrolledwin = gq_gtk_scrolled_window_new(nullptr, nullptr);
 413         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 414                                        GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
 415         gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
 416                                             GTK_SHADOW_IN);
 417
 418         gq_gtk_box_pack_start(GTK_BOX(win_vbox), scrolledwin, TRUE, TRUE, 0);
 419         gtk_widget_show(scrolledwin);
 420
 421         text = gtk_text_view_new();
 422         gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
 423         if (options->log_window.line_wrap)
 424                 {
 425                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
 426                 }
 427         else
 428                 {
 429                 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_NONE);
 430                 }
 431         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
 432         gtk_text_buffer_get_start_iter(buffer, &iter);
 433         gtk_text_buffer_create_mark(buffer, "end", &iter, FALSE);
 434         gq_gtk_container_add(GTK_WIDGET(scrolledwin), text);
 435         gtk_widget_show(text);
 436
 437 #ifdef DEBUG
 438         gtk_text_buffer_create_tag(buffer, "gray_bg", "background", "gray", NULL);
 439         gtk_text_buffer_create_tag(buffer, "green_bg", "background", "#00FF00", NULL);
 440
 441         hbox = pref_box_new(win_vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
 442
 443         gtk_widget_show(hbox);
 444         logwin->debug_level = pref_spin_new_int(hbox, _("Debug level:"), nullptr, 0, 4, 1, get_debug_level(), &logwin->debug_value);
 445         g_signal_connect(logwin->debug_level, "value-changed", G_CALLBACK(debug_changed_cb), logwin);
 446
 447         logwin->pause = gtk_toggle_button_new();
 448         label = gtk_label_new("Pause");
 449         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->pause), _("Pause scrolling"));
 450         gq_gtk_container_add(GTK_WIDGET(logwin->pause), label) ;
 451         gq_gtk_box_pack_start(GTK_BOX(hbox),logwin->pause, FALSE, FALSE, 0) ;
 452         g_signal_connect(logwin->pause, "toggled", G_CALLBACK(log_window_pause_cb), logwin);
 453         gtk_widget_show_all(logwin->pause);
 454
 455         logwin->wrap = gtk_toggle_button_new();
 456         label = gtk_label_new("Wrap");
 457         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->wrap), _("Enable line wrap"));
 458         gq_gtk_container_add(GTK_WIDGET(logwin->wrap), label) ;
 459         gq_gtk_box_pack_start(GTK_BOX(hbox),logwin->wrap, FALSE, FALSE, 0) ;
 460         g_signal_connect(logwin->wrap, "toggled", G_CALLBACK(log_window_line_wrap_cb), logwin);
 461         gtk_widget_show_all(logwin->wrap);
 462
 463         logwin->timer_data = gtk_toggle_button_new();
 464         label = gtk_label_new(_("Timer"));
 465         gtk_widget_set_tooltip_text(GTK_WIDGET(logwin->timer_data), _("Enable timer data"));
 466         gq_gtk_container_add(GTK_WIDGET(logwin->timer_data), label) ;
 467         gq_gtk_box_pack_start(GTK_BOX(hbox),logwin->timer_data, FALSE, FALSE, 0) ;
 468         if (options->log_window.timer_data)
 469                 {
 470                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(logwin->timer_data), TRUE);
 471                 }
 472         g_signal_connect(logwin->timer_data, "toggled", G_CALLBACK(log_window_timer_data_cb), logwin);
 473         gtk_widget_show_all(logwin->timer_data);
 474
 475         search_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 476         gq_gtk_container_add(GTK_WIDGET(hbox), search_box);
 477         gtk_widget_show(search_box);
 478
 479         logwin->search_entry_box = gtk_entry_new();
 480         gq_gtk_box_pack_start(GTK_BOX(search_box), logwin->search_entry_box, FALSE, FALSE, 0);
 481         gtk_widget_show(logwin->search_entry_box);
 482         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(logwin->search_entry_box), GTK_ENTRY_ICON_PRIMARY, GQ_ICON_FIND);
 483         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(logwin->search_entry_box), GTK_ENTRY_ICON_SECONDARY, GQ_ICON_CLEAR);
 484         gtk_widget_show(search_box);
 485         gtk_widget_set_tooltip_text(logwin->search_entry_box, _("Search for text in log window"));
 486         g_signal_connect(logwin->search_entry_box, "icon-press", G_CALLBACK(search_entry_icon_cb), logwin);
 487         g_signal_connect(logwin->search_entry_box, "activate", G_CALLBACK(search_activate_event), logwin);
 488
 489         theme = gtk_icon_theme_get_default();
 490         pixbuf = gtk_icon_theme_load_icon(theme, GQ_ICON_PAN_UP, 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, nullptr);
 491         image = gtk_image_new_from_pixbuf(pixbuf);
 492         backwards_button = gtk_button_new();
 493         gtk_button_set_image(GTK_BUTTON(backwards_button), GTK_WIDGET(image));
 494         gtk_widget_set_tooltip_text(backwards_button, _("Search backwards"));
 495         gq_gtk_box_pack_start(GTK_BOX(search_box), backwards_button, FALSE, FALSE, 0);
 496         gtk_widget_show(backwards_button);
 497         g_signal_connect(backwards_button, "button_release_event", G_CALLBACK(backwards_keypress_event_cb), logwin);
 498         g_object_unref(pixbuf);
 499
 500         pixbuf = gtk_icon_theme_load_icon(theme, GQ_ICON_PAN_DOWN, 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, nullptr);
 501         image = gtk_image_new_from_pixbuf(pixbuf);
 502         forwards_button = gtk_button_new();
 503         gtk_button_set_image(GTK_BUTTON(forwards_button), GTK_WIDGET(image));
 504         gtk_widget_set_tooltip_text(forwards_button, _("Search forwards"));
 505         gq_gtk_box_pack_start(GTK_BOX(search_box), forwards_button, FALSE, FALSE, 0);
 506         gtk_widget_show(forwards_button);
 507         g_signal_connect(forwards_button, "button_release_event", G_CALLBACK(forwards_keypress_event_cb), logwin);
 508         g_object_unref(pixbuf);
 509
 510         pixbuf = gtk_icon_theme_load_icon(theme, "edit-select-all-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, nullptr);
 511         image = gtk_image_new_from_pixbuf(pixbuf);
 512         all_button = gtk_toggle_button_new();
 513         gtk_button_set_image(GTK_BUTTON(all_button), GTK_WIDGET(image));
 514         gtk_widget_set_tooltip_text(GTK_WIDGET(all_button), _("Highlight all"));
 515         gq_gtk_box_pack_start(GTK_BOX(search_box), all_button, FALSE, FALSE, 0) ;
 516         g_signal_connect(all_button, "toggled", G_CALLBACK(all_keypress_event_cb), logwin);
 517         gtk_widget_show_all(all_button);
 518         g_object_unref(pixbuf);
 519
 520         pref_label_new(hbox, _("Filter regexp"));
 521
 522         textbox = gtk_entry_new();
 523         gq_gtk_box_pack_start(GTK_BOX(hbox), textbox, FALSE, FALSE, 0);
 524         gtk_entry_set_icon_from_icon_name(GTK_ENTRY(textbox), GTK_ENTRY_ICON_SECONDARY, GQ_ICON_CLEAR);
 525         gtk_widget_show(textbox);
 526         g_signal_connect(G_OBJECT(textbox), "activate",
 527                          G_CALLBACK(log_window_regexp_cb), logwin);
 528         g_signal_connect(textbox, "icon-press", G_CALLBACK(filter_entry_icon_cb), logwin);
 529 #endif
 530
 531         logwin->window = window;
 532         logwin->scrolledwin = scrolledwin;
 533         logwin->text = text;
 534         logwin->lines = 1;
 535         logwin->regexp_box = textbox;
 536         lw->log_window = logwin->window;
 537         return logwin;
 538 }
 539
 540 static void log_window_init(LogWindow *logwin)
 541 {
 542         GtkTextBuffer *buffer;
 543
 544         g_assert(logwin != nullptr);
 545
 546         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 547
 548         logwin->color_tags[LOG_NORMAL] = gtk_text_buffer_create_tag (buffer,
 549                                                         "black_foreground", "foreground", "black",
 550                                                         "family", "MonoSpace", NULL);
 551         logwin->color_tags[LOG_MSG] = gtk_text_buffer_create_tag (buffer,
 552                                                         "blue_foreground", "foreground", "blue",
 553                                                         "family", "MonoSpace", NULL);
 554         logwin->color_tags[LOG_WARN] = gtk_text_buffer_create_tag (buffer,
 555                                                         "orange_foreground", "foreground", "orange",
 556                                                         "family", "MonoSpace", NULL);
 557         logwin->color_tags[LOG_ERROR] = gtk_text_buffer_create_tag (buffer,
 558                                                         "red_foreground", "foreground", "red",
 559                                                         "family", "MonoSpace", NULL);
 560 }
 561
 562 static void log_window_show(LogWindow *logwin)
 563 {
 564         GtkTextView *text = GTK_TEXT_VIEW(logwin->text);
 565         GtkTextBuffer *buffer;
 566         GtkTextMark *mark;
 567         gchar *regexp;
 568
 569         buffer = gtk_text_view_get_buffer(text);
 570         mark = gtk_text_buffer_get_mark(buffer, "end");
 571         gtk_text_view_scroll_mark_onscreen(text, mark);
 572
 573         gtk_window_present(GTK_WINDOW(logwin->window));
 574
 575         log_window_append("", LOG_NORMAL); // to flush memorized lines
 576
 577         regexp = g_strdup(get_regexp());
 578         if (regexp != nullptr)
 579                 {
 580                 gq_gtk_entry_set_text(GTK_ENTRY(logwin->regexp_box), regexp);
 581                 g_free(regexp);
 582                 }
 583 }
 584
 585 void log_window_new(LayoutWindow *lw)
 586 {
 587         if (logwindow == nullptr)
 588                 {
 589                 LogWindow *logwin;
 590
 591                 logwin = log_window_create(lw);
 592                 log_window_init(logwin);
 593                 logwindow = logwin;
 594                 }
 595
 596         log_window_show(logwindow);
 597 }
 598
 599 struct LogMsg {
 600         LogMsg() = default;
 601         LogMsg(const gchar *text, LogType type)
 602                 : text(text)
 603                 , type(type)
 604         {}
 605         std::string text;
 606         LogType type;
 607 };
 608
 609 static void log_window_insert_text(GtkTextBuffer *buffer, GtkTextIter *iter,
 610                                    const gchar *text, GtkTextTag *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(buffer, iter, str_utf8, -1, tag, NULL);
 618         g_free(str_utf8);
 619 }
 620
 621 void log_window_append(const gchar *str, LogType type)
 622 {
 623         GtkTextView *text;
 624         GtkTextBuffer *buffer;
 625         GtkTextIter iter;
 626         static std::deque<LogMsg> memory;
 627
 628         if (logwindow == nullptr)
 629                 {
 630                 if (*str)
 631                         {
 632                         memory.emplace_front(str, type);
 633
 634                         if (memory.size() >= static_cast<guint>(options->log_window_lines))
 635                                 {
 636                                 const auto count = std::max(options->log_window_lines - 1, 0);
 637
 638                                 memory.resize(count);
 639                                 }
 640                         }
 641                 return;
 642                 }
 643
 644         text = GTK_TEXT_VIEW(logwindow->text);
 645         buffer = gtk_text_view_get_buffer(text);
 646
 647         if (options->log_window_lines > 0 && logwindow->lines >= options->log_window_lines)
 648                 {
 649                 GtkTextIter start;
 650                 GtkTextIter end;
 651
 652                 gtk_text_buffer_get_start_iter(buffer, &start);
 653                 end = start;
 654                 gtk_text_iter_forward_lines(&end, logwindow->lines - options->log_window_lines);
 655                 gtk_text_buffer_delete(buffer, &start, &end);
 656                 }
 657
 658         gtk_text_buffer_get_end_iter(buffer, &iter);
 659
 660         std::for_each(memory.crbegin(), memory.crend(), [buffer, &iter](const LogMsg &oldest_msg)
 661                 {
 662                 log_window_insert_text(buffer, &iter, oldest_msg.text.c_str(), logwindow->color_tags[oldest_msg.type]);
 663                 });
 664         memory.clear();
 665
 666         log_window_insert_text(buffer, &iter, str, logwindow->color_tags[type]);
 667
 668         if (!options->log_window.paused)
 669                 {
 670                 if (gtk_widget_get_visible(GTK_WIDGET(text)))
 671                         {
 672                         GtkTextMark *mark;
 673
 674                         mark = gtk_text_buffer_get_mark(buffer, "end");
 675                         gtk_text_view_scroll_mark_onscreen(text, mark);
 676                         }
 677                 }
 678
 679         logwindow->lines = gtk_text_buffer_get_line_count(buffer);
 680 }
 681 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */