src/bar_sort.c

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