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