src/ui-tree-edit.cc

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