src/logwindow.c

   1 /*
   2  * Geeqie
   3  * Copyright (C) 2008 The Geeqie Team
   4  *
   5  * Author: Vladimir Nadvornik, Laurent Monin
   6  * based on logwindow.[ch] from Sylpheed 2.4.7 (C) Hiroyuki Yamamoto
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13 #include "main.h"
  14 #include "logwindow.h"
  15
  16 #include "window.h"
  17
  18 #include <gdk/gdkkeysyms.h>
  19
  20 #define TRIM_LINES      25
  21
  22
  23 typedef struct _LogWindow LogWindow;
  24
  25 struct _LogWindow
  26 {
  27         GtkWidget *window;
  28         GtkWidget *scrolledwin;
  29         GtkWidget *text;
  30
  31         GdkColor colors[LOG_COUNT];
  32
  33         gint lines;
  34 };
  35
  36 typedef struct _LogDef LogDef;
  37 struct _LogDef
  38 {
  39         LogType type;
  40         const gchar *tag;
  41         const gchar *color;
  42 };
  43
  44 /* Keep LogType order !! */
  45 static LogDef logdefs[LOG_COUNT] = {
  46         { LOG_NORMAL,   "normal",       "black"  },
  47         { LOG_MSG,      "message",      "blue"   },
  48         { LOG_WARN,     "warning",      "orange" },
  49         { LOG_ERROR,    "error",        "red"    },
  50 };
  51
  52 static LogWindow *logwindow = NULL;
  53
  54 static void hide_cb(GtkWidget *widget, LogWindow *logwin)
  55 {
  56 }
  57
  58 static gboolean key_pressed(GtkWidget *widget, GdkEventKey *event,
  59                             LogWindow *logwin)
  60 {
  61         if (event && event->keyval == GDK_Escape)
  62                 gtk_widget_hide(logwin->window);
  63         return FALSE;
  64 }
  65
  66 static LogWindow *log_window_create(void)
  67 {
  68         LogWindow *logwin;
  69         GtkWidget *window;
  70         GtkWidget *scrolledwin;
  71         GtkWidget *text;
  72         GtkTextBuffer *buffer;
  73         GtkTextIter iter;
  74
  75         logwin = g_new0(LogWindow, 1);
  76
  77         window = window_new(GTK_WINDOW_TOPLEVEL, "log", NULL, NULL, _("Log"));
  78         gtk_widget_set_size_request(window, 520, 400);
  79         g_signal_connect(G_OBJECT(window), "delete_event",
  80                          G_CALLBACK(gtk_widget_hide_on_delete), NULL);
  81         g_signal_connect(G_OBJECT(window), "key_press_event",
  82                          G_CALLBACK(key_pressed), logwin);
  83         g_signal_connect(G_OBJECT(window), "hide",
  84                          G_CALLBACK(hide_cb), logwin);
  85         gtk_widget_realize(window);
  86
  87         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
  88         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
  89                                        GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
  90         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
  91                                             GTK_SHADOW_IN);
  92         gtk_container_add(GTK_CONTAINER(window), scrolledwin);
  93         gtk_widget_show(scrolledwin);
  94
  95         text = gtk_text_view_new();
  96         gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
  97         gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
  98         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
  99         gtk_text_buffer_get_start_iter(buffer, &iter);
 100         gtk_text_buffer_create_mark(buffer, "end", &iter, FALSE);
 101         gtk_container_add(GTK_CONTAINER(scrolledwin), text);
 102         gtk_widget_show(text);
 103
 104         logwin->window = window;
 105         logwin->scrolledwin = scrolledwin;
 106         logwin->text = text;
 107         logwin->lines = 1;
 108
 109         return logwin;
 110 }
 111
 112 static void log_window_init(LogWindow *logwin)
 113 {
 114         GtkTextBuffer *buffer;
 115         GdkColormap *colormap;
 116         gboolean success[LOG_COUNT - 1];
 117         gint i;
 118
 119         g_assert(logwin != NULL);
 120         g_assert(logwin->colors != NULL);
 121
 122         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 123                 {
 124                 gboolean ok = gdk_color_parse(logdefs[i].color, &logwin->colors[i]);
 125                 if (ok == TRUE) continue;
 126
 127                 if (i == LOG_NORMAL) return;
 128                 memcpy(&logwin->colors[i], &logwin->colors[LOG_NORMAL], sizeof(GdkColor));
 129                 }
 130
 131         colormap = gdk_drawable_get_colormap(logwin->window->window);
 132         gdk_colormap_alloc_colors(colormap, logwin->colors, LOG_COUNT, FALSE, TRUE, success);
 133
 134         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 135                 {
 136                 if (success[i] == FALSE)
 137                         {
 138                         GtkStyle *style;
 139                         gint j;
 140
 141                         g_warning("LogWindow: color allocation failed\n");
 142                         style = gtk_widget_get_style(logwin->window);
 143                         for (j = LOG_NORMAL; j < LOG_COUNT; j++)
 144                                 logwin->colors[j] = style->black;
 145                         break;
 146                         }
 147                 }
 148
 149         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
 150         for (i = LOG_NORMAL; i < LOG_COUNT; i++)
 151                 gtk_text_buffer_create_tag(buffer, logdefs[i].tag,
 152                                            "foreground-gdk", &logwin->colors[i],
 153                                            NULL);
 154 }
 155
 156 static void log_window_show(LogWindow *logwin)
 157 {
 158         GtkTextView *text = GTK_TEXT_VIEW(logwin->text);
 159         GtkTextBuffer *buffer;
 160         GtkTextMark *mark;
 161
 162         g_assert(logwin != NULL);
 163
 164         buffer = gtk_text_view_get_buffer(text);
 165         mark = gtk_text_buffer_get_mark(buffer, "end");
 166         gtk_text_view_scroll_mark_onscreen(text, mark);
 167
 168         gtk_window_present(GTK_WINDOW(logwin->window));
 169 }
 170
 171
 172 void log_window_new(void)
 173 {
 174         if (logwindow == NULL)
 175                 {
 176                 LogWindow *logwin;
 177
 178                 logwin = log_window_create();
 179                 log_window_init(logwin);
 180                 logwindow = logwin;
 181                 }
 182
 183         log_window_show(logwindow);
 184 }
 185
 186 void log_window_append(const gchar *str, LogType type)
 187 {
 188         GtkTextView *text;
 189         GtkTextBuffer *buffer;
 190         GtkTextIter iter;
 191         gint line_limit = 1000; //FIXME: option
 192         gchar *str_utf8;
 193
 194         if (logwindow == NULL) return;
 195
 196         text = GTK_TEXT_VIEW(logwindow->text);
 197         buffer = gtk_text_view_get_buffer(text);
 198
 199         if (line_limit > 0 && logwindow->lines >= line_limit)
 200                 {
 201                 GtkTextIter start, end;
 202
 203                 gtk_text_buffer_get_start_iter(buffer, &start);
 204                 end = start;
 205                 gtk_text_iter_forward_lines(&end, TRIM_LINES);
 206                 gtk_text_buffer_delete(buffer, &start, &end);
 207                 logwindow->lines = gtk_text_buffer_get_line_count(buffer);
 208                 }
 209
 210         gtk_text_buffer_get_end_iter(buffer, &iter);
 211
 212         str_utf8 = utf8_validate_or_convert((gchar *)str);
 213         gtk_text_buffer_insert_with_tags_by_name
 214                         (buffer, &iter, str_utf8, -1, logdefs[type].tag, NULL);
 215
 216         if (GTK_WIDGET_VISIBLE(text))
 217                 {
 218                 GtkTextMark *mark;
 219
 220                 mark = gtk_text_buffer_get_mark(buffer, "end");
 221                 gtk_text_view_scroll_mark_onscreen(text, mark);
 222                 }
 223
 224         logwindow->lines++;
 225 }