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 #include "rcfile.h"
  30
  31
  32 /*
  33   *-------------------------------------------------------------------
  34   * sort bar
  35   *-------------------------------------------------------------------
  36   */
  37
  38 typedef enum {
  39         BAR_SORT_MODE_FOLDER = 0,
  40         BAR_SORT_MODE_COLLECTION,
  41         BAR_SORT_MODE_COUNT
  42 } SortModeType;
  43
  44 typedef enum {
  45         BAR_SORT_COPY = 0,
  46         BAR_SORT_MOVE,
  47         BAR_SORT_FILTER,
  48         BAR_SORT_ACTION_COUNT
  49 } SortActionType;
  50
  51 typedef enum {
  52         BAR_SORT_SELECTION_IMAGE = 0,
  53         BAR_SORT_SELECTION_SELECTED,
  54         BAR_SORT_SELECTION_COUNT
  55 } SortSelectionType;
  56
  57 typedef struct _SortData SortData;
  58 struct _SortData
  59 {
  60         GtkWidget *vbox;
  61         GtkWidget *bookmarks;
  62         LayoutWindow *lw;
  63
  64         FileDialog *dialog;
  65         GtkWidget *dialog_name_entry;
  66
  67         SortModeType mode;
  68         SortActionType action;
  69         gchar *filter_key;
  70
  71         SortSelectionType selection;
  72
  73         GtkWidget *folder_group;
  74         GtkWidget *collection_group;
  75
  76         GtkWidget *add_button;
  77         GtkWidget *undo_button;
  78         SortActionType undo_action;
  79         GList *undo_src_list;
  80         gchar *undo_src;
  81         gchar *undo_dest;
  82 };
  83
  84
  85 #define SORT_KEY_FOLDERS     "sort_manager"
  86 #define SORT_KEY_COLLECTIONS "sort_manager_collections"
  87
  88
  89 static void bar_sort_undo_set(SortData *sd, GList *src_list, FileData *src, const gchar *dest);
  90 static void bar_sort_add_close(SortData *sd);
  91
  92
  93 static void bar_sort_collection_list_build(GtkWidget *bookmarks)
  94 {
  95         FileData *dir_fd;
  96         GList *list;
  97         GList *work;
  98
  99         history_list_free_key(SORT_KEY_COLLECTIONS);
 100         bookmark_list_set_key(bookmarks, SORT_KEY_COLLECTIONS);
 101
 102         dir_fd = file_data_new_simple(get_collections_dir());
 103         filelist_read(dir_fd, &list, NULL);
 104         file_data_unref(dir_fd);
 105
 106         list = filelist_sort_path(list);
 107
 108         work = list;
 109         while (work)
 110                 {
 111                 FileData *fd;
 112                 gchar *name;
 113
 114                 fd = work->data;
 115                 work = work->next;
 116
 117                 if (file_extension_match(fd->path, GQ_COLLECTION_EXT))
 118                         {
 119                         name = remove_extension_from_path(fd->name);
 120                         }
 121                 else
 122                         {
 123                         name = g_strdup(fd->name);
 124                         }
 125                 bookmark_list_add(bookmarks, name, fd->path);
 126                 g_free(name);
 127                 }
 128
 129         filelist_free(list);
 130 }
 131
 132 static void bar_sort_mode_sync(SortData *sd, SortModeType mode)
 133 {
 134         gint folder_mode;
 135
 136         if (sd->mode == mode) return;
 137         sd->mode = mode;
 138
 139         folder_mode = (sd->mode == BAR_SORT_MODE_FOLDER);
 140
 141         bookmark_list_set_no_defaults(sd->bookmarks, !folder_mode);
 142         bookmark_list_set_editable(sd->bookmarks, folder_mode);
 143         bookmark_list_set_only_directories(sd->bookmarks, folder_mode);
 144
 145         if (folder_mode)
 146                 {
 147                 gtk_widget_hide(sd->collection_group);
 148                 gtk_widget_show(sd->folder_group);
 149                 bookmark_list_set_key(sd->bookmarks, SORT_KEY_FOLDERS);
 150                 }
 151         else
 152                 {
 153                 gtk_widget_hide(sd->folder_group);
 154                 gtk_widget_show(sd->collection_group);
 155                 bar_sort_collection_list_build(sd->bookmarks);
 156                 }
 157
 158         bar_sort_add_close(sd);
 159
 160         bar_sort_undo_set(sd, NULL, NULL, NULL);
 161 }
 162
 163 static void bar_sort_mode_cb(GtkWidget *combo, gpointer data)
 164 {
 165         SortData *sd = data;
 166
 167         if (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) == BAR_SORT_MODE_FOLDER)
 168                 {
 169                 bar_sort_mode_sync(sd, BAR_SORT_MODE_FOLDER);
 170                 }
 171         else
 172                 {
 173                 bar_sort_mode_sync(sd, BAR_SORT_MODE_COLLECTION);
 174                 }
 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         sd->action = action;
 355         if (action == BAR_SORT_FILTER)
 356                 {
 357                 if (!filter_key) filter_key = "";
 358                 sd->filter_key = g_strdup(filter_key);
 359                 }
 360         else
 361                 {
 362                 sd->filter_key = NULL;
 363                 }
 364 }
 365
 366 static void bar_sort_set_copy_cb(GtkWidget *button, gpointer data)
 367 {
 368         SortData *sd = data;
 369         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 370         bar_sort_set_action(sd, BAR_SORT_COPY, NULL);
 371 }
 372
 373 static void bar_sort_set_move_cb(GtkWidget *button, gpointer data)
 374 {
 375         SortData *sd = data;
 376         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 377         bar_sort_set_action(sd, BAR_SORT_MOVE, NULL);
 378 }
 379
 380 static void bar_sort_set_filter_cb(GtkWidget *button, gpointer data)
 381 {
 382         SortData *sd = data;
 383         const gchar *key;
 384
 385         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 386         key = g_object_get_data(G_OBJECT(button), "filter_key");
 387         bar_sort_set_action(sd, BAR_SORT_FILTER, key);
 388 }
 389
 390 static void bar_sort_set_selection(SortData *sd, SortSelectionType selection)
 391 {
 392         sd->selection = selection;
 393 }
 394
 395 static void bar_sort_set_selection_image_cb(GtkWidget *button, gpointer data)
 396 {
 397         SortData *sd = data;
 398         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 399         bar_sort_set_selection(sd, BAR_SORT_SELECTION_IMAGE);
 400 }
 401
 402 static void bar_sort_set_selection_selected_cb(GtkWidget *button, gpointer data)
 403 {
 404         SortData *sd = data;
 405         if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
 406         bar_sort_set_selection(sd, BAR_SORT_SELECTION_SELECTED);
 407 }
 408
 409 static void bar_sort_add_close(SortData *sd)
 410 {
 411         if (sd->dialog) file_dialog_close(sd->dialog);
 412         sd->dialog_name_entry = NULL;
 413         sd->dialog = NULL;
 414 }
 415
 416 static void bar_sort_add_ok_cb(FileDialog *fd, gpointer data)
 417 {
 418         SortData *sd = data;
 419         const gchar *name;
 420
 421         name = gtk_entry_get_text(GTK_ENTRY(sd->dialog_name_entry));
 422         if (sd->mode == BAR_SORT_MODE_FOLDER)
 423                 {
 424                 if (strlen(name) == 0)
 425                         {
 426                         name = filename_from_path(fd->dest_path);
 427                         }
 428
 429                 bookmark_list_add(sd->bookmarks, name, fd->dest_path);
 430                 }
 431         else
 432                 {
 433                 gchar *path;
 434
 435                 if (strlen(name) == 0) return;
 436
 437                 if (!file_extension_match(name, GQ_COLLECTION_EXT))
 438                         {
 439                         gchar *tmp = g_strconcat(name, GQ_COLLECTION_EXT, NULL);
 440                         g_free((gpointer) name);
 441                         name = tmp;
 442                         }
 443
 444                 path = g_build_filename(get_collections_dir(), name, NULL);
 445                 if (isfile(path))
 446                         {
 447                         gchar *text = g_strdup_printf(_("The collection:\n%s\nalready exists."), name);
 448                         file_util_warning_dialog(_("Collection exists"), text, GTK_STOCK_DIALOG_INFO, NULL);
 449                         g_free(text);
 450                         }
 451                 else
 452                         {
 453                         CollectionData *cd;
 454
 455                         cd = collection_new(path);
 456                         if (collection_save(cd, path))
 457                                 {
 458                                 bar_sort_collection_list_build(sd->bookmarks);
 459                                 }
 460                         else
 461                                 {
 462                                 gchar *text = g_strdup_printf(_("Failed to save the collection:\n%s"), path);
 463                                 file_util_warning_dialog(_("Save Failed"), text,
 464                                                          GTK_STOCK_DIALOG_ERROR, GENERIC_DIALOG(fd)->dialog);
 465                                 g_free(text);
 466                                 }
 467                         collection_unref(cd);
 468                         }
 469
 470                 g_free(path);
 471                 }
 472
 473         bar_sort_add_close(sd);
 474 }
 475
 476 static void bar_sort_add_cancel_cb(FileDialog *fd, gpointer data)
 477 {
 478         SortData *sd = data;
 479
 480         bar_sort_add_close(sd);
 481 }
 482
 483 static void bar_sort_add_cb(GtkWidget *button, gpointer data)
 484 {
 485         SortData *sd = data;
 486         GtkWidget *hbox;
 487         const gchar *title;
 488
 489         if (sd->dialog)
 490                 {
 491                 gtk_window_present(GTK_WINDOW(GENERIC_DIALOG(sd->dialog)->dialog));
 492                 return;
 493                 }
 494
 495         if (sd->mode == BAR_SORT_MODE_FOLDER)
 496                 {
 497                 title = _("Add Bookmark");
 498                 }
 499         else
 500                 {
 501                 title = _("Add Collection");
 502                 }
 503
 504         sd->dialog = file_util_file_dlg(title,
 505                                        "add_bookmark", button,
 506                                        bar_sort_add_cancel_cb, sd);
 507         file_dialog_add_button(sd->dialog, GTK_STOCK_OK, NULL, bar_sort_add_ok_cb, TRUE);
 508
 509         generic_dialog_add_message(GENERIC_DIALOG(sd->dialog), NULL, title, NULL);
 510
 511         if (sd->mode == BAR_SORT_MODE_FOLDER)
 512                 {
 513                 file_dialog_add_path_widgets(sd->dialog, NULL, NULL, "add_bookmark", NULL, NULL);
 514                 }
 515
 516         hbox = pref_box_new(GENERIC_DIALOG(sd->dialog)->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
 517
 518         pref_label_new(hbox, _("Name:"));
 519
 520         sd->dialog_name_entry = gtk_entry_new();
 521         gtk_box_pack_start(GTK_BOX(hbox), sd->dialog_name_entry, TRUE, TRUE, 0);
 522         generic_dialog_attach_default(GENERIC_DIALOG(sd->dialog), sd->dialog_name_entry);
 523         gtk_widget_show(sd->dialog_name_entry);
 524
 525         if (sd->mode == BAR_SORT_MODE_COLLECTION)
 526                 {
 527                 gtk_widget_grab_focus(sd->dialog_name_entry);
 528                 }
 529
 530         gtk_widget_show(GENERIC_DIALOG(sd->dialog)->dialog);
 531 }
 532
 533 void bar_sort_close(GtkWidget *bar)
 534 {
 535         SortData *sd;
 536
 537         sd = g_object_get_data(G_OBJECT(bar), "bar_sort_data");
 538         if (!sd) return;
 539
 540         gtk_widget_destroy(sd->vbox);
 541 }
 542
 543 static void bar_sort_destroy(GtkWidget *widget, gpointer data)
 544 {
 545         SortData *sd = data;
 546
 547         bar_sort_add_close(sd);
 548
 549         g_free(sd->filter_key);
 550         g_free(sd->undo_src);
 551         g_free(sd->undo_dest);
 552         g_free(sd);
 553 }
 554
 555 static void bar_sort_edit_button_free(gpointer data)
 556 {
 557         g_free(data);
 558 }
 559
 560 static GtkWidget *bar_sort_new(LayoutWindow *lw, SortActionType action, SortModeType mode, SortSelectionType selection, const gchar *filter_key)
 561 {
 562         SortData *sd;
 563         GtkWidget *buttongrp;
 564         GtkWidget *label;
 565         GtkWidget *tbar;
 566         GtkWidget *combo;
 567         GList *editors_list, *work;
 568         gboolean have_filter;
 569
 570         if (!lw) return NULL;
 571
 572         sd = g_new0(SortData, 1);
 573
 574         sd->lw = lw;
 575
 576         sd->action = action;
 577
 578         if (sd->action == BAR_SORT_FILTER && (!filter_key || !filter_key[0]))
 579                 {
 580                 sd->action = BAR_SORT_COPY;
 581                 }
 582
 583         sd->selection = selection;
 584         sd->undo_src = NULL;
 585         sd->undo_dest = NULL;
 586
 587         sd->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 588         g_object_set_data(G_OBJECT(sd->vbox), "bar_sort_data", sd);
 589         g_signal_connect(G_OBJECT(sd->vbox), "destroy",
 590                          G_CALLBACK(bar_sort_destroy), sd);
 591
 592         label = gtk_label_new(_("Sort Manager"));
 593         pref_label_bold(label, TRUE, FALSE);
 594         gtk_box_pack_start(GTK_BOX(sd->vbox), label, FALSE, FALSE, 0);
 595         gtk_widget_show(label);
 596
 597         combo = gtk_combo_box_new_text();
 598         gtk_box_pack_start(GTK_BOX(sd->vbox), combo, FALSE, FALSE, 0);
 599         gtk_widget_show(combo);
 600
 601         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Folders"));
 602         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Collections"));
 603
 604         g_signal_connect(G_OBJECT(combo), "changed",
 605                          G_CALLBACK(bar_sort_mode_cb), sd);
 606
 607         sd->folder_group = pref_box_new(sd->vbox, FALSE, GTK_ORIENTATION_VERTICAL, 0);
 608
 609         buttongrp = pref_radiobutton_new(sd->folder_group, NULL,
 610                                          _("Copy"), (sd->action == BAR_SORT_COPY),
 611                                          G_CALLBACK(bar_sort_set_copy_cb), sd);
 612         pref_radiobutton_new(sd->folder_group, buttongrp,
 613                              _("Move"), (sd->action == BAR_SORT_MOVE),
 614                              G_CALLBACK(bar_sort_set_move_cb), sd);
 615
 616
 617         have_filter = FALSE;
 618         editors_list = editor_list_get();
 619         work = editors_list;
 620         while (work)
 621                 {
 622                 GtkWidget *button;
 623                 EditorDescription *editor = work->data;
 624                 gchar *key;
 625                 gboolean select = FALSE;
 626
 627                 work = work->next;
 628
 629                 if (!editor_is_filter(editor->key)) continue;
 630
 631                 key = g_strdup(editor->key);
 632                 if (sd->action == BAR_SORT_FILTER && strcmp(key, filter_key) == 0)
 633                         {
 634                         bar_sort_set_action(sd, sd->action, key);
 635                         select = TRUE;
 636                         have_filter = TRUE;
 637                         }
 638
 639                 button = pref_radiobutton_new(sd->folder_group, buttongrp,
 640                                               editor->name, select,
 641                                               G_CALLBACK(bar_sort_set_filter_cb), sd);
 642
 643                 g_object_set_data_full(G_OBJECT(button), "filter_key", key, bar_sort_edit_button_free);
 644                 }
 645         g_list_free(editors_list);
 646
 647         if (sd->action == BAR_SORT_FILTER && !have_filter) sd->action = BAR_SORT_COPY;
 648
 649         sd->collection_group = pref_box_new(sd->vbox, FALSE, GTK_ORIENTATION_VERTICAL, 0);
 650
 651         buttongrp = pref_radiobutton_new(sd->collection_group, NULL,
 652                                          _("Add image"), (sd->selection == BAR_SORT_SELECTION_IMAGE),
 653                                          G_CALLBACK(bar_sort_set_selection_image_cb), sd);
 654         pref_radiobutton_new(sd->collection_group, buttongrp,
 655                              _("Add selection"), (sd->selection == BAR_SORT_SELECTION_SELECTED),
 656                              G_CALLBACK(bar_sort_set_selection_selected_cb), sd);
 657
 658         sd->bookmarks = bookmark_list_new(SORT_KEY_FOLDERS, bar_sort_bookmark_select, sd);
 659         gtk_box_pack_start(GTK_BOX(sd->vbox), sd->bookmarks, TRUE, TRUE, 0);
 660         gtk_widget_show(sd->bookmarks);
 661
 662         tbar = pref_toolbar_new(sd->vbox, GTK_TOOLBAR_ICONS);
 663
 664         sd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, NULL, FALSE,
 665                                              _("Add Bookmark"),
 666                                              G_CALLBACK(bar_sort_add_cb), sd);
 667         sd->undo_button = pref_toolbar_button(tbar, GTK_STOCK_UNDO, NULL, FALSE,
 668                                               _("Undo last image"),
 669                                               G_CALLBACK(bar_sort_undo_cb), sd);
 670
 671         sd->mode = -1;
 672         bar_sort_mode_sync(sd, mode);
 673         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), sd->mode);
 674
 675         return sd->vbox;
 676 }
 677
 678 GtkWidget *bar_sort_new_from_config(LayoutWindow *lw, const gchar **attribute_names, const gchar **attribute_values)
 679 {
 680         GtkWidget *bar;
 681
 682         gboolean enabled = TRUE;
 683         gint action = 0;
 684         gint mode = 0;
 685         gint selection = 0;
 686         gchar *filter_key = NULL;
 687
 688         while (attribute_names && *attribute_names)
 689                 {
 690                 const gchar *option = *attribute_names++;
 691                 const gchar *value = *attribute_values++;
 692
 693                 if (READ_BOOL_FULL("enabled", enabled)) continue;
 694                 if (READ_INT_CLAMP_FULL("action", action, 0, BAR_SORT_ACTION_COUNT - 1)) continue;
 695                 if (READ_INT_CLAMP_FULL("mode", mode, 0, BAR_SORT_MODE_COUNT - 1)) continue;
 696                 if (READ_INT_CLAMP_FULL("selection", selection, 0, BAR_SORT_SELECTION_COUNT - 1)) continue;
 697                 if (READ_CHAR_FULL("filter_key", filter_key)) continue;
 698
 699                 DEBUG_1("unknown attribute %s = %s", option, value);
 700                 }
 701         bar = bar_sort_new(lw, action, mode, selection, filter_key);
 702
 703         g_free(filter_key);
 704         if (enabled) gtk_widget_show(bar);
 705         return bar;
 706 }
 707
 708 GtkWidget *bar_sort_new_default(LayoutWindow *lw)
 709 {
 710         return bar_sort_new_from_config(lw, NULL, NULL);
 711 }
 712
 713 void bar_sort_write_config(GtkWidget *bar, GString *outstr, gint indent)
 714 {
 715         SortData *sd;
 716
 717         if (!bar) return;
 718         sd = g_object_get_data(G_OBJECT(bar), "bar_sort_data");
 719         if (!sd) return;
 720
 721         WRITE_STRING("<bar_sort\n");
 722         indent++;
 723         write_bool_option(outstr, indent, "enabled", GTK_WIDGET_VISIBLE(bar));
 724         WRITE_INT(*sd, mode);
 725         WRITE_INT(*sd, action);
 726         WRITE_INT(*sd, selection);
 727         WRITE_CHAR(*sd, filter_key);
 728         indent--;
 729         WRITE_STRING("/>\n");
 730 }
 731
 732
 733 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */