summaryrefslogtreecommitdiff
path: root/src/searches/SavedSearchDialog.vala
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-07-23 09:06:59 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-07-23 09:06:59 +0200
commit4ea2cc3bd4a7d9b1c54a9d33e6a1cf82e7c8c21d (patch)
treed2e54377d14d604356c86862a326f64ae64dadd6 /src/searches/SavedSearchDialog.vala
Imported Upstream version 0.18.1upstream/0.18.1
Diffstat (limited to 'src/searches/SavedSearchDialog.vala')
-rw-r--r--src/searches/SavedSearchDialog.vala829
1 files changed, 829 insertions, 0 deletions
diff --git a/src/searches/SavedSearchDialog.vala b/src/searches/SavedSearchDialog.vala
new file mode 100644
index 0000000..b425cfb
--- /dev/null
+++ b/src/searches/SavedSearchDialog.vala
@@ -0,0 +1,829 @@
+/* Copyright 2011-2014 Yorba Foundation
+ *
+ * This software is licensed under the GNU LGPL (version 2.1 or later).
+ * See the COPYING file in this distribution.
+ */
+
+// This dialog displays a boolean search configuration.
+public class SavedSearchDialog {
+
+ // Conatins a search row, with a type selector and remove button.
+ private class SearchRowContainer {
+ public signal void remove(SearchRowContainer this_row);
+ public signal void changed(SearchRowContainer this_row);
+
+ private Gtk.ComboBoxText type_combo;
+ private Gtk.Box box;
+ private Gtk.Alignment align;
+ private Gtk.Button remove_button;
+ private SearchCondition.SearchType[] search_types;
+ private Gee.HashMap<SearchCondition.SearchType, int> search_types_index;
+
+ private SearchRow? my_row = null;
+
+ public SearchRowContainer() {
+ setup_gui();
+ set_type(SearchCondition.SearchType.ANY_TEXT);
+ }
+
+ public SearchRowContainer.edit_existing(SearchCondition sc) {
+ setup_gui();
+ set_type(sc.search_type);
+ set_type_combo_box(sc.search_type);
+ my_row.populate(sc);
+ }
+
+ // Creates the GUI for this row.
+ private void setup_gui() {
+ search_types = SearchCondition.SearchType.as_array();
+ search_types_index = new Gee.HashMap<SearchCondition.SearchType, int>();
+ SearchCondition.SearchType.sort_array(ref search_types);
+
+ type_combo = new Gtk.ComboBoxText();
+ for (int i = 0; i < search_types.length; i++) {
+ SearchCondition.SearchType st = search_types[i];
+ search_types_index.set(st, i);
+ type_combo.append_text(st.display_text());
+ }
+ set_type_combo_box(SearchCondition.SearchType.ANY_TEXT); // Sets default.
+ type_combo.changed.connect(on_type_changed);
+
+ remove_button = new Gtk.Button();
+ remove_button.set_label(" – ");
+ remove_button.button_press_event.connect(on_removed);
+
+ align = new Gtk.Alignment(0,0,0,0);
+
+ box = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 8);
+ box.pack_start(type_combo, false, false, 0);
+ box.pack_start(align, false, false, 0);
+ box.pack_start(new Gtk.Alignment(0,0,0,0), true, true, 0); // Fill space.
+ box.pack_start(remove_button, false, false, 0);
+ box.show_all();
+ }
+
+ private void on_type_changed() {
+ set_type(get_search_type());
+ changed(this);
+ }
+
+ private void set_type_combo_box(SearchCondition.SearchType st) {
+ type_combo.set_active(search_types_index.get(st));
+ }
+
+ private void set_type(SearchCondition.SearchType type) {
+ if (my_row != null)
+ align.remove(my_row.get_widget());
+
+ switch (type) {
+ case SearchCondition.SearchType.ANY_TEXT:
+ case SearchCondition.SearchType.EVENT_NAME:
+ case SearchCondition.SearchType.FILE_NAME:
+ case SearchCondition.SearchType.TAG:
+ case SearchCondition.SearchType.COMMENT:
+ case SearchCondition.SearchType.TITLE:
+ my_row = new SearchRowText(this);
+ break;
+
+ case SearchCondition.SearchType.MEDIA_TYPE:
+ my_row = new SearchRowMediaType(this);
+ break;
+
+ case SearchCondition.SearchType.FLAG_STATE:
+ my_row = new SearchRowFlagged(this);
+ break;
+
+ case SearchCondition.SearchType.MODIFIED_STATE:
+ my_row = new SearchRowModified(this);
+ break;
+
+ case SearchCondition.SearchType.RATING:
+ my_row = new SearchRowRating(this);
+ break;
+
+ case SearchCondition.SearchType.DATE:
+ my_row = new SearchRowDate(this);
+ break;
+
+ default:
+ assert(false);
+ break;
+ }
+
+ align.add(my_row.get_widget());
+ }
+
+ public SearchCondition.SearchType get_search_type() {
+ return search_types[type_combo.get_active()];
+ }
+
+ private bool on_removed(Gdk.EventButton event) {
+ remove(this);
+ return false;
+ }
+
+ public void allow_removal(bool allow) {
+ remove_button.sensitive = allow;
+ }
+
+ public Gtk.Widget get_widget() {
+ return box;
+ }
+
+ public SearchCondition get_search_condition() {
+ return my_row.get_search_condition();
+ }
+
+ public bool is_complete() {
+ return my_row.is_complete();
+ }
+ }
+
+ // Represents a row-type.
+ private abstract class SearchRow {
+ // Returns the GUI widget for this row.
+ public abstract Gtk.Widget get_widget();
+
+ // Returns the search condition for this row.
+ public abstract SearchCondition get_search_condition();
+
+ // Fills out the fields in this row based on an existing search condition (for edit mode.)
+ public abstract void populate(SearchCondition sc);
+
+ // Returns true if the row is valid and complete.
+ public abstract bool is_complete();
+ }
+
+ private class SearchRowText : SearchRow {
+ private Gtk.Box box;
+ private Gtk.ComboBoxText text_context;
+ private Gtk.Entry entry;
+
+ private SearchRowContainer parent;
+
+ public SearchRowText(SearchRowContainer parent) {
+ this.parent = parent;
+
+ // Ordering must correspond with SearchConditionText.Context
+ text_context = new Gtk.ComboBoxText();
+ text_context.append_text(_("contains"));
+ text_context.append_text(_("is exactly"));
+ text_context.append_text(_("starts with"));
+ text_context.append_text(_("ends with"));
+ text_context.append_text(_("does not contain"));
+ text_context.append_text(_("is not set"));
+ text_context.set_active(0);
+ text_context.changed.connect(on_changed);
+
+ entry = new Gtk.Entry();
+ entry.set_width_chars(25);
+ entry.set_activates_default(true);
+ entry.changed.connect(on_changed);
+
+ box = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 8);
+ box.pack_start(text_context, false, false, 0);
+ box.pack_start(entry, false, false, 0);
+ box.show_all();
+ }
+
+ ~SearchRowText() {
+ text_context.changed.disconnect(on_changed);
+ entry.changed.disconnect(on_changed);
+ }
+
+ public override Gtk.Widget get_widget() {
+ return box;
+ }
+
+ public override SearchCondition get_search_condition() {
+ SearchCondition.SearchType type = parent.get_search_type();
+ string text = entry.get_text();
+ SearchConditionText.Context context = get_text_context();
+ SearchConditionText c = new SearchConditionText(type, text, context);
+ return c;
+ }
+
+ public override void populate(SearchCondition sc) {
+ SearchConditionText? text = sc as SearchConditionText;
+ assert(text != null);
+ text_context.set_active(text.context);
+ entry.set_text(text.text);
+ on_changed();
+ }
+
+ public override bool is_complete() {
+ return entry.text.chomp() != "" || get_text_context() == SearchConditionText.Context.IS_NOT_SET;
+ }
+
+ private SearchConditionText.Context get_text_context() {
+ return (SearchConditionText.Context) text_context.get_active();
+ }
+
+ private void on_changed() {
+ if (get_text_context() == SearchConditionText.Context.IS_NOT_SET) {
+ entry.hide();
+ } else {
+ entry.show();
+ }
+
+ parent.changed(parent);
+ }
+ }
+
+ private class SearchRowMediaType : SearchRow {
+ private Gtk.Box box;
+ private Gtk.ComboBoxText media_context;
+ private Gtk.ComboBoxText media_type;
+
+ private SearchRowContainer parent;
+
+ public SearchRowMediaType(SearchRowContainer parent) {
+ this.parent = parent;
+
+ // Ordering must correspond with SearchConditionMediaType.Context
+ media_context = new Gtk.ComboBoxText();
+ media_context.append_text(_("is"));
+ media_context.append_text(_("is not"));
+ media_context.set_active(0);
+ media_context.changed.connect(on_changed);
+
+ // Ordering must correspond with SearchConditionMediaType.MediaType
+ media_type = new Gtk.ComboBoxText();
+ media_type.append_text(_("any photo"));
+ media_type.append_text(_("a raw photo"));
+ media_type.append_text(_("a video"));
+ media_type.set_active(0);
+ media_type.changed.connect(on_changed);
+
+ box = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 8);
+ box.pack_start(media_context, false, false, 0);
+ box.pack_start(media_type, false, false, 0);
+ box.show_all();
+ }
+
+ ~SearchRowMediaType() {
+ media_context.changed.disconnect(on_changed);
+ media_type.changed.disconnect(on_changed);
+ }
+
+ public override Gtk.Widget get_widget() {
+ return box;
+ }
+
+ public override SearchCondition get_search_condition() {
+ SearchCondition.SearchType search_type = parent.get_search_type();
+ SearchConditionMediaType.Context context = (SearchConditionMediaType.Context) media_context.get_active();
+ SearchConditionMediaType.MediaType type = (SearchConditionMediaType.MediaType) media_type.get_active();
+ SearchConditionMediaType c = new SearchConditionMediaType(search_type, context, type);
+ return c;
+ }
+
+ public override void populate(SearchCondition sc) {
+ SearchConditionMediaType? media = sc as SearchConditionMediaType;
+ assert(media != null);
+ media_context.set_active(media.context);
+ media_type.set_active(media.media_type);
+ }
+
+ public override bool is_complete() {
+ return true;
+ }
+
+ private void on_changed() {
+ parent.changed(parent);
+ }
+ }
+
+ private class SearchRowModified : SearchRow {
+ private Gtk.Box box;
+ private Gtk.ComboBoxText modified_context;
+ private Gtk.ComboBoxText modified_state;
+
+ private SearchRowContainer parent;
+
+ public SearchRowModified(SearchRowContainer parent) {
+ this.parent = parent;
+
+ modified_context = new Gtk.ComboBoxText();
+ modified_context.append_text(_("has"));
+ modified_context.append_text(_("has no"));
+ modified_context.set_active(0);
+ modified_context.changed.connect(on_changed);
+
+ modified_state = new Gtk.ComboBoxText();
+ modified_state.append_text(_("modifications"));
+ modified_state.append_text(_("internal modifications"));
+ modified_state.append_text(_("external modifications"));
+ modified_state.set_active(0);
+ modified_state.changed.connect(on_changed);
+
+ box = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 8);
+ box.pack_start(modified_context, false, false, 0);
+ box.pack_start(modified_state, false, false, 0);
+ box.show_all();
+ }
+
+ ~SearchRowModified() {
+ modified_state.changed.disconnect(on_changed);
+ modified_context.changed.disconnect(on_changed);
+ }
+
+ public override Gtk.Widget get_widget() {
+ return box;
+ }
+
+ public override SearchCondition get_search_condition() {
+ SearchCondition.SearchType search_type = parent.get_search_type();
+ SearchConditionModified.Context context = (SearchConditionModified.Context) modified_context.get_active();
+ SearchConditionModified.State state = (SearchConditionModified.State) modified_state.get_active();
+ SearchConditionModified c = new SearchConditionModified(search_type, context, state);
+ return c;
+ }
+
+ public override void populate(SearchCondition sc) {
+ SearchConditionModified? scm = sc as SearchConditionModified;
+ assert(scm != null);
+ modified_state.set_active(scm.state);
+ modified_context.set_active(scm.context);
+ }
+
+ public override bool is_complete() {
+ return true;
+ }
+
+ private void on_changed() {
+ parent.changed(parent);
+ }
+ }
+
+ private class SearchRowFlagged : SearchRow {
+ private Gtk.Box box;
+ private Gtk.ComboBoxText flagged_state;
+
+ private SearchRowContainer parent;
+
+ public SearchRowFlagged(SearchRowContainer parent) {
+ this.parent = parent;
+
+ // Ordering must correspond with SearchConditionFlagged.State
+ flagged_state = new Gtk.ComboBoxText();
+ flagged_state.append_text(_("flagged"));
+ flagged_state.append_text(_("not flagged"));
+ flagged_state.set_active(0);
+ flagged_state.changed.connect(on_changed);
+
+ box = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 8);
+ box.pack_start(new Gtk.Label(_("is")), false, false, 0);
+ box.pack_start(flagged_state, false, false, 0);
+ box.show_all();
+ }
+
+ ~SearchRowFlagged() {
+ flagged_state.changed.disconnect(on_changed);
+ }
+
+ public override Gtk.Widget get_widget() {
+ return box;
+ }
+
+ public override SearchCondition get_search_condition() {
+ SearchCondition.SearchType search_type = parent.get_search_type();
+ SearchConditionFlagged.State state = (SearchConditionFlagged.State) flagged_state.get_active();
+ SearchConditionFlagged c = new SearchConditionFlagged(search_type, state);
+ return c;
+ }
+
+ public override void populate(SearchCondition sc) {
+ SearchConditionFlagged? f = sc as SearchConditionFlagged;
+ assert(f != null);
+ flagged_state.set_active(f.state);
+ }
+
+ public override bool is_complete() {
+ return true;
+ }
+
+ private void on_changed() {
+ parent.changed(parent);
+ }
+ }
+
+ private class SearchRowRating : SearchRow {
+ private Gtk.Box box;
+ private Gtk.ComboBoxText rating;
+ private Gtk.ComboBoxText context;
+
+ private SearchRowContainer parent;
+
+ public SearchRowRating(SearchRowContainer parent) {
+ this.parent = parent;
+
+ // Ordering must correspond with Rating
+ rating = new Gtk.ComboBoxText();
+ rating.append_text(Resources.rating_combo_box(Rating.REJECTED));
+ rating.append_text(Resources.rating_combo_box(Rating.UNRATED));
+ rating.append_text(Resources.rating_combo_box(Rating.ONE));
+ rating.append_text(Resources.rating_combo_box(Rating.TWO));
+ rating.append_text(Resources.rating_combo_box(Rating.THREE));
+ rating.append_text(Resources.rating_combo_box(Rating.FOUR));
+ rating.append_text(Resources.rating_combo_box(Rating.FIVE));
+ rating.set_active(0);
+ rating.changed.connect(on_changed);
+
+ context = new Gtk.ComboBoxText();
+ context.append_text(_("and higher"));
+ context.append_text(_("only"));
+ context.append_text(_("and lower"));
+ context.set_active(0);
+ context.changed.connect(on_changed);
+
+ box = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 8);
+ box.pack_start(new Gtk.Label(_("is")), false, false, 0);
+ box.pack_start(rating, false, false, 0);
+ box.pack_start(context, false, false, 0);
+ box.show_all();
+ }
+
+ ~SearchRowRating() {
+ rating.changed.disconnect(on_changed);
+ context.changed.disconnect(on_changed);
+ }
+
+ public override Gtk.Widget get_widget() {
+ return box;
+ }
+
+ public override SearchCondition get_search_condition() {
+ SearchCondition.SearchType search_type = parent.get_search_type();
+ Rating search_rating = (Rating) rating.get_active() + Rating.REJECTED;
+ SearchConditionRating.Context search_context = (SearchConditionRating.Context) context.get_active();
+ SearchConditionRating c = new SearchConditionRating(search_type, search_rating, search_context);
+ return c;
+ }
+
+ public override void populate(SearchCondition sc) {
+ SearchConditionRating? r = sc as SearchConditionRating;
+ assert(r != null);
+ context.set_active(r.context);
+ rating.set_active(r.rating - Rating.REJECTED);
+ }
+
+ public override bool is_complete() {
+ return true;
+ }
+
+ private void on_changed() {
+ parent.changed(parent);
+ }
+ }
+
+ private class SearchRowDate : SearchRow {
+ private const string DATE_FORMAT = "%x";
+ private Gtk.Box box;
+ private Gtk.ComboBoxText context;
+ private Gtk.Button label_one;
+ private Gtk.Button label_two;
+ private Gtk.Calendar cal_one;
+ private Gtk.Calendar cal_two;
+ private Gtk.Label and;
+
+ private SearchRowContainer parent;
+
+ public SearchRowDate(SearchRowContainer parent) {
+ this.parent = parent;
+
+ // Ordering must correspond with Context
+ context = new Gtk.ComboBoxText();
+ context.append_text(_("is exactly"));
+ context.append_text(_("is after"));
+ context.append_text(_("is before"));
+ context.append_text(_("is between"));
+ context.append_text(_("is not set"));
+ context.set_active(0);
+ context.changed.connect(on_changed);
+
+ cal_one = new Gtk.Calendar();
+ cal_two = new Gtk.Calendar();
+
+ label_one = new Gtk.Button();
+ label_one.clicked.connect(on_one_clicked);
+ label_two = new Gtk.Button();
+ label_two.clicked.connect(on_two_clicked);
+
+ and = new Gtk.Label(_("and"));
+
+ box = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 8);
+ box.pack_start(context, false, false, 0);
+ box.pack_start(label_one, false, false, 0);
+ box.pack_start(and, false, false, 0);
+ box.pack_start(label_two, false, false, 0);
+
+ box.show_all();
+ update_date_labels();
+ }
+
+ ~SearchRowRating() {
+ context.changed.disconnect(on_changed);
+ }
+
+ private void update_date_labels() {
+ SearchConditionDate.Context c = (SearchConditionDate.Context) context.get_active();
+
+ // Only show "and" and 2nd date label for between mode.
+ if (c == SearchConditionDate.Context.BETWEEN) {
+ label_one.show();
+ and.show();
+ label_two.show();
+ } else if (c == SearchConditionDate.Context.IS_NOT_SET) {
+ label_one.hide();
+ and.hide();
+ label_two.hide();
+ } else {
+ label_one.show();
+ and.hide();
+ label_two.hide();
+ }
+
+ // Set label text to date.
+ label_one.label = get_date_one().format(DATE_FORMAT);
+ label_two.label = get_date_two().format(DATE_FORMAT);;
+ }
+
+ public override Gtk.Widget get_widget() {
+ return box;
+ }
+
+ private DateTime get_date_one() {
+ return new DateTime.local(cal_one.year, cal_one.month + 1, cal_one.day, 0, 0, 0.0);
+ }
+
+ private DateTime get_date_two() {
+ return new DateTime.local(cal_two.year, cal_two.month + 1, cal_two.day, 0, 0, 0.0);
+ }
+
+ private void set_date_one(DateTime date) {
+ cal_one.day = date.get_day_of_month();
+ cal_one.month = date.get_month() - 1;
+ cal_one.year = date.get_year();
+ }
+
+ private void set_date_two(DateTime date) {
+ cal_two.day = date.get_day_of_month();
+ cal_two.month = date.get_month() - 1;
+ cal_two.year = date.get_year();
+ }
+
+ public override SearchCondition get_search_condition() {
+ SearchCondition.SearchType search_type = parent.get_search_type();
+ SearchConditionDate.Context search_context = (SearchConditionDate.Context) context.get_active();
+ SearchConditionDate c = new SearchConditionDate(search_type, search_context, get_date_one(),
+ get_date_two());
+ return c;
+ }
+
+ public override void populate(SearchCondition sc) {
+ SearchConditionDate? cond = sc as SearchConditionDate;
+ assert(cond != null);
+ context.set_active(cond.context);
+ set_date_one(cond.date_one);
+ set_date_two(cond.date_two);
+ update_date_labels();
+ }
+
+ public override bool is_complete() {
+ return true;
+ }
+
+ private void on_changed() {
+ parent.changed(parent);
+ update_date_labels();
+ }
+
+ private void popup_calendar(Gtk.Calendar cal) {
+ int orig_day = cal.day;
+ int orig_month = cal.month;
+ int orig_year = cal.year;
+ Gtk.Dialog d = new Gtk.Dialog.with_buttons(null, null,
+ Gtk.DialogFlags.MODAL, Gtk.Stock.CANCEL, Gtk.ResponseType.REJECT,
+ Gtk.Stock.OK, Gtk.ResponseType.ACCEPT);
+ d.set_modal(true);
+ d.set_resizable(false);
+ d.set_decorated(false);
+ ((Gtk.Box) d.get_content_area()).add(cal);
+ ulong id_1 = cal.day_selected.connect(()=>{update_date_labels();});
+ ulong id_2 = cal.day_selected_double_click.connect(()=>{d.close();});
+ d.show_all();
+ int res = d.run();
+ if (res != Gtk.ResponseType.ACCEPT) {
+ // User hit cancel, restore original date.
+ cal.day = orig_day;
+ cal.month = orig_month;
+ cal.year = orig_year;
+ }
+ cal.disconnect(id_1);
+ cal.disconnect(id_2);
+ d.destroy();
+ update_date_labels();
+ }
+
+ private void on_one_clicked() {
+ popup_calendar(cal_one);
+ }
+
+ private void on_two_clicked() {
+ popup_calendar(cal_two);
+ }
+ }
+
+ private Gtk.Builder builder;
+ private Gtk.Dialog dialog;
+ private Gtk.Button add_criteria;
+ private Gtk.ComboBoxText operator;
+ private Gtk.Box row_box;
+ private Gtk.Entry search_title;
+ private Gee.ArrayList<SearchRowContainer> row_list = new Gee.ArrayList<SearchRowContainer>();
+ private bool edit_mode = false;
+ private SavedSearch? previous_search = null;
+ private bool valid = false;
+
+ public SavedSearchDialog() {
+ setup_dialog();
+
+ // Default name.
+ search_title.set_text(SavedSearchTable.get_instance().generate_unique_name());
+ search_title.select_region(0, -1); // select all
+
+ // Default is text search.
+ add_text_search();
+ row_list.get(0).allow_removal(false);
+
+ // Add buttons for new search.
+ dialog.add_action_widget(new Gtk.Button.from_stock(Gtk.Stock.CANCEL), Gtk.ResponseType.CANCEL);
+ Gtk.Button ok_button = new Gtk.Button.from_stock(Gtk.Stock.OK);
+ ok_button.can_default = true;
+ dialog.add_action_widget(ok_button, Gtk.ResponseType.OK);
+ dialog.set_default_response(Gtk.ResponseType.OK);
+
+ dialog.show_all();
+ set_valid(false);
+ }
+
+ public SavedSearchDialog.edit_existing(SavedSearch saved_search) {
+ previous_search = saved_search;
+ edit_mode = true;
+ setup_dialog();
+
+ // Add close button.
+ Gtk.Button close_button = new Gtk.Button.from_stock(Gtk.Stock.CLOSE);
+ close_button.can_default = true;
+ dialog.add_action_widget(close_button, Gtk.ResponseType.OK);
+ dialog.set_default_response(Gtk.ResponseType.OK);
+
+ dialog.show_all();
+
+ // Load existing search into dialog.
+ operator.set_active((SearchOperator) saved_search.get_operator());
+ search_title.set_text(saved_search.get_name());
+ foreach (SearchCondition sc in saved_search.get_conditions()) {
+ add_row(new SearchRowContainer.edit_existing(sc));
+ }
+
+ if (row_list.size == 1)
+ row_list.get(0).allow_removal(false);
+
+ set_valid(true);
+ }
+
+ ~SavedSearchDialog() {
+ search_title.changed.disconnect(on_title_changed);
+ }
+
+ // Builds the dialog UI. Doesn't add buttons to the dialog or call dialog.show().
+ private void setup_dialog() {
+ builder = AppWindow.create_builder();
+
+ dialog = builder.get_object("Search criteria") as Gtk.Dialog;
+ dialog.set_parent_window(AppWindow.get_instance().get_parent_window());
+ dialog.set_transient_for(AppWindow.get_instance());
+ dialog.response.connect(on_response);
+
+ add_criteria = builder.get_object("Add search button") as Gtk.Button;
+ add_criteria.button_press_event.connect(on_add_criteria);
+
+ search_title = builder.get_object("Search title") as Gtk.Entry;
+ search_title.set_activates_default(true);
+ search_title.changed.connect(on_title_changed);
+
+ row_box = builder.get_object("row_box") as Gtk.Box;
+
+ operator = builder.get_object("Type of search criteria") as Gtk.ComboBoxText;
+ operator.append_text(_("any"));
+ operator.append_text(_("all"));
+ operator.append_text(_("none"));
+ operator.set_active(0);
+ }
+
+ // Displays the dialog.
+ public void show() {
+ dialog.run();
+ dialog.destroy();
+ }
+
+ // Adds a row of search criteria.
+ private bool on_add_criteria(Gdk.EventButton event) {
+ add_text_search();
+ return false;
+ }
+
+ private void add_text_search() {
+ SearchRowContainer text = new SearchRowContainer();
+ add_row(text);
+ }
+
+ // Appends a row of search criteria to the list and table.
+ private void add_row(SearchRowContainer row) {
+ if (row_list.size == 1)
+ row_list.get(0).allow_removal(true);
+ row_box.add(row.get_widget());
+ row_list.add(row);
+ row.remove.connect(on_remove_row);
+ row.changed.connect(on_row_changed);
+ set_valid(row.is_complete());
+ }
+
+ // Removes a row of search criteria.
+ private void on_remove_row(SearchRowContainer row) {
+ row.remove.disconnect(on_remove_row);
+ row.changed.disconnect(on_row_changed);
+ row_box.remove(row.get_widget());
+ row_list.remove(row);
+ if (row_list.size == 1)
+ row_list.get(0).allow_removal(false);
+ set_valid(true); // try setting to "true" since we removed a row
+ }
+
+ private void on_response(int response_id) {
+ if (response_id == Gtk.ResponseType.OK) {
+ if (SavedSearchTable.get_instance().exists(search_title.get_text()) &&
+ !(edit_mode && previous_search.get_name() == search_title.get_text())) {
+ AppWindow.error_message(Resources.rename_search_exists_message(search_title.get_text()));
+ return;
+ }
+
+ if (edit_mode) {
+ // Remove previous search.
+ SavedSearchTable.get_instance().remove(previous_search);
+ }
+
+ // Build the condition list from the search rows, and add our new saved search to the table.
+ Gee.ArrayList<SearchCondition> conditions = new Gee.ArrayList<SearchCondition>();
+ foreach (SearchRowContainer c in row_list) {
+ conditions.add(c.get_search_condition());
+ }
+
+ // Create the object. It will be added to the DB and SearchTable automatically.
+ SearchOperator search_operator = (SearchOperator)operator.get_active();
+ SavedSearchTable.get_instance().create(search_title.get_text(), search_operator, conditions);
+ }
+ }
+
+ private void on_row_changed(SearchRowContainer row) {
+ set_valid(row.is_complete());
+ }
+
+ private void on_title_changed() {
+ set_valid(is_title_valid());
+ }
+
+ private bool is_title_valid() {
+ if (edit_mode && previous_search != null &&
+ previous_search.get_name() == search_title.get_text())
+ return true; // Title hasn't changed.
+ if (search_title.get_text().chomp() == "")
+ return false;
+ if (SavedSearchTable.get_instance().exists(search_title.get_text()))
+ return false;
+ return true;
+ }
+
+ // Call this with your new value for validity whenever a row or the title changes.
+ private void set_valid(bool v) {
+ if (!v) {
+ valid = false;
+ } else if (v != valid) {
+ if (is_title_valid()) {
+ // Go through rows to check validity.
+ int valid_rows = 0;
+ foreach (SearchRowContainer c in row_list) {
+ if (c.is_complete())
+ valid_rows++;
+ }
+ valid = (valid_rows == row_list.size);
+ } else {
+ valid = false; // title was invalid
+ }
+ }
+
+ dialog.set_response_sensitive(Gtk.ResponseType.OK, valid);
+ }
+}