src/bar_sort.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 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
  14 #include "main.h"
  15 #include "bar_sort.h"
  16
  17 #include "collect.h"
  18 #include "collect-io.h"
  19 #include "filedata.h"
  20 #include "history_list.h"
  21 #include "layout.h"
  22 #include "layout_image.h"
  23 #include "utilops.h"
  24 #include "editors.h"
  25 #include "ui_bookmark.h"
  26 #include "ui_fileops.h"
  27 #include "ui_menu.h"
  28 #include "ui_misc.h"
  29
  30
  31 /*
  32   *-------------------------------------------------------------------
  33   * sort bar
  34   *-------------------------------------------------------------------
  35   */
  36
  37 typedef enum {
  38         BAR_SORT_MODE_FOLDER = 0,
  39         BAR_SORT_MODE_COLLECTION,
  40         BAR_SORT_MODE_COUNT
  41 } SortModeType;
  42
  43 typedef enum {
  44         BAR_SORT_COPY = 0,
  45         BAR_SORT_MOVE,
  46         BAR_SORT_FILTER,
  47         BAR_SORT_ACTION_COUNT
  48 } SortActionType;
  49
  50 typedef enum {
  51         BAR_SORT_SELECTION_IMAGE = 0,
  52         BAR_SORT_SELECTION_SELECTED,
  53         BAR_SORT_SELECTION_COUNT
  54 } SortSelectionType;
  55
  56 typedef struct _SortData SortData;
  57 struct _SortData
  58 {
  59         GtkWidget *vbox;
  60         GtkWidget *bookmarks;
  61         LayoutWindow *lw;
  62
  63         FileDialog *dialog;
  64         GtkWidget *dialog_name_entry;
  65
  66         SortModeType mode;
  67         SortActionType action;
  68         const gchar *filter_key;
  69
  70         SortSelectionType selection;
  71
  72         GtkWidget *folder_group;
  73         GtkWidget *collection_group;
  74
  75         GtkWidget *add_button;
  76         GtkWidget *undo_button;
  77         SortActionType undo_action;
  78         GList *undo_src_list;
  79         gchar *undo_src;
  80         gchar *undo_dest;
  81 };
  82
  83
  84 #define SORT_KEY_FOLDERS     "sort_manager"
  85 #define SORT_KEY_COLLECTIONS "sort_manager_collections"
  86
  87
  88 static void bar_sort_undo_set(SortData *sd, GList *src_list, FileData *src, const gchar *dest);
  89 static void bar_sort_add_close(SortData *sd);
  90
  91
  92 static void bar_sort_collection_list_build(GtkWidget *bookmarks)
  93 {
  94         FileData *dir_fd;
  95         GList *list;
  96         GList *work;
  97
  98         history_list_free_key(SORT_KEY_COLLECTIONS);
  99         bookmark_list_set_key(bookmarks, SORT_KEY_COLLECTIONS);
 100
 101         dir_fd = file_data_new_simple(get_collections_dir());
 102         filelist_read(dir_fd, &list, NULL);
 103         file_data_unref(dir_fd);
 104
 105         list = filelist_sort_path(list);
 106
 107         work = list;
 108         while (work)
 109                 {
 110                 FileData *fd;
 111                 gchar *name;
 112
 113                 fd = work->data;
 114                 work = work->next;
 115
 116                 if (file_extension_match(fd->path, GQ_COLLECTION_EXT))
 117                         {
 118                         name = remove_extension_from_path(fd->name);
 119                         }
 120                 else
 121                         {
 122                         name = g_strdup(fd->name);
 123                         }
 124                 bookmark_list_add(bookmarks, name, fd->path);
 125                 g_free(name);
 126                 }
 127
 128         filelist_free(list);
 129 }
 130
 131 static void bar_sort_mode_sync(SortData *sd, SortModeType mode)
 132 {
 133         gint folder_mode;
 134
 135         if (sd->mode == mode) return;
 136         sd->mode = mode;
 137
 138         folder_mode = (sd->mode == BAR_SORT_MODE_FOLDER);
 139
 140         bookmark_list_set_no_defaults(sd->bookmarks, !folder_mode);
 141         bookmark_list_set_editable(sd->bookmarks, folder_mode);
 142         bookmark_list_set_only_directories(sd->bookmarks, folder_mode);
 143
 144         if (folder_mode)
 145                 {
 146                 gtk_widget_hide(sd->collection_group);
 147                 gtk_widget_show(sd->folder_group);
 148                 bookmark_list_set_key(sd->bookmarks, SORT_KEY_FOLDERS);
 149                 }
 150         else
 151                 {
 152                 gtk_widget_hide(sd->folder_group);
 153                 gtk_widget_show(sd->collection_group);
 154                 bar_sort_collection_list_build(sd->bookmarks);
 155                 }
 156
 157         bar_sort_add_close(sd);
 158
 159         bar_sort_undo_set(sd, NULL, NULL, NULL);
 160 }
 161
 162 static void bar_sort_mode_cb(GtkWidget *combo, gpointer data)
 163 {
 164         SortData *sd = data;
 165
 166         if (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) == BAR_SORT_MODE_FOLDER)
 167                 {
 168                 bar_sort_mode_sync(sd, BAR_SORT_MODE_FOLDER);
 169                 }
 170         else
 171                 {
 172                 bar_sort_mode_sync(sd, BAR_SORT_MODE_COLLECTION);
 173                 }
 174         options->panels.sort.mode_state = sd->mode;
 175 }
 176
 177 /* this takes control of src_list */
 178 static void bar_sort_undo_set(SortData *sd, GList *src_list, FileData *src, const gchar *dest)
 179 {
 180         string_list_free(sd->undo_src_list);
 181         sd->undo_src_list = filelist_to_path_list(src_list);
 182
 183         g_free(sd->undo_src);
 184         sd->undo_src = src ? g_strdup(src->path) : NULL;
 185         g_free(sd->undo_dest);
 186         sd->undo_dest = g_strdup(dest);
 187
 188         sd->undo_action = sd->action;
 189
 190         if (sd->undo_button)
 191                 {
 192                 gtk_widget_set_sensitive(sd->undo_button,
 193                                          ((sd->undo_src_list || sd->undo_src) && sd->undo_dest) );
 194                 }
 195 }
 196
 197 static void bar_sort_undo_folder(SortData *sd, GtkWidget *button)
 198 {
 199         if (!sd->undo_src || !sd->undo_dest) return;
 200
 201         switch (sd->undo_action)
 202                 {
 203                 case BAR_SORT_MOVE:
 204                         {
 205                         GList *list;
 206                         gchar *src_dir;
 207
 208                         list = g_list_append(NULL, file_data_new_simple(sd->undo_dest));
 209                         src_dir = remove_level_from_path(sd->undo_src);
 210                         file_util_move_simple(list, src_dir, sd->lw->window);
 211                         g_free(src_dir);
 212                         }
 213                         break;
 214                 case BAR_SORT_COPY:
 215                         file_util_delete(file_data_new_simple(sd->undo_dest), NULL, button);
 216                         break;
 217                 default:
 218                         /* undo external command */
 219                         file_util_delete(file_data_new_simple(sd->undo_dest), NULL, button);
 220                         break;
 221                 }
 222
 223         layout_refresh(sd->lw);
 224
 225         if (isfile(sd->undo_src))
 226                 {
 227                 layout_image_set_fd(sd->lw, file_data_new_simple(sd->undo_src));
 228                 }
 229
 230         bar_sort_undo_set(sd, NULL, NULL, NULL);
 231 }
 232
 233 static void bar_sort_undo_collection(SortData *sd)
 234 {
 235         GList *work;
 236
 237         work = sd->undo_src_list;
 238         while (work)
 239                 {
 240                 gchar *source;
 241
 242                 source = work->data;
 243                 work = work->next;
 244                 collect_manager_remove(file_data_new_simple(source), sd->undo_dest);
 245                 }
 246
 247         bar_sort_undo_set(sd, NULL, NULL, NULL);
 248 }
 249
 250 static void bar_sort_undo_cb(GtkWidget *button, gpointer data)
 251 {
 252         SortData *sd = data;
 253
 254         if (sd->mode == BAR_SORT_MODE_FOLDER)
 255                 {
 256                 bar_sort_undo_folder(sd, button);
 257                 }
 258         else
 259                 {
 260                 bar_sort_undo_collection(sd);
 261                 }
 262 }
 263
 264 static void bar_sort_bookmark_select_folder(SortData *sd, FileData *source, const gchar *path)
 265 {
 266         GList *list;
 267         gchar *dest_path;
 268
 269         if (!isdir(path)) return;
 270
 271         dest_path = g_build_filename(path, source->name, NULL);
 272         bar_sort_undo_set(sd, NULL, source, dest_path);
 273
 274         list = g_list_append(NULL, file_data_ref(source));
 275
 276         switch (sd->action)
 277                 {
 278                 case BAR_SORT_COPY:
 279                         file_util_copy_simple(list, path, sd->lw->window);
 280                         list = NULL;
 281                         layout_image_next(sd->lw);
 282                         break;
 283                 case BAR_SORT_MOVE:
 284                         file_util_move_simple(list, path, sd->lw->window);
 285                         list = NULL;
 286                         break;
 287                 case BAR_SORT_FILTER:
 288                         file_util_start_filter_from_filelist(sd->filter_key, list, path, sd->lw->window);
 289                         list = NULL;
 290                         layout_image_next(sd->lw);
 291                         break;
 292                 default:
 293                         break;
 294                 }
 295
 296         g_list_free(list);
 297         g_free(dest_path);
 298 }
 299
 300 static void bar_sort_bookmark_select_collection(SortData *sd, FileData *source, const gchar *path)
 301 {
 302         GList *list = NULL;
 303
 304         switch (sd->selection)
 305                 {
 306                 case BAR_SORT_SELECTION_IMAGE:
 307                         list = g_list_append(NULL, file_data_ref(source));
 308                         break;
 309                 case BAR_SORT_SELECTION_SELECTED:
 310                         list = layout_selection_list(sd->lw);
 311                         break;
 312                 default:
 313                         break;
 314                 }
 315
 316         if (!list)
 317                 {
 318                 bar_sort_undo_set(sd, NULL, NULL, NULL);
 319                 return;
 320                 }
 321
 322         bar_sort_undo_set(sd, list, NULL, path);
 323
 324         while (list)
 325                 {
 326                 FileData *image_fd;
 327
 328                 image_fd = list->data;
 329                 list = list->next;
 330                 collect_manager_add(image_fd, path);
 331                 }
 332 }
 333
 334 static void bar_sort_bookmark_select(const gchar *path, gpointer data)
 335 {
 336         SortData *sd = data;
 337         FileData *source;
 338
 339         source = layout_image_get_fd(sd->lw);
 340         if (!path || !source) return;
 341
 342         if (sd->mode == BAR_SORT_MODE_FOLDER)
 343                 {
 344                 bar_sort_bookmark_select_folder(sd, source, path);
 345                 }
 346         else
 347                 {
 348                 bar_sort_bookmark_select_collection(sd, source, path);
 349                 }
 350 }
 351
 352 static void bar_sort_set_action(SortData *sd, SortActionType action, const gchar *filter_key)
 353 {
 354         options->panels.sort.action_state = sd->action = action;
 355         if (action == BAR_SORT_FILTER)
 356                 {
 357                 if (!filter_key) filter_key = "";
 358                 sd->filter_key = filter_key;
 359                 g_free(options->panels.sort.action_filter);
 360                 options->panels.sort.action_filter = g_strdup(filter_key);
 361                 }
 362         else
 363                 {
 364                 sd->filter_key = NULL;
 365                 g_free(options->panels.sort.action_filter);
 366                 options->panels.sort.action_filter = g_strdup("");
 367                 }
 368 }
 369
 370 static void bar_sort_set_copy_cb(GtkWidget *button, gpointer data)
 371 {
 372         SortData *sd = data;
 373         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 374         bar_sort_set_action(sd, BAR_SORT_COPY, NULL);
 375 }
 376
 377 static void bar_sort_set_move_cb(GtkWidget *button, gpointer data)
 378 {
 379         SortData *sd = data;
 380         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 381         bar_sort_set_action(sd, BAR_SORT_MOVE, NULL);
 382 }
 383
 384 static void bar_sort_set_filter_cb(GtkWidget *button, gpointer data)
 385 {
 386         SortData *sd = data;
 387         const gchar *key;
 388
 389         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 390         key = g_object_get_data(G_OBJECT(button), "filter_key");
 391         bar_sort_set_action(sd, BAR_SORT_FILTER, key);
 392 }
 393
 394 static void bar_sort_set_selection(SortData *sd, SortSelectionType selection)
 395 {
 396         options->panels.sort.selection_state = sd->selection = selection;
 397 }
 398
 399 static void bar_sort_set_selection_image_cb(GtkWidget *button, gpointer data)
 400 {
 401         SortData *sd = data;
 402         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 403         bar_sort_set_selection(sd, BAR_SORT_SELECTION_IMAGE);
 404 }
 405
 406 static void bar_sort_set_selection_selected_cb(GtkWidget *button, gpointer data)
 407 {
 408         SortData *sd = data;
 409         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 410         bar_sort_set_selection(sd, BAR_SORT_SELECTION_SELECTED);
 411 }
 412
 413 static void bar_sort_add_close(SortData *sd)
 414 {
 415         if (sd->dialog) file_dialog_close(sd->dialog);
 416         sd->dialog_name_entry = NULL;
 417         sd->dialog = NULL;
 418 }
 419
 420 static void bar_sort_add_ok_cb(FileDialog *fd, gpointer data)
 421 {
 422         SortData *sd = data;
 423         const gchar *name;
 424
 425         name = gtk_entry_get_text(GTK_ENTRY(sd->dialog_name_entry));
 426         if (sd->mode == BAR_SORT_MODE_FOLDER)
 427                 {
 428                 if (strlen(name) == 0)
 429                         {
 430                         name = filename_from_path(fd->dest_path);
 431                         }
 432
 433                 bookmark_list_add(sd->bookmarks, name, fd->dest_path);
 434                 }
 435         else
 436                 {
 437                 gchar *path;
 438
 439                 if (strlen(name) == 0) return;
 440
 441                 if (!file_extension_match(name, GQ_COLLECTION_EXT))
 442                         {
 443                         gchar *tmp = g_strconcat(name, GQ_COLLECTION_EXT, NULL);
 444                         g_free((gpointer) name);
 445                         name = tmp;
 446                         }
 447
 448                 path = g_build_filename(get_collections_dir(), name, NULL);
 449                 if (isfile(path))
 450                         {
 451                         gchar *text = g_strdup_printf(_("The collection:\n%s\nalready exists."), name);
 452                         file_util_warning_dialog(_("Collection exists"), text, GTK_STOCK_DIALOG_INFO, NULL);
 453                         g_free(text);
 454                         }
 455                 else
 456                         {
 457                         CollectionData *cd;
 458
 459                         cd = collection_new(path);
 460                         if (collection_save(cd, path))
 461                                 {
 462                                 bar_sort_collection_list_build(sd->bookmarks);
 463                                 }
 464                         else
 465                                 {
 466                                 gchar *text = g_strdup_printf(_("Failed to save the collection:\n%s"), path);
 467                                 file_util_warning_dialog(_("Save Failed"), text,
 468                                                          GTK_STOCK_DIALOG_ERROR, GENERIC_DIALOG(fd)->dialog);
 469                                 g_free(text);
 470                                 }
 471                         collection_unref(cd);
 472                         }
 473
 474                 g_free(path);
 475                 }
 476
 477         bar_sort_add_close(sd);
 478 }
 479
 480 static void bar_sort_add_cancel_cb(FileDialog *fd, gpointer data)
 481 {
 482         SortData *sd = data;
 483
 484         bar_sort_add_close(sd);
 485 }
 486
 487 static void bar_sort_add_cb(GtkWidget *button, gpointer data)
 488 {
 489         SortData *sd = data;
 490         GtkWidget *hbox;
 491         const gchar *title;
 492
 493         if (sd->dialog)
 494                 {
 495                 gtk_window_present(GTK_WINDOW(GENERIC_DIALOG(sd->dialog)->dialog));
 496                 return;
 497                 }
 498
 499         if (sd->mode == BAR_SORT_MODE_FOLDER)
 500                 {
 501                 title = _("Add Bookmark");
 502                 }
 503         else
 504                 {
 505                 title = _("Add Collection");
 506                 }
 507
 508         sd->dialog = file_util_file_dlg(title,
 509                                        "add_bookmark", button,
 510                                        bar_sort_add_cancel_cb, sd);
 511         file_dialog_add_button(sd->dialog, GTK_STOCK_OK, NULL, bar_sort_add_ok_cb, TRUE);
 512
 513         generic_dialog_add_message(GENERIC_DIALOG(sd->dialog), NULL, title, NULL);
 514
 515         if (sd->mode == BAR_SORT_MODE_FOLDER)
 516                 {
 517                 file_dialog_add_path_widgets(sd->dialog, NULL, NULL, "add_bookmark", NULL, NULL);
 518                 }
 519
 520         hbox = pref_box_new(GENERIC_DIALOG(sd->dialog)->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
 521
 522         pref_label_new(hbox, _("Name:"));
 523
 524         sd->dialog_name_entry = gtk_entry_new();
 525         gtk_box_pack_start(GTK_BOX(hbox), sd->dialog_name_entry, TRUE, TRUE, 0);
 526         generic_dialog_attach_default(GENERIC_DIALOG(sd->dialog), sd->dialog_name_entry);
 527         gtk_widget_show(sd->dialog_name_entry);
 528
 529         if (sd->mode == BAR_SORT_MODE_COLLECTION)
 530                 {
 531                 gtk_widget_grab_focus(sd->dialog_name_entry);
 532                 }
 533
 534         gtk_widget_show(GENERIC_DIALOG(sd->dialog)->dialog);
 535 }
 536
 537 void bar_sort_close(GtkWidget *bar)
 538 {
 539         SortData *sd;
 540
 541         sd = g_object_get_data(G_OBJECT(bar), "bar_sort_data");
 542         if (!sd) return;
 543
 544         gtk_widget_destroy(sd->vbox);
 545 }
 546
 547 static void bar_sort_destroy(GtkWidget *widget, gpointer data)
 548 {
 549         SortData *sd = data;
 550
 551         bar_sort_add_close(sd);
 552
 553         g_free(sd->undo_src);
 554         g_free(sd->undo_dest);
 555         g_free(sd);
 556 }
 557
 558 GtkWidget *bar_sort_new(LayoutWindow *lw)
 559 {
 560         SortData *sd;
 561         GtkWidget *buttongrp;
 562         GtkWidget *label;
 563         GtkWidget *tbar;
 564         GtkWidget *combo;
 565         SortModeType mode;
 566         GList *editors_list, *work;
 567         gboolean have_filter;
 568
 569         if (!lw) return NULL;
 570
 571         sd = g_new0(SortData, 1);
 572
 573         sd->lw = lw;
 574
 575         mode = CLAMP(options->panels.sort.mode_state, 0, BAR_SORT_MODE_COUNT - 1);
 576         sd->action = CLAMP(options->panels.sort.action_state, 0, BAR_SORT_ACTION_COUNT - 1);
 577
 578         if (sd->action == BAR_SORT_FILTER &&
 579             (!options->panels.sort.action_filter || !options->panels.sort.action_filter[0]))
 580                 sd->action = BAR_SORT_COPY;
 581
 582         sd->selection = CLAMP(options->panels.sort.selection_state, 0, BAR_SORT_SELECTION_COUNT - 1);
 583         sd->undo_src = NULL;
 584         sd->undo_dest = NULL;
 585
 586         sd->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 587         g_object_set_data(G_OBJECT(sd->vbox), "bar_sort_data", sd);
 588         g_signal_connect(G_OBJECT(sd->vbox), "destroy",
 589                          G_CALLBACK(bar_sort_destroy), sd);
 590
 591         label = gtk_label_new(_("Sort Manager"));
 592         pref_label_bold(label, TRUE, FALSE);
 593         gtk_box_pack_start(GTK_BOX(sd->vbox), label, FALSE, FALSE, 0);
 594         gtk_widget_show(label);
 595
 596         combo = gtk_combo_box_new_text();
 597         gtk_box_pack_start(GTK_BOX(sd->vbox), combo, FALSE, FALSE, 0);
 598         gtk_widget_show(combo);
 599
 600         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Folders"));
 601         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Collections"));
 602
 603         g_signal_connect(G_OBJECT(combo), "changed",
 604                          G_CALLBACK(bar_sort_mode_cb), sd);
 605
 606         sd->folder_group = pref_box_new(sd->vbox, FALSE, GTK_ORIENTATION_VERTICAL, 0);
 607
 608         buttongrp = pref_radiobutton_new(sd->folder_group, NULL,
 609                                          _("Copy"), (sd->action == BAR_SORT_COPY),
 610                                          G_CALLBACK(bar_sort_set_copy_cb), sd);
 611         pref_radiobutton_new(sd->folder_group, buttongrp,
 612                              _("Move"), (sd->action == BAR_SORT_MOVE),
 613                              G_CALLBACK(bar_sort_set_move_cb), sd);
 614
 615
 616         have_filter = FALSE;
 617         editors_list = editor_list_get();
 618         work = editors_list;
 619         while (work)
 620                 {
 621                 GtkWidget *button;
 622                 EditorDescription *editor = work->data;
 623                 work = work->next;
 624                 gboolean select = FALSE;
 625
 626                 if (!editor_is_filter(editor->key)) continue;
 627
 628                 if (sd->action == BAR_SORT_FILTER && strcmp(editor->key, options->panels.sort.action_filter) == 0)
 629                         {
 630                         bar_sort_set_action(sd, sd->action, editor->key);
 631                         select = TRUE;
 632                         have_filter = TRUE;
 633                         }
 634
 635                 button = pref_radiobutton_new(sd->folder_group, buttongrp,
 636                                               editor->name, select,
 637                                               G_CALLBACK(bar_sort_set_filter_cb), sd);
 638
 639
 640                 g_object_set_data(G_OBJECT(button), "filter_key", editor->key);
 641                 }
 642         g_list_free(editors_list);
 643
 644         if (sd->action == BAR_SORT_FILTER && !have_filter) sd->action = BAR_SORT_COPY;
 645
 646         sd->collection_group = pref_box_new(sd->vbox, FALSE, GTK_ORIENTATION_VERTICAL, 0);
 647
 648         buttongrp = pref_radiobutton_new(sd->collection_group, NULL,
 649                                          _("Add image"), (sd->selection == BAR_SORT_SELECTION_IMAGE),
 650                                          G_CALLBACK(bar_sort_set_selection_image_cb), sd);
 651         pref_radiobutton_new(sd->collection_group, buttongrp,
 652                              _("Add selection"), (sd->selection == BAR_SORT_SELECTION_SELECTED),
 653                              G_CALLBACK(bar_sort_set_selection_selected_cb), sd);
 654
 655         sd->bookmarks = bookmark_list_new(SORT_KEY_FOLDERS, bar_sort_bookmark_select, sd);
 656         gtk_box_pack_start(GTK_BOX(sd->vbox), sd->bookmarks, TRUE, TRUE, 0);
 657         gtk_widget_show(sd->bookmarks);
 658
 659         tbar = pref_toolbar_new(sd->vbox, GTK_TOOLBAR_ICONS);
 660
 661         sd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, NULL, FALSE,
 662                                              _("Add Bookmark"),
 663                                              G_CALLBACK(bar_sort_add_cb), sd);
 664         sd->undo_button = pref_toolbar_button(tbar, GTK_STOCK_UNDO, NULL, FALSE,
 665                                               _("Undo last image"),
 666                                               G_CALLBACK(bar_sort_undo_cb), sd);
 667
 668         sd->mode = -1;
 669         bar_sort_mode_sync(sd, mode);
 670         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), sd->mode);
 671
 672         return sd->vbox;
 673 }
 674 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */