gint -> gboolean.
[geeqie.git] / src / ui_tree_edit.c
1 /*
2  * (SLIK) SimpLIstic sKin functions
3  * (C) 2004 John Ellis
4  * Copyright (C) 2008 - 2009 The Geeqie Team
5  *
6  * Author: John Ellis
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 #ifdef HAVE_CONFIG_H
14 #  include "config.h"
15 #endif
16 #include "intl.h"
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21
22 #include <gtk/gtk.h>
23 #include <gdk/gdkkeysyms.h>
24
25 #include "ui_tree_edit.h"
26
27 /*
28  *-------------------------------------------------------------------
29  * cell popup editor
30  *-------------------------------------------------------------------
31  */
32
33 static void tree_edit_close(TreeEditData *ted)
34 {
35         gtk_grab_remove(ted->window);
36         gdk_keyboard_ungrab(GDK_CURRENT_TIME);
37         gdk_pointer_ungrab(GDK_CURRENT_TIME);
38
39         gtk_widget_destroy(ted->window);
40
41         g_free(ted->old_name);
42         g_free(ted->new_name);
43         gtk_tree_path_free(ted->path);
44
45         g_free(ted);
46 }
47
48 static void tree_edit_do(TreeEditData *ted)
49 {
50         ted->new_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(ted->entry)));
51
52         if (strcmp(ted->new_name, ted->old_name) != 0)
53                 {
54                 if (ted->edit_func)
55                         {
56                         if (ted->edit_func(ted, ted->old_name, ted->new_name, ted->edit_data))
57                                 {
58                                 /* hmm, should the caller be required to set text instead ? */
59                                 }
60                         }
61                 }
62 }
63
64 static gint tree_edit_click_end_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
65 {
66         TreeEditData *ted = data;
67
68         tree_edit_do(ted);
69         tree_edit_close(ted);
70
71         return TRUE;
72 }
73
74 static gint tree_edit_click_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
75 {
76         TreeEditData *ted = data;
77
78         gint x, y;
79         gint w, h;
80
81         gint xr, yr;
82
83         xr = (gint)event->x_root;
84         yr = (gint)event->y_root;
85
86         gdk_window_get_origin(ted->window->window, &x, &y);
87         gdk_drawable_get_size(ted->window->window, &w, &h);
88
89         if (xr < x || yr < y || xr > x + w || yr > y + h)
90                 {
91                 /* gobble the release event, so it does not propgate to an underlying widget */
92                 g_signal_connect(G_OBJECT(ted->window), "button_release_event",
93                                  G_CALLBACK(tree_edit_click_end_cb), ted);
94                 return TRUE;
95                 }
96         return FALSE;
97 }
98
99 static gint tree_edit_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
100 {
101         TreeEditData *ted = data;
102
103         switch (event->keyval)
104                 {
105                 case GDK_Return:
106                 case GDK_KP_Enter:
107                 case GDK_Tab:           /* ok, we are going to intercept the focus change
108                                            from keyboard and act like return was hit */
109                 case GDK_ISO_Left_Tab:
110                 case GDK_Up:
111                 case GDK_Down:
112                 case GDK_KP_Up:
113                 case GDK_KP_Down:
114                 case GDK_KP_Left:
115                 case GDK_KP_Right:
116                         tree_edit_do(ted);
117                         tree_edit_close(ted);
118                         break;
119                 case GDK_Escape:
120                         tree_edit_close(ted);
121                         break;
122                 default:
123                         break;
124                 }
125
126         return FALSE;
127 }
128
129 static gboolean tree_edit_by_path_idle_cb(gpointer data)
130 {
131         TreeEditData *ted = data;
132         GdkRectangle rect;
133         gint x, y, w, h;        /* geometry of cell within tree */
134         gint wx, wy;            /* geometry of tree from root window */
135         gint sx, sw;
136
137         gtk_tree_view_get_cell_area(ted->tree, ted->path, ted->column, &rect);
138
139         x = rect.x;
140         y = rect.y;
141         w = rect.width + 4;
142         h = rect.height + 4;
143
144         if (gtk_tree_view_column_cell_get_position(ted->column, ted->cell, &sx, &sw))
145                 {
146                 x += sx;
147                 w = MAX(w - sx, sw);
148                 }
149
150         gdk_window_get_origin(gtk_tree_view_get_bin_window(ted->tree), &wx, &wy);
151
152         x += wx - 2; /* the -val is to 'fix' alignment of entry position */
153         y += wy - 2;
154
155         /* now show it */
156         gtk_widget_set_size_request(ted->window, w, h);
157         gtk_widget_realize(ted->window);
158         gtk_window_move(GTK_WINDOW(ted->window), x, y);
159         gtk_window_resize(GTK_WINDOW(ted->window), w, h);
160         gtk_widget_show(ted->window);
161
162         /* grab it */
163         gtk_widget_grab_focus(ted->entry);
164         /* explicitely set the focus flag for the entry, for some reason on popup windows this
165          * is not set, and causes no edit cursor to appear ( popups not allowed focus? )
166          */
167         GTK_WIDGET_SET_FLAGS(ted->entry, GTK_HAS_FOCUS);
168         gtk_grab_add(ted->window);
169         gdk_pointer_grab(ted->window->window, TRUE,
170                          GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK,
171                          NULL, NULL, GDK_CURRENT_TIME);
172         gdk_keyboard_grab(ted->window->window, TRUE, GDK_CURRENT_TIME);
173
174         return FALSE;
175 }
176
177 gint tree_edit_by_path(GtkTreeView *tree, GtkTreePath *tpath, gint column, const gchar *text,
178                        gint (*edit_func)(TreeEditData *, const gchar *, const gchar *, gpointer), gpointer data)
179 {
180         TreeEditData *ted;
181         GtkTreeViewColumn *tcolumn;
182         GtkCellRenderer *cell = NULL;
183         GList *list;
184         GList *work;
185
186         if (!edit_func) return FALSE;
187         if (!GTK_WIDGET_VISIBLE(tree)) return FALSE;
188
189         tcolumn = gtk_tree_view_get_column(tree, column);
190         if (!tcolumn) return FALSE;
191
192         list = gtk_tree_view_column_get_cell_renderers(tcolumn);
193         work = list;
194         while (work && !cell)
195                 {
196                 cell = work->data;
197                 if (!GTK_IS_CELL_RENDERER_TEXT(cell))
198                         {
199                         cell = NULL;
200                         }
201                 work = work->next;
202                 }
203
204         g_list_free(list);
205         if (!cell) return FALSE;
206
207         if (!text) text = "";
208
209         ted = g_new0(TreeEditData, 1);
210
211         ted->old_name = g_strdup(text);
212
213         ted->edit_func = edit_func;
214         ted->edit_data = data;
215
216         ted->tree = tree;
217         ted->path = gtk_tree_path_copy(tpath);
218         ted->column = tcolumn;
219         ted->cell = cell;
220
221         gtk_tree_view_scroll_to_cell(ted->tree, ted->path, ted->column, FALSE, 0.0, 0.0);
222
223         /* create the window */
224
225         ted->window = gtk_window_new(GTK_WINDOW_POPUP);
226         gtk_window_set_resizable(GTK_WINDOW(ted->window), FALSE);
227         g_signal_connect(G_OBJECT(ted->window), "button_press_event",
228                          G_CALLBACK(tree_edit_click_cb), ted);
229         g_signal_connect(G_OBJECT(ted->window), "key_press_event",
230                          G_CALLBACK(tree_edit_key_press_cb), ted);
231
232         ted->entry = gtk_entry_new();
233         gtk_entry_set_text(GTK_ENTRY(ted->entry), ted->old_name);
234         gtk_editable_select_region(GTK_EDITABLE(ted->entry), 0, strlen(ted->old_name));
235         gtk_container_add(GTK_CONTAINER(ted->window), ted->entry);
236         gtk_widget_show(ted->entry);
237
238         /* due to the fact that gtktreeview scrolls in an idle loop, we cannot
239          * reliably get the cell position until those scroll priority signals are processed
240          */
241         g_idle_add_full(G_PRIORITY_DEFAULT_IDLE - 2, tree_edit_by_path_idle_cb, ted, NULL);
242
243         return TRUE;
244 }
245
246 /*
247  *-------------------------------------------------------------------
248  * tree cell position retrieval
249  *-------------------------------------------------------------------
250  */
251
252 gint tree_view_get_cell_origin(GtkTreeView *widget, GtkTreePath *tpath, gint column, gint text_cell_only,
253                                gint *x, gint *y, gint *width, gint *height)
254 {
255         gint x_origin, y_origin;
256         gint x_offset, y_offset;
257         gint header_size;
258         GtkTreeViewColumn *tv_column;
259         GdkRectangle rect;
260
261         tv_column = gtk_tree_view_get_column(widget, column);
262         if (!tv_column || !tpath) return FALSE;
263
264         /* hmm, appears the rect will not account for X scroll, but does for Y scroll
265          * use x_offset instead for X scroll (sigh)
266          */
267         gtk_tree_view_get_cell_area(widget, tpath, tv_column, &rect);
268 #if GTK_CHECK_VERSION(2,12,0)
269         gtk_tree_view_convert_tree_to_widget_coords(widget, 0, 0, &x_offset, &y_offset);
270 #else
271         gtk_tree_view_tree_to_widget_coords(widget, 0, 0, &x_offset, &y_offset);
272 #endif
273         gdk_window_get_origin(GTK_WIDGET(widget)->window, &x_origin, &y_origin);
274
275         if (gtk_tree_view_get_headers_visible(widget))
276                 {
277                 header_size = tv_column->button->allocation.height;
278                 }
279         else
280                 {
281                 header_size = 0;
282                 }
283
284         if (text_cell_only)
285                 {
286                 GtkCellRenderer *cell = NULL;
287                 GList *renderers;
288                 GList *work;
289                 gint cell_x;
290                 gint cell_width;
291
292                 renderers = gtk_tree_view_column_get_cell_renderers(tv_column);
293                 work = renderers;
294                 while (work && !cell)
295                         {
296                         cell = work->data;
297                         work = work->next;
298                         if (!GTK_IS_CELL_RENDERER_TEXT(cell)) cell = NULL;
299                         }
300                 g_list_free(renderers);
301
302                 if (!cell) return FALSE;
303
304                 if (!gtk_tree_view_column_cell_get_position(tv_column, cell, &cell_x, &cell_width))
305                         {
306                         cell_x = 0;
307                         cell_width = rect.width;
308                         }
309                 *x = x_origin + x_offset + rect.x + cell_x;
310                 *width = cell_width;
311                 }
312         else
313                 {
314                 *x = x_origin + x_offset + rect.x;
315                 *width = rect.width;
316                 }
317         *y = y_origin + rect.y + header_size;
318         *height = rect.height;
319         return TRUE;
320 }
321
322 void tree_view_get_cell_clamped(GtkTreeView *widget, GtkTreePath *tpath, gint column, gint text_cell_only,
323                                 gint *x, gint *y, gint *width, gint *height)
324 {
325         gint wx, wy, ww, wh;
326         GdkWindow *window;
327
328         window = GTK_WIDGET(widget)->window;
329         gdk_window_get_origin(window, &wx, &wy);
330         gdk_drawable_get_size(window, &ww, &wh);
331         if (!tree_view_get_cell_origin(widget, tpath, column, text_cell_only, x,  y, width, height))
332                 {
333                 *x = wx;
334                 *y = wy;
335                 *width = ww;
336                 *height = wh;
337                 return;
338                 }
339
340         *width = MIN(*width, ww);
341         *x = CLAMP(*x, wx, wx + ww - (*width));
342         *y = CLAMP(*y, wy, wy + wh);
343         *height = MIN(*height, wy + wh - (*y));
344 }
345
346 gint tree_view_row_get_visibility(GtkTreeView *widget, GtkTreeIter *iter, gint fully_visible)
347 {
348         GtkTreeModel *store;
349         GtkTreePath *tpath;
350         gint cx, cy;
351
352         GdkRectangle vrect;
353         GdkRectangle crect;
354
355         if (!GTK_WIDGET_REALIZED(GTK_WIDGET(widget))) return -1; /* we will most probably scroll down, needed for tree_view_row_make_visible */
356
357         store = gtk_tree_view_get_model(widget);
358         tpath = gtk_tree_model_get_path(store, iter);
359
360         gtk_tree_view_get_visible_rect(widget, &vrect);
361         gtk_tree_view_get_cell_area(widget, tpath, NULL, &crect);
362         gtk_tree_path_free(tpath);
363
364
365 #if GTK_CHECK_VERSION(2,12,0)
366         gtk_tree_view_convert_widget_to_tree_coords(widget, crect.x, crect.y, &cx, &cy);
367 #else
368         gtk_tree_view_widget_to_tree_coords(widget, crect.x, crect.y, &cx, &cy);
369 #endif
370
371         if (fully_visible)
372                 {
373                 if (cy < vrect.y) return -1;
374                 if (cy + crect.height > vrect.y + vrect.height) return 1;
375                 return 0;
376                 }
377
378         if (cy + crect.height < vrect.y) return -1;
379         if (cy > vrect.y + vrect.height) return 1;
380         return 0;
381 }
382
383 gint tree_view_row_make_visible(GtkTreeView *widget, GtkTreeIter *iter, gint center)
384 {
385         GtkTreePath *tpath;
386         gint vis;
387
388         vis = tree_view_row_get_visibility(widget, iter, TRUE);
389
390         tpath = gtk_tree_model_get_path(gtk_tree_view_get_model(widget), iter);
391         if (center && vis != 0)
392                 {
393                 gtk_tree_view_scroll_to_cell(widget, tpath, NULL, TRUE, 0.5, 0.0);
394                 }
395         else if (vis < 0)
396                 {
397                 gtk_tree_view_scroll_to_cell(widget, tpath, NULL, TRUE, 0.0, 0.0);
398                 }
399         else if (vis > 0)
400                 {
401                 gtk_tree_view_scroll_to_cell(widget, tpath, NULL, TRUE, 1.0, 0.0);
402                 }
403         gtk_tree_path_free(tpath);
404
405         return vis;
406 }
407
408 gint tree_view_move_cursor_away(GtkTreeView *widget, GtkTreeIter *iter, gint only_selected)
409 {
410         GtkTreeModel *store;
411         GtkTreePath *tpath;
412         GtkTreePath *fpath;
413         gboolean move = FALSE;
414
415         if (!iter) return FALSE;
416
417         store = gtk_tree_view_get_model(widget);
418         tpath = gtk_tree_model_get_path(store, iter);
419         gtk_tree_view_get_cursor(widget, &fpath, NULL);
420
421         if (fpath && gtk_tree_path_compare(tpath, fpath) == 0)
422                 {
423                 GtkTreeSelection *selection;
424
425                 selection = gtk_tree_view_get_selection(widget);
426
427                 if (!only_selected ||
428                     gtk_tree_selection_path_is_selected(selection, tpath))
429                         {
430                         GtkTreeIter current;
431
432                         current = *iter;
433                         if (gtk_tree_model_iter_next(store, &current))
434                                 {
435                                 gtk_tree_path_next(tpath);
436                                 move = TRUE;
437                                 }
438                         else if (gtk_tree_path_prev(tpath) &&
439                                  gtk_tree_model_get_iter(store, &current, tpath))
440                                 {
441                                 move = TRUE;
442                                 }
443
444                         if (move)
445                                 {
446                                 gtk_tree_view_set_cursor(widget, tpath, NULL, FALSE);
447                                 }
448                         }
449                 }
450
451         gtk_tree_path_free(tpath);
452         if (fpath) gtk_tree_path_free(fpath);
453
454         return move;
455 }
456
457 gint tree_path_to_row(GtkTreePath *tpath)
458 {
459         gint *indices;
460
461         indices = gtk_tree_path_get_indices(tpath);
462         if (indices) return indices[0];
463
464         return -1;
465 }
466
467
468 /*
469  *-------------------------------------------------------------------
470  * color utilities
471  *-------------------------------------------------------------------
472  */
473
474 void shift_color(GdkColor *src, gshort val, gint direction)
475 {
476         gshort cs;
477
478         if (val == -1)
479                 {
480                 val = STYLE_SHIFT_STANDARD;
481                 }
482         else
483                 {
484                 val = CLAMP(val, 1, 100);
485                 }
486         cs = 0xffff / 100 * val;
487
488         /* up or down ? */
489         if (direction < 0 ||
490             (direction == 0 &&((gint)src->red + (gint)src->green + (gint)src->blue) / 3 > 0xffff / 2))
491                 {
492                 src->red = MAX(0 , src->red - cs);
493                 src->green = MAX(0 , src->green - cs);
494                 src->blue = MAX(0 , src->blue - cs);
495                 }
496         else
497                 {
498                 src->red = MIN(0xffff, src->red + cs);
499                 src->green = MIN(0xffff, src->green + cs);
500                 src->blue = MIN(0xffff, src->blue + cs);
501                 }
502 }
503
504 /* darkens or lightens a style's color for given state
505  * esp. useful for alternating dark/light in (c)lists
506  */
507 void style_shift_color(GtkStyle *style, GtkStateType type, gshort shift_value, gint direction)
508 {
509         if (!style) return;
510
511         shift_color(&style->base[type], shift_value, direction);
512         shift_color(&style->bg[type], shift_value, direction);
513 }
514
515 /*
516  *-------------------------------------------------------------------
517  * auto scroll by mouse position
518  *-------------------------------------------------------------------
519  */
520
521 #define AUTO_SCROLL_DEFAULT_SPEED 100
522 #define AUTO_SCROLL_DEFAULT_REGION 20
523
524 typedef struct _AutoScrollData AutoScrollData;
525 struct _AutoScrollData
526 {
527         gint timer_id;
528         gint region_size;
529         GtkWidget *widget;
530         GtkAdjustment *adj;
531         gint max_step;
532
533         gint (*notify_func)(GtkWidget *, gint, gint, gpointer);
534         gpointer notify_data;
535 };
536
537 void widget_auto_scroll_stop(GtkWidget *widget)
538 {
539         AutoScrollData *sd;
540
541         sd = g_object_get_data(G_OBJECT(widget), "autoscroll");
542         if (!sd) return;
543         g_object_set_data(G_OBJECT(widget), "autoscroll", NULL);
544
545         if (sd->timer_id != -1) g_source_remove(sd->timer_id);
546         g_free(sd);
547 }
548
549 static gint widget_auto_scroll_cb(gpointer data)
550 {
551         AutoScrollData *sd = data;
552         GdkWindow *window;
553         gint x, y;
554         gint w, h;
555         gint amt = 0;
556
557         if (sd->max_step < sd->region_size)
558                 {
559                 sd->max_step = MIN(sd->region_size, sd->max_step + 2);
560                 }
561
562         window = sd->widget->window;
563         gdk_window_get_pointer(window, &x, &y, NULL);
564         gdk_drawable_get_size(window, &w, &h);
565
566         if (x < 0 || x >= w || y < 0 || y >= h)
567                 {
568                 sd->timer_id = -1;
569                 widget_auto_scroll_stop(sd->widget);
570                 return FALSE;
571                 }
572
573         if (h < sd->region_size * 3)
574                 {
575                 /* height is cramped, nicely divide into three equal regions */
576                 if (y < h / 3 || y > h / 3 * 2)
577                         {
578                         amt = (y < h / 2) ? 0 - ((h / 2) - y) : y - (h / 2);
579                         }
580                 }
581         else if (y < sd->region_size)
582                 {
583                 amt = 0 - (sd->region_size - y);
584                 }
585         else if (y >= h - sd->region_size)
586                 {
587                 amt = y - (h - sd->region_size);
588                 }
589
590         if (amt != 0)
591                 {
592                 amt = CLAMP(amt, 0 - sd->max_step, sd->max_step);
593
594                 if (sd->adj->value != CLAMP(sd->adj->value + amt, sd->adj->lower, sd->adj->upper - sd->adj->page_size))
595                         {
596                         /* only notify when scrolling is needed */
597                         if (sd->notify_func && !sd->notify_func(sd->widget, x, y, sd->notify_data))
598                                 {
599                                 sd->timer_id = -1;
600                                 widget_auto_scroll_stop(sd->widget);
601                                 return FALSE;
602                                 }
603
604                         gtk_adjustment_set_value(sd->adj,
605                                 CLAMP(sd->adj->value + amt, sd->adj->lower, sd->adj->upper - sd->adj->page_size));
606                         }
607                 }
608
609         return TRUE;
610 }
611
612 gint widget_auto_scroll_start(GtkWidget *widget, GtkAdjustment *v_adj, gint scroll_speed, gint region_size,
613                               gint (*notify_func)(GtkWidget *widget, gint x, gint y, gpointer data), gpointer notify_data)
614 {
615         AutoScrollData *sd;
616
617         if (!widget || !v_adj) return 0;
618         if (g_object_get_data(G_OBJECT(widget), "autoscroll")) return 0;
619         if (scroll_speed < 1) scroll_speed = AUTO_SCROLL_DEFAULT_SPEED;
620         if (region_size < 1) region_size = AUTO_SCROLL_DEFAULT_REGION;
621
622         sd = g_new0(AutoScrollData, 1);
623         sd->widget = widget;
624         sd->adj = v_adj;
625         sd->region_size = region_size;
626         sd->max_step = 1;
627         sd->timer_id = g_timeout_add(scroll_speed, widget_auto_scroll_cb, sd);
628
629         sd->notify_func = notify_func;
630         sd->notify_data = notify_data;
631
632         g_object_set_data(G_OBJECT(widget), "autoscroll", sd);
633
634         return scroll_speed;
635 }
636
637
638 /*
639  *-------------------------------------------------------------------
640  * GList utils
641  *-------------------------------------------------------------------
642  */
643
644 GList *uig_list_insert_link(GList *list, GList *link, gpointer data)
645 {
646         GList *new_list;
647
648         if (!list || link == list) return g_list_prepend(list, data);
649         if (!link) return g_list_append(list, data);
650
651         new_list = g_list_alloc();
652         new_list->data = data;
653
654         if (link->prev)
655                 {
656                 link->prev->next = new_list;
657                 new_list->prev = link->prev;
658                 }
659         else
660                 {
661                 list = new_list;
662                 }
663         link->prev = new_list;
664         new_list->next = link;
665
666         return list;
667 }
668
669 GList *uig_list_insert_list(GList *parent, GList *insert_link, GList *list)
670 {
671         GList *end;
672
673         if (!insert_link) return g_list_concat(parent, list);
674         if (insert_link == parent) return g_list_concat(list, parent);
675         if (!parent) return list;
676         if (!list) return parent;
677
678         end  = g_list_last(list);
679
680         if (insert_link->prev) insert_link->prev->next = list;
681         list->prev = insert_link->prev;
682         insert_link->prev = end;
683         end->next = insert_link;
684
685         return parent;
686 }
687 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */