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         GList *undo_dest_list;
  89         gchar *undo_collection;
  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, 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);
 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, 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         if (src_list)
 192                 {
 193                 /* we should create the undo_dest_list to use it later... */
 194                 string_list_free(sd->undo_dest_list);
 195                 sd->undo_dest_list=NULL;
 196
 197                 GList *work = sd->undo_src_list;
 198                 while(work)
 199                         {
 200                         gchar *filename =  g_strdup(filename_from_path(work->data));
 201                         gchar *dest_path = g_build_filename(g_strdup(dest), filename, NULL);
 202                         sd->undo_dest_list = g_list_prepend(sd->undo_dest_list, g_strdup(dest_path));
 203                         work = work->next;
 204                         }
 205                 sd->undo_dest_list = g_list_reverse(sd->undo_dest_list);
 206                 }
 207
 208         sd->undo_action = sd->action;
 209
 210         if (sd->undo_button)
 211                 {
 212                 gtk_widget_set_sensitive(sd->undo_button,
 213                                         ((sd->undo_src_list ) && sd->undo_dest_list));
 214                 }
 215 }
 216
 217 static void bar_sort_undo_folder(SortData *sd, GtkWidget *button)
 218 {
 219         gchar *origin;
 220
 221         if (!(sd->undo_src_list && sd->undo_dest_list)) return;
 222
 223         switch (sd->undo_action)
 224                 {
 225                 case BAR_SORT_MOVE:
 226                         {
 227                         GList *list;
 228                         gchar *src_dir;
 229                         gchar *src_path;
 230
 231                         if (sd->undo_src_list)
 232                                 {
 233                                 GList *work = NULL;
 234
 235                                 src_path = g_strdup(sd->undo_src_list->data);
 236                                 src_dir = remove_level_from_path(src_path);
 237                                 list = sd->undo_dest_list;
 238                                 while (list)
 239                                         {
 240                                         work = g_list_prepend(work, file_data_new_group(list->data));
 241                                         list=list->next;
 242                                         }
 243                                 file_util_move_simple(work, src_dir, sd->lw->window);
 244                                 g_free(src_dir);
 245                                 g_free(src_path);
 246                                 }
 247                         }
 248                         break;
 249
 250                 case BAR_SORT_COPY:
 251                 case BAR_SORT_FILTER:
 252                         if (sd->undo_src_list)
 253                                 {
 254                                 GList *delete_list;
 255                                 GList *work = NULL;
 256
 257                                 delete_list = sd->undo_dest_list;
 258                                 while (delete_list)
 259                                         {
 260                                         work = g_list_append(work, file_data_new_group(delete_list->data));
 261                                         delete_list = delete_list->next;
 262                                         }
 263                                 options->file_ops.safe_delete_enable = TRUE;
 264                                 file_util_delete(NULL, work, button);
 265                                 }
 266                         break;
 267
 268                 default:
 269                         break;
 270                 }
 271
 272         layout_refresh(sd->lw);
 273         origin = (sd->undo_src_list)->data;
 274
 275         if (isfile(origin))
 276                 {
 277                 layout_image_set_fd(sd->lw, file_data_new_group(origin));
 278                 }
 279
 280         bar_sort_undo_set(sd, NULL, NULL);
 281 }
 282
 283 static void bar_sort_undo_collection(SortData *sd)
 284 {
 285         GList *work;
 286
 287         work = sd->undo_src_list;
 288         while (work)
 289                 {
 290                 gchar *source;
 291                 source = work->data;
 292                 work = work->next;
 293                 collect_manager_remove(file_data_new_group(source), sd->undo_collection);
 294                 }
 295
 296         bar_sort_undo_set(sd, NULL,  NULL);
 297 }
 298
 299 static void bar_sort_undo_cb(GtkWidget *button, gpointer data)
 300 {
 301         SortData *sd = data;
 302
 303         if (sd->mode == BAR_SORT_MODE_FOLDER)
 304                 {
 305                 bar_sort_undo_folder(sd, button);
 306                 }
 307         else
 308                 {
 309                 bar_sort_undo_collection(sd);
 310                 }
 311 }
 312
 313 static void bar_sort_bookmark_select_folder(SortData *sd, FileData *source, const gchar *path)
 314 {
 315         GList *orig_list;
 316         GList *action_list;
 317         GList *undo_src_list;
 318
 319         if (!isdir(path)) return;
 320
 321         orig_list = layout_selection_list(sd->lw);
 322         action_list = orig_list;
 323         undo_src_list = orig_list;
 324         orig_list = NULL;
 325
 326         bar_sort_undo_set(sd, undo_src_list, path);
 327
 328         switch (sd->action)
 329                 {
 330                 case BAR_SORT_COPY:
 331                         file_util_copy_simple(action_list, path, sd->lw->window);
 332                         action_list = NULL;
 333                         layout_image_next(sd->lw);
 334                         break;
 335
 336                 case BAR_SORT_MOVE:
 337                         file_util_move_simple(action_list, path, sd->lw->window);
 338                         action_list = NULL;
 339                         break;
 340
 341                 case BAR_SORT_FILTER:
 342                         file_util_start_filter_from_filelist(sd->filter_key, action_list, path, sd->lw->window);
 343                         layout_image_next(sd->lw);
 344                         break;
 345
 346                 default:
 347                         break;
 348                 }
 349 }
 350
 351 static void bar_sort_bookmark_select_collection(SortData *sd, FileData *source, const gchar *path)
 352 {
 353         GList *list = NULL;
 354
 355         switch (sd->selection)
 356                 {
 357                 case BAR_SORT_SELECTION_IMAGE:
 358                         list = g_list_append(NULL, file_data_ref(source));
 359                         break;
 360                 case BAR_SORT_SELECTION_SELECTED:
 361                         list = layout_selection_list(sd->lw);
 362                         break;
 363                 default:
 364                         break;
 365                 }
 366
 367         if (!list)
 368                 {
 369                 bar_sort_undo_set(sd, NULL, NULL);
 370                 return;
 371                 }
 372
 373         bar_sort_undo_set(sd, list, path);
 374         sd->undo_collection = g_strdup(path);
 375
 376         while (list)
 377                 {
 378                 FileData *image_fd;
 379
 380                 image_fd = list->data;
 381                 list = list->next;
 382                 collect_manager_add(image_fd, path);
 383                 }
 384 }
 385
 386 static void bar_sort_bookmark_select(const gchar *path, gpointer data)
 387 {
 388         SortData *sd = data;
 389         FileData *source;
 390
 391         source = layout_image_get_fd(sd->lw);
 392         if (!path || !source) return;
 393
 394         if (sd->mode == BAR_SORT_MODE_FOLDER)
 395                 {
 396                 bar_sort_bookmark_select_folder(sd, source, path);
 397                 }
 398         else
 399                 {
 400                 bar_sort_bookmark_select_collection(sd, source, path);
 401                 }
 402 }
 403
 404 static void bar_sort_set_action(SortData *sd, SortActionType action, const gchar *filter_key)
 405 {
 406         sd->action = action;
 407         if (action == BAR_SORT_FILTER)
 408                 {
 409                 if (!filter_key) filter_key = "";
 410                 sd->filter_key = g_strdup(filter_key);
 411                 }
 412         else
 413                 {
 414                 sd->filter_key = NULL;
 415                 }
 416 }
 417
 418 static void bar_sort_set_copy_cb(GtkWidget *button, gpointer data)
 419 {
 420         SortData *sd = data;
 421         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 422         bar_sort_set_action(sd, BAR_SORT_COPY, NULL);
 423 }
 424
 425 static void bar_sort_set_move_cb(GtkWidget *button, gpointer data)
 426 {
 427         SortData *sd = data;
 428         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 429         bar_sort_set_action(sd, BAR_SORT_MOVE, NULL);
 430 }
 431
 432 static void bar_sort_set_filter_cb(GtkWidget *button, gpointer data)
 433 {
 434         SortData *sd = data;
 435         const gchar *key;
 436
 437         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 438         key = g_object_get_data(G_OBJECT(button), "filter_key");
 439         bar_sort_set_action(sd, BAR_SORT_FILTER, key);
 440 }
 441
 442 static void bar_sort_set_selection(SortData *sd, SortSelectionType selection)
 443 {
 444         sd->selection = selection;
 445 }
 446
 447 static void bar_sort_set_selection_image_cb(GtkWidget *button, gpointer data)
 448 {
 449         SortData *sd = data;
 450         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 451         bar_sort_set_selection(sd, BAR_SORT_SELECTION_IMAGE);
 452 }
 453
 454 static void bar_sort_set_selection_selected_cb(GtkWidget *button, gpointer data)
 455 {
 456         SortData *sd = data;
 457         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 458         bar_sort_set_selection(sd, BAR_SORT_SELECTION_SELECTED);
 459 }
 460
 461 static void bar_sort_add_close(SortData *sd)
 462 {
 463         if (sd->dialog) file_dialog_close(sd->dialog);
 464         sd->dialog_name_entry = NULL;
 465         sd->dialog = NULL;
 466 }
 467
 468 static void bar_sort_add_ok_cb(FileDialog *fd, gpointer data)
 469 {
 470         SortData *sd = data;
 471         const gchar *name = gtk_entry_get_text(GTK_ENTRY(sd->dialog_name_entry));
 472         gboolean empty_name = (name[0] == '\0');
 473
 474         name = gtk_entry_get_text(GTK_ENTRY(sd->dialog_name_entry));
 475         if (sd->mode == BAR_SORT_MODE_FOLDER)
 476                 {
 477                 if (empty_name)
 478                         {
 479                         name = filename_from_path(fd->dest_path);
 480                         }
 481
 482                 bookmark_list_add(sd->bookmarks, name, fd->dest_path);
 483                 }
 484         else
 485                 {
 486                 gchar *path;
 487                 gboolean has_extension;
 488                 gchar *filename = (gchar *) name;
 489
 490                 if (empty_name) return;
 491
 492                 has_extension = file_extension_match(name, GQ_COLLECTION_EXT);
 493                 if (!has_extension)
 494                         {
 495                         filename = g_strconcat(name, GQ_COLLECTION_EXT, NULL);
 496                         }
 497
 498                 path = g_build_filename(get_collections_dir(), filename, NULL);
 499                 if (isfile(path))
 500                         {
 501                         gchar *text = g_strdup_printf(_("The collection:\n%s\nalready exists."), filename);
 502                         file_util_warning_dialog(_("Collection exists"), text, GTK_STOCK_DIALOG_INFO, NULL);
 503                         g_free(text);
 504                         }
 505                 else
 506                         {
 507                         CollectionData *cd;
 508
 509                         cd = collection_new(path);
 510                         if (collection_save(cd, path))
 511                                 {
 512                                 bar_sort_collection_list_build(sd->bookmarks);
 513                                 }
 514                         else
 515                                 {
 516                                 gchar *text = g_strdup_printf(_("Failed to save the collection:\n%s"), path);
 517                                 file_util_warning_dialog(_("Save Failed"), text,
 518                                                          GTK_STOCK_DIALOG_ERROR, GENERIC_DIALOG(fd)->dialog);
 519                                 g_free(text);
 520                                 }
 521                         collection_unref(cd);
 522                         }
 523
 524                 if (!has_extension) g_free(filename);
 525                 g_free(path);
 526                 }
 527
 528         bar_sort_add_close(sd);
 529 }
 530
 531 static void bar_sort_add_cancel_cb(FileDialog *fd, gpointer data)
 532 {
 533         SortData *sd = data;
 534
 535         bar_sort_add_close(sd);
 536 }
 537
 538 static void bar_sort_add_cb(GtkWidget *button, gpointer data)
 539 {
 540         SortData *sd = data;
 541         GtkWidget *hbox;
 542         const gchar *title;
 543
 544         if (sd->dialog)
 545                 {
 546                 gtk_window_present(GTK_WINDOW(GENERIC_DIALOG(sd->dialog)->dialog));
 547                 return;
 548                 }
 549
 550         if (sd->mode == BAR_SORT_MODE_FOLDER)
 551                 {
 552                 title = _("Add Bookmark");
 553                 }
 554         else
 555                 {
 556                 title = _("Add Collection");
 557                 }
 558
 559         sd->dialog = file_util_file_dlg(title,
 560                                        "add_bookmark", button,
 561                                        bar_sort_add_cancel_cb, sd);
 562         file_dialog_add_button(sd->dialog, GTK_STOCK_OK, NULL, bar_sort_add_ok_cb, TRUE);
 563
 564         generic_dialog_add_message(GENERIC_DIALOG(sd->dialog), NULL, title, NULL, FALSE);
 565
 566         if (sd->mode == BAR_SORT_MODE_FOLDER)
 567                 {
 568                 file_dialog_add_path_widgets(sd->dialog, NULL, NULL, "add_bookmark", NULL, NULL);
 569                 }
 570
 571         hbox = pref_box_new(GENERIC_DIALOG(sd->dialog)->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
 572
 573         pref_label_new(hbox, _("Name:"));
 574
 575         sd->dialog_name_entry = gtk_entry_new();
 576         gtk_box_pack_start(GTK_BOX(hbox), sd->dialog_name_entry, TRUE, TRUE, 0);
 577         generic_dialog_attach_default(GENERIC_DIALOG(sd->dialog), sd->dialog_name_entry);
 578         gtk_widget_show(sd->dialog_name_entry);
 579
 580         if (sd->mode == BAR_SORT_MODE_COLLECTION)
 581                 {
 582                 gtk_widget_grab_focus(sd->dialog_name_entry);
 583                 }
 584
 585         gtk_widget_show(GENERIC_DIALOG(sd->dialog)->dialog);
 586 }
 587
 588 void bar_sort_close(GtkWidget *bar)
 589 {
 590         SortData *sd;
 591
 592         sd = g_object_get_data(G_OBJECT(bar), "bar_sort_data");
 593         if (!sd) return;
 594
 595         gtk_widget_destroy(sd->vbox);
 596 }
 597
 598 static void bar_sort_destroy(GtkWidget *widget, gpointer data)
 599 {
 600         SortData *sd = data;
 601
 602         bar_sort_add_close(sd);
 603
 604         g_free(sd->filter_key);
 605         string_list_free(sd->undo_src_list);
 606         string_list_free(sd->undo_dest_list);
 607         g_free(sd->undo_collection);
 608         g_free(sd);
 609 }
 610
 611 static void bar_sort_edit_button_free(gpointer data)
 612 {
 613         g_free(data);
 614 }
 615
 616 static GtkWidget *bar_sort_new(LayoutWindow *lw, SortActionType action,
 617                                SortModeType mode, SortSelectionType selection,
 618                                const gchar *filter_key)
 619 {
 620         SortData *sd;
 621         GtkWidget *buttongrp;
 622         GtkWidget *label;
 623         GtkWidget *tbar;
 624         GtkWidget *combo;
 625         GList *editors_list, *work;
 626         gboolean have_filter;
 627
 628         if (!lw) return NULL;
 629
 630         sd = g_new0(SortData, 1);
 631
 632         sd->lw = lw;
 633
 634         sd->action = action;
 635
 636         if (sd->action == BAR_SORT_FILTER && (!filter_key || !filter_key[0]))
 637                 {
 638                 sd->action = BAR_SORT_COPY;
 639                 }
 640
 641         sd->selection = selection;
 642         sd->undo_src_list = NULL;
 643         sd->undo_dest_list = NULL;
 644         sd->undo_collection = NULL;
 645
 646         sd->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 647         DEBUG_NAME(sd->vbox);
 648         g_object_set_data(G_OBJECT(sd->vbox), "bar_sort_data", sd);
 649         g_signal_connect(G_OBJECT(sd->vbox), "destroy",
 650                          G_CALLBACK(bar_sort_destroy), sd);
 651
 652         label = gtk_label_new(_("Sort Manager"));
 653         pref_label_bold(label, TRUE, FALSE);
 654         gtk_box_pack_start(GTK_BOX(sd->vbox), label, FALSE, FALSE, 0);
 655         gtk_widget_show(label);
 656
 657         combo = gtk_combo_box_text_new();
 658         gtk_box_pack_start(GTK_BOX(sd->vbox), combo, FALSE, FALSE, 0);
 659         gtk_widget_show(combo);
 660
 661         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Folders"));
 662         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Collections"));
 663
 664         g_signal_connect(G_OBJECT(combo), "changed",
 665                          G_CALLBACK(bar_sort_mode_cb), sd);
 666
 667         sd->folder_group = pref_box_new(sd->vbox, FALSE, GTK_ORIENTATION_VERTICAL, 0);
 668         DEBUG_NAME(sd->folder_group);
 669
 670         buttongrp = pref_radiobutton_new(sd->folder_group, NULL,
 671                                          _("Copy"), (sd->action == BAR_SORT_COPY),
 672                                          G_CALLBACK(bar_sort_set_copy_cb), sd);
 673         pref_radiobutton_new(sd->folder_group, buttongrp,
 674                              _("Move"), (sd->action == BAR_SORT_MOVE),
 675                              G_CALLBACK(bar_sort_set_move_cb), sd);
 676
 677
 678         have_filter = FALSE;
 679         editors_list = editor_list_get();
 680         work = editors_list;
 681         while (work)
 682                 {
 683                 GtkWidget *button;
 684                 EditorDescription *editor = work->data;
 685                 gchar *key;
 686                 gboolean select = FALSE;
 687
 688                 work = work->next;
 689
 690                 if (!editor_is_filter(editor->key)) continue;
 691
 692                 key = g_strdup(editor->key);
 693                 if (sd->action == BAR_SORT_FILTER && strcmp(key, filter_key) == 0)
 694                         {
 695                         bar_sort_set_action(sd, sd->action, key);
 696                         select = TRUE;
 697                         have_filter = TRUE;
 698                         }
 699
 700                 button = pref_radiobutton_new(sd->folder_group, buttongrp,
 701                                               editor->name, select,
 702                                               G_CALLBACK(bar_sort_set_filter_cb), sd);
 703
 704                 g_object_set_data_full(G_OBJECT(button), "filter_key", key, bar_sort_edit_button_free);
 705                 }
 706         g_list_free(editors_list);
 707
 708         if (sd->action == BAR_SORT_FILTER && !have_filter) sd->action = BAR_SORT_COPY;
 709
 710         sd->collection_group = pref_box_new(sd->vbox, FALSE, GTK_ORIENTATION_VERTICAL, 0);
 711
 712         buttongrp = pref_radiobutton_new(sd->collection_group, NULL,
 713                                          _("Add image"), (sd->selection == BAR_SORT_SELECTION_IMAGE),
 714                                          G_CALLBACK(bar_sort_set_selection_image_cb), sd);
 715         pref_radiobutton_new(sd->collection_group, buttongrp,
 716                              _("Add selection"), (sd->selection == BAR_SORT_SELECTION_SELECTED),
 717                              G_CALLBACK(bar_sort_set_selection_selected_cb), sd);
 718
 719         sd->bookmarks = bookmark_list_new(SORT_KEY_FOLDERS, bar_sort_bookmark_select, sd);
 720         DEBUG_NAME(sd->bookmarks);
 721         gtk_box_pack_start(GTK_BOX(sd->vbox), sd->bookmarks, TRUE, TRUE, 0);
 722         gtk_widget_show(sd->bookmarks);
 723
 724         tbar = pref_toolbar_new(sd->vbox, GTK_TOOLBAR_ICONS);
 725         DEBUG_NAME(tbar);
 726
 727         sd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, NULL, FALSE,
 728                                              _("Add Bookmark"),
 729                                              G_CALLBACK(bar_sort_add_cb), sd);
 730         sd->undo_button = pref_toolbar_button(tbar, GTK_STOCK_UNDO, NULL, FALSE,
 731                                               _("Undo last image"),
 732                                               G_CALLBACK(bar_sort_undo_cb), sd);
 733
 734         sd->mode = -1;
 735         bar_sort_mode_sync(sd, mode);
 736         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), sd->mode);
 737
 738         return sd->vbox;
 739 }
 740
 741 GtkWidget *bar_sort_new_from_config(LayoutWindow *lw, const gchar **attribute_names, const gchar **attribute_values)
 742 {
 743         GtkWidget *bar;
 744
 745         gboolean enabled = TRUE;
 746         gint action = 0;
 747         gint mode = 0;
 748         gint selection = 0;
 749         gchar *filter_key = NULL;
 750
 751         while (attribute_names && *attribute_names)
 752                 {
 753                 const gchar *option = *attribute_names++;
 754                 const gchar *value = *attribute_values++;
 755
 756                 if (READ_BOOL_FULL("enabled", enabled)) continue;
 757                 if (READ_INT_CLAMP_FULL("action", action, 0, BAR_SORT_ACTION_COUNT - 1)) continue;
 758                 if (READ_INT_CLAMP_FULL("mode", mode, 0, BAR_SORT_MODE_COUNT - 1)) continue;
 759                 if (READ_INT_CLAMP_FULL("selection", selection, 0, BAR_SORT_SELECTION_COUNT - 1)) continue;
 760                 if (READ_CHAR_FULL("filter_key", filter_key)) continue;
 761
 762                 log_printf("unknown attribute %s = %s\n", option, value);
 763                 }
 764         bar = bar_sort_new(lw, action, mode, selection, filter_key);
 765
 766         g_free(filter_key);
 767         if (enabled) gtk_widget_show(bar);
 768         return bar;
 769 }
 770
 771 /**
 772  * @brief Sets the bar_sort_enabled flag
 773  * @param lw
 774  * @param attribute_names
 775  * @param attribute_values
 776  *
 777  * Called from rcfile when processing geeqierc.xml on start-up.
 778  * It is neccesary to set the bar_sort_enabled flag because
 779  * the sort manager and desktop files are set up in the idle loop, and
 780  * setup is not yet completed during initialisation.
 781  * The flag is checked in layout_editors_reload_idle_cb.
 782  * action, mode, selection and filter_key are ignored.
 783  */
 784 void bar_sort_cold_start(LayoutWindow *lw, const gchar **attribute_names, const gchar **attribute_values)
 785 {
 786         gboolean enabled = TRUE;
 787         gint action = 0;
 788         gint mode = 0;
 789         gint selection = 0;
 790         gchar *filter_key = NULL;
 791
 792         while (attribute_names && *attribute_names)
 793                 {
 794                 const gchar *option = *attribute_names++;
 795                 const gchar *value = *attribute_values++;
 796
 797                 if (READ_BOOL_FULL("enabled", enabled)) continue;
 798                 if (READ_INT_CLAMP_FULL("action", action, 0, BAR_SORT_ACTION_COUNT - 1)) continue;
 799                 if (READ_INT_CLAMP_FULL("mode", mode, 0, BAR_SORT_MODE_COUNT - 1)) continue;
 800                 if (READ_INT_CLAMP_FULL("selection", selection, 0, BAR_SORT_SELECTION_COUNT - 1)) continue;
 801                 if (READ_CHAR_FULL("filter_key", filter_key)) continue;
 802
 803                 log_printf("unknown attribute %s = %s\n", option, value);
 804                 }
 805
 806         lw->bar_sort_enabled = enabled;
 807 }
 808
 809 GtkWidget *bar_sort_new_default(LayoutWindow *lw)
 810 {
 811         return bar_sort_new_from_config(lw, NULL, NULL);
 812 }
 813
 814 void bar_sort_write_config(GtkWidget *bar, GString *outstr, gint indent)
 815 {
 816         SortData *sd;
 817
 818         if (!bar) return;
 819         sd = g_object_get_data(G_OBJECT(bar), "bar_sort_data");
 820         if (!sd) return;
 821
 822         WRITE_NL(); WRITE_STRING("<bar_sort ");
 823         write_bool_option(outstr, indent, "enabled", gtk_widget_get_visible(bar));
 824         WRITE_INT(*sd, mode);
 825         WRITE_INT(*sd, action);
 826         WRITE_INT(*sd, selection);
 827         WRITE_CHAR(*sd, filter_key);
 828         WRITE_STRING("/>");
 829 }
 830
 831
 832 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */