Imported Upstream version 0.18.1upstream/0.18.1

6 files changed, 2104 insertions, 0 deletions

diff --git a/src/searches/Branch.vala b/src/searches/Branch.vala
new file mode 100644
index 0000000..229c710
--- /dev/null
+++ b/src/searches/Branch.vala
@@ -0,0 +1,150 @@
+/* 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.
+ */
+
+public class Searches.Branch : Sidebar.Branch {
+    private Gee.HashMap<SavedSearch, Searches.SidebarEntry> entry_map = 
+        new Gee.HashMap<SavedSearch, Searches.SidebarEntry>();
+    
+    public Branch() {
+        base (new Searches.Grouping(),
+            Sidebar.Branch.Options.HIDE_IF_EMPTY
+                | Sidebar.Branch.Options.AUTO_OPEN_ON_NEW_CHILD
+                | Sidebar.Branch.Options.STARTUP_EXPAND_TO_FIRST_CHILD,
+            comparator);
+        
+        // seed the branch with existing searches
+        foreach (SavedSearch search in SavedSearchTable.get_instance().get_all())
+            on_saved_search_added(search);
+        
+        // monitor collection for future events
+        SavedSearchTable.get_instance().search_added.connect(on_saved_search_added);
+        SavedSearchTable.get_instance().search_removed.connect(on_saved_search_removed);
+    }
+    
+    ~Branch() {
+        SavedSearchTable.get_instance().search_added.disconnect(on_saved_search_added);
+        SavedSearchTable.get_instance().search_removed.disconnect(on_saved_search_removed);
+    }
+    
+    public Searches.SidebarEntry? get_entry_for_saved_search(SavedSearch search) {
+        return entry_map.get(search);
+    }
+    
+    private static int comparator(Sidebar.Entry a, Sidebar.Entry b) {
+        if (a == b)
+            return 0;
+        
+        return SavedSearch.compare_names(((Searches.SidebarEntry) a).for_saved_search(),
+            ((Searches.SidebarEntry) b).for_saved_search());
+    }
+    
+    private void on_saved_search_added(SavedSearch search) {
+        debug("search added");
+        Searches.SidebarEntry entry = new Searches.SidebarEntry(search);
+        entry_map.set(search, entry);
+        graft(get_root(), entry);
+    }
+    
+    private void on_saved_search_removed(SavedSearch search) {
+        debug("search removed");
+        Searches.SidebarEntry? entry = entry_map.get(search);
+        assert(entry != null);
+        
+        bool is_removed = entry_map.unset(search);
+        assert(is_removed);
+        
+        prune(entry);
+    }
+}
+
+public class Searches.Grouping : Sidebar.Grouping, Sidebar.Contextable {
+    private Gtk.UIManager ui = new Gtk.UIManager();
+    private Gtk.Menu? context_menu = null;
+    
+    public Grouping() {
+        base (_("Saved Searches"), new ThemedIcon(Gtk.Stock.FIND));
+        setup_context_menu();
+    }
+    
+    private void setup_context_menu() {
+        Gtk.ActionGroup group = new Gtk.ActionGroup("SidebarDefault");
+        Gtk.ActionEntry[] actions = new Gtk.ActionEntry[0];
+        
+        Gtk.ActionEntry new_search = { "CommonNewSearch", null, TRANSLATABLE, null, null, on_new_search };
+        new_search.label = _("Ne_w Saved Search...");
+        actions += new_search;
+        
+        group.add_actions(actions, this);
+        ui.insert_action_group(group, 0);
+        
+        File ui_file = Resources.get_ui("search_sidebar_context.ui");
+        try {
+            ui.add_ui_from_file(ui_file.get_path());
+        } catch (Error err) {
+            AppWindow.error_message("Error loading UI file %s: %s".printf(
+                ui_file.get_path(), err.message));
+            Application.get_instance().panic();
+        }
+        context_menu = (Gtk.Menu) ui.get_widget("/SidebarSearchContextMenu");
+        
+        ui.ensure_update();
+    }
+    
+    public Gtk.Menu? get_sidebar_context_menu(Gdk.EventButton? event) {
+        return context_menu;
+    }
+    
+    private void on_new_search() {
+        (new SavedSearchDialog()).show();
+    }
+}
+
+public class Searches.SidebarEntry : Sidebar.SimplePageEntry, Sidebar.RenameableEntry,
+    Sidebar.DestroyableEntry {
+    private static Icon single_search_icon;
+    
+    private SavedSearch search;
+    
+    public SidebarEntry(SavedSearch search) {
+        this.search = search;
+    }
+    
+    internal static void init() {
+        single_search_icon = new ThemedIcon(Gtk.Stock.FIND);
+    }
+    
+    internal static void terminate() {
+        single_search_icon = null;
+    }
+    
+    public SavedSearch for_saved_search() {
+        return search;
+    }
+    
+    public override string get_sidebar_name() {
+        return search.get_name();
+    }
+    
+    public override Icon? get_sidebar_icon() {
+        return single_search_icon;
+    }
+    
+    protected override Page create_page() {
+        return new SavedSearchPage(search);
+    }
+    
+    public void rename(string new_name) {
+        if (!SavedSearchTable.get_instance().exists(new_name))
+            AppWindow.get_command_manager().execute(new RenameSavedSearchCommand(search, new_name));
+        else if (new_name != search.get_name())
+            AppWindow.error_message(Resources.rename_search_exists_message(new_name));
+    }
+    
+    public void destroy_source() {
+        if (Dialogs.confirm_delete_saved_search(search))
+            AppWindow.get_command_manager().execute(new DeleteSavedSearchCommand(search));
+    }
+}
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);
+    }
+}
diff --git a/src/searches/SavedSearchPage.vala b/src/searches/SavedSearchPage.vala
new file mode 100644
index 0000000..8e6672e
--- /dev/null
+++ b/src/searches/SavedSearchPage.vala
@@ -0,0 +1,92 @@
+/* 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.
+ */
+
+// Source monitoring for saved searches.
+private class SavedSearchManager : CollectionViewManager {
+    SavedSearch search;
+    public SavedSearchManager(SavedSearchPage owner, SavedSearch search) {
+        base (owner);
+        this.search = search;
+    }
+    
+    public override bool include_in_view(DataSource source) {
+        return search.predicate((MediaSource) source);
+    }
+}
+
+// Page for displaying saved searches.
+public class SavedSearchPage : CollectionPage {
+
+    // The search logic and parameters are contained in the SavedSearch.
+    private SavedSearch search;
+    
+    public SavedSearchPage(SavedSearch search) {
+        base (search.get_name());
+        this.search = search;
+        
+        
+        foreach (MediaSourceCollection sources in MediaCollectionRegistry.get_instance().get_all())
+            get_view().monitor_source_collection(sources, new SavedSearchManager(this, search), null);
+        
+        init_page_context_menu("/SearchContextMenu");
+    }
+    
+    protected override void get_config_photos_sort(out bool sort_order, out int sort_by) {
+        Config.Facade.get_instance().get_library_photos_sort(out sort_order, out sort_by);
+    }
+    
+    protected override void set_config_photos_sort(bool sort_order, int sort_by) {
+        Config.Facade.get_instance().set_library_photos_sort(sort_order, sort_by);
+    }
+    
+    protected override void init_collect_ui_filenames(Gee.List<string> ui_filenames) {
+        base.init_collect_ui_filenames(ui_filenames);
+        ui_filenames.add("savedsearch.ui");
+    }
+    
+    protected override Gtk.ActionEntry[] init_collect_action_entries() {
+        Gtk.ActionEntry[] actions = base.init_collect_action_entries();
+        
+        Gtk.ActionEntry rename_search = { "RenameSearch", null, TRANSLATABLE, null, null, on_rename_search };
+        actions += rename_search;
+        
+        Gtk.ActionEntry edit_search = { "EditSearch", null, TRANSLATABLE, null, null, on_edit_search };
+        actions += edit_search;
+        
+        Gtk.ActionEntry delete_search = { "DeleteSearch", null, TRANSLATABLE, null, null, on_delete_search };
+        actions += delete_search;
+        
+        return actions;
+    }
+    
+    private void on_delete_search() {
+        if (Dialogs.confirm_delete_saved_search(search))
+            AppWindow.get_command_manager().execute(new DeleteSavedSearchCommand(search));
+    }
+    
+    private void on_rename_search() {
+        LibraryWindow.get_app().rename_search_in_sidebar(search);
+    }
+    
+    private void on_edit_search() {
+        SavedSearchDialog ssd = new SavedSearchDialog.edit_existing(search);
+        ssd.show();
+    }
+    
+    protected override void update_actions(int selected_count, int count) {
+        set_action_details("RenameSearch",
+            Resources.RENAME_SEARCH_MENU,
+            null, true);
+        set_action_details("EditSearch",
+            Resources.EDIT_SEARCH_MENU,
+            null, true);
+        set_action_details("DeleteSearch",
+            Resources.DELETE_SEARCH_MENU,
+            null, true);
+        base.update_actions(selected_count, count);
+    }
+}
+
diff --git a/src/searches/SearchBoolean.vala b/src/searches/SearchBoolean.vala
new file mode 100644
index 0000000..431e398
--- /dev/null
+++ b/src/searches/SearchBoolean.vala
@@ -0,0 +1,971 @@
+/* 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.
+ */
+
+// For specifying whether a search should be ORed (any) or ANDed (all).
+public enum SearchOperator {
+    ANY = 0,
+    ALL,
+    NONE;
+    
+    public string to_string() {
+        switch (this) {
+            case SearchOperator.ANY:
+                return "ANY";
+            
+            case SearchOperator.ALL:
+                return "ALL";
+            
+            case SearchOperator.NONE:
+                return "NONE";
+            
+            default:
+                error("unrecognized search operator enumeration value");
+        }
+    }
+    
+    public static SearchOperator from_string(string str) {
+        if (str == "ANY")
+            return SearchOperator.ANY;
+        
+        else if (str == "ALL")
+            return SearchOperator.ALL;
+        
+        else if (str == "NONE")
+            return SearchOperator.NONE;
+        
+        else
+            error("unrecognized search operator name: %s", str);
+    }
+}
+
+// Important note: if you are adding, removing, or otherwise changing
+// this table, you're going to have to modify SavedSearchDBTable.vala
+// as well.
+public abstract class SearchCondition {
+    // Type of search condition.
+    public enum SearchType {
+        ANY_TEXT = 0,
+        TITLE,
+        TAG,
+        EVENT_NAME,
+        FILE_NAME,
+        MEDIA_TYPE,
+        FLAG_STATE,
+        MODIFIED_STATE,
+        RATING,
+        COMMENT,
+        DATE;
+        // Note: when adding new types, be sure to update all functions below.
+        
+        public static SearchType[] as_array() {
+            return { ANY_TEXT, TITLE, TAG, COMMENT, EVENT_NAME, FILE_NAME, 
+                     MEDIA_TYPE, FLAG_STATE, MODIFIED_STATE, RATING, DATE };
+        }
+        
+        // Sorts an array alphabetically by display name.
+        public static void sort_array(ref SearchType[] array) {
+            Posix.qsort(array, array.length, sizeof(SearchType), (a, b) => {
+                return utf8_cs_compare(((*(SearchType*) a)).display_text(), 
+                    ((*(SearchType*) b)).display_text());
+            });
+        }
+        
+        public string to_string() {
+            switch (this) {
+                case SearchType.ANY_TEXT:
+                    return "ANY_TEXT";
+                
+                case SearchType.TITLE:
+                    return "TITLE";
+                
+                case SearchType.TAG:
+                    return "TAG";
+
+                case SearchType.COMMENT:
+                    return "COMMENT";
+                
+                case SearchType.EVENT_NAME:
+                    return "EVENT_NAME";
+                
+                case SearchType.FILE_NAME:
+                    return "FILE_NAME";
+                    
+                case SearchType.MEDIA_TYPE:
+                    return "MEDIA_TYPE";
+                
+                case SearchType.FLAG_STATE:
+                    return "FLAG_STATE";
+                
+                case SearchType.MODIFIED_STATE:
+                    return "MODIFIED_STATE";
+                
+                case SearchType.RATING:
+                    return "RATING";
+                
+                case SearchType.DATE:
+                    return "DATE";
+                
+                default:
+                    error("unrecognized search type enumeration value");
+            }
+        }
+        
+        public static SearchType from_string(string str) {
+            if (str == "ANY_TEXT")
+                return SearchType.ANY_TEXT;
+            
+            else if (str == "TITLE")
+                return SearchType.TITLE;
+            
+            else if (str == "TAG")
+                return SearchType.TAG;
+
+            else if (str == "COMMENT")
+                return SearchType.COMMENT;
+            
+            else if (str == "EVENT_NAME")
+                return SearchType.EVENT_NAME;
+            
+            else if (str == "FILE_NAME")
+                return SearchType.FILE_NAME;
+
+            else if (str == "MEDIA_TYPE")
+                return SearchType.MEDIA_TYPE;
+            
+            else if (str == "FLAG_STATE")
+                return SearchType.FLAG_STATE;
+            
+            else if (str == "MODIFIED_STATE")
+                return SearchType.MODIFIED_STATE;
+            
+            else if (str == "RATING")
+                return SearchType.RATING;
+            
+            else if (str == "DATE")
+                return SearchType.DATE;
+            
+            else
+                error("unrecognized search type name: %s", str);
+        }
+        
+        public string display_text() {
+            switch (this) {
+                case SearchType.ANY_TEXT:
+                    return _("Any text");
+                
+                case SearchType.TITLE:
+                    return _("Title");
+                
+                case SearchType.TAG:
+                    return _("Tag");
+                
+                case SearchType.COMMENT:
+                    return _("Comment");
+
+                case SearchType.EVENT_NAME:
+                    return _("Event name");
+                
+                case SearchType.FILE_NAME:
+                    return _("File name");
+
+                case SearchType.MEDIA_TYPE:
+                    return _("Media type");
+                
+                case SearchType.FLAG_STATE:
+                    return _("Flag state");
+                
+                case SearchType.MODIFIED_STATE:
+                    return _("Photo state");
+                
+                case SearchType.RATING:
+                    return _("Rating");
+                
+                case SearchType.DATE:
+                    return _("Date");
+                
+                default:
+                    error("unrecognized search type enumeration value");
+            }
+        }
+    }
+    
+    public SearchType search_type { get; protected set; }
+    
+    // Determines whether the source is included.
+    public abstract bool predicate(MediaSource source);
+}
+
+// Condition for text matching.
+public class SearchConditionText : SearchCondition {
+    public enum Context {
+        CONTAINS = 0,
+        IS_EXACTLY,
+        STARTS_WITH,
+        ENDS_WITH,
+        DOES_NOT_CONTAIN,
+        IS_NOT_SET;
+        
+        public string to_string() {
+            switch (this) {
+                case Context.CONTAINS:
+                    return "CONTAINS";
+                
+                case Context.IS_EXACTLY:
+                    return "IS_EXACTLY";
+                
+                case Context.STARTS_WITH:
+                    return "STARTS_WITH";
+                
+                case Context.ENDS_WITH:
+                    return "ENDS_WITH";
+                
+                case Context.DOES_NOT_CONTAIN:
+                    return "DOES_NOT_CONTAIN";
+                
+                case Context.IS_NOT_SET:
+                    return "IS_NOT_SET";
+                
+                default:
+                    error("unrecognized text search context enumeration value");
+            }
+        }
+        
+        public static Context from_string(string str) {
+            if (str == "CONTAINS")
+                return Context.CONTAINS;
+            
+            else if (str == "IS_EXACTLY")
+                return Context.IS_EXACTLY;
+            
+            else if (str == "STARTS_WITH")
+                return Context.STARTS_WITH;
+            
+            else if (str == "ENDS_WITH")
+                return Context.ENDS_WITH;
+            
+            else if (str == "DOES_NOT_CONTAIN")
+                return Context.DOES_NOT_CONTAIN;
+            
+            else if (str == "IS_NOT_SET")
+                return Context.IS_NOT_SET;
+            
+            else
+                error("unrecognized text search context name: %s", str);
+        }
+    }
+
+    // What to search for.
+    public string text { get; private set; }
+    
+    // How to match.
+    public Context context { get; private set; }
+    
+    public SearchConditionText(SearchCondition.SearchType search_type, string? text, Context context) {
+        this.search_type = search_type;
+        this.text = (text != null) ? String.remove_diacritics(text.down()) : "";
+        this.context = context;
+    }
+    
+    // Match string by context.
+    private bool string_match(string needle, string? haystack) {
+        switch (context) {
+            case Context.CONTAINS:
+            case Context.DOES_NOT_CONTAIN:
+                return !is_string_empty(haystack) && haystack.contains(needle);
+
+            case Context.IS_EXACTLY:
+                return !is_string_empty(haystack) && haystack == needle;
+                
+            case Context.STARTS_WITH:
+                return !is_string_empty(haystack) && haystack.has_prefix(needle);
+                
+            case Context.ENDS_WITH:
+                return !is_string_empty(haystack) && haystack.has_suffix(needle);
+
+            case Context.IS_NOT_SET:
+                return (is_string_empty(haystack));
+        }
+        
+        return false;
+    }
+    
+    // Determines whether the source is included.
+    public override bool predicate(MediaSource source) {
+        bool ret = false;
+        
+        // title
+        if (SearchType.ANY_TEXT == search_type || SearchType.TITLE == search_type) {
+            string title = source.get_title();
+            if(title != null){
+                ret |= string_match(text, String.remove_diacritics(title.down()));
+            }
+        }
+        
+        // tags
+        if (SearchType.ANY_TEXT == search_type || SearchType.TAG == search_type) {
+            Gee.List<Tag>? tag_list = Tag.global.fetch_for_source(source);
+            if (null != tag_list) {
+                string itag;
+                foreach (Tag tag in tag_list) {
+                    itag = tag.get_searchable_name().down(); // get_searchable already remove diacritics
+                    ret |= string_match(text, itag);
+                }
+            } else {
+                ret |= string_match(text, null); // for IS_NOT_SET
+            }
+        }
+        
+        // event name
+        if (SearchType.ANY_TEXT == search_type || SearchType.EVENT_NAME == search_type) {
+            string? event_name = (null != source.get_event()) ? 
+                String.remove_diacritics(source.get_event().get_name().down()) : null;
+            ret |= string_match(text, event_name);
+        }
+
+        // comment
+        if (SearchType.ANY_TEXT == search_type || SearchType.COMMENT == search_type) {
+            string? comment = source.get_comment();
+            if(null != comment)
+                ret |= string_match(text, String.remove_diacritics(comment.down()));
+        }
+        
+        // file name
+        if (SearchType.ANY_TEXT == search_type || SearchType.FILE_NAME == search_type) {
+            ret |= string_match(text, String.remove_diacritics(source.get_basename().down()));
+        }
+
+        return (context == Context.DOES_NOT_CONTAIN) ? !ret : ret;
+    }
+}
+
+// Condition for media type matching.
+public class SearchConditionMediaType : SearchCondition {
+    public enum Context {
+        IS = 0,
+        IS_NOT;
+        
+        public string to_string() {
+            switch (this) {
+                case Context.IS:
+                    return "IS";
+                
+                case Context.IS_NOT:
+                    return "IS_NOT";
+                
+                default:
+                    error("unrecognized media search context enumeration value");
+            }
+        }
+        
+        public static Context from_string(string str) {
+            if (str == "IS")
+                return Context.IS;
+            
+            else if (str == "IS_NOT")
+                return Context.IS_NOT;
+            
+            else
+                error("unrecognized media search context name: %s", str);
+        }
+    }
+    
+    public enum MediaType {
+        PHOTO_ALL = 0,
+        PHOTO_RAW,
+        VIDEO;
+        
+        public string to_string() {
+            switch (this) {
+                case MediaType.PHOTO_ALL:
+                    return "PHOTO_ALL";
+                
+                case MediaType.PHOTO_RAW:
+                    return "PHOTO_RAW";
+                
+                case MediaType.VIDEO:
+                    return "VIDEO";
+                
+                default:
+                    error("unrecognized media search type enumeration value");
+            }
+        }
+        
+        public static MediaType from_string(string str) {
+            if (str == "PHOTO_ALL")
+                return MediaType.PHOTO_ALL;
+            
+            else if (str == "PHOTO_RAW")
+                return MediaType.PHOTO_RAW;
+            
+            else if (str == "VIDEO")
+                return MediaType.VIDEO;
+            
+            else
+                error("unrecognized media search type name: %s", str);
+        }
+    }
+    
+    // What to search for.
+    public MediaType media_type { get; private set; }
+    
+    // How to match.
+    public Context context { get; private set; }
+    
+    public SearchConditionMediaType(SearchCondition.SearchType search_type, Context context, MediaType media_type) {
+        this.search_type = search_type;
+        this.context = context;
+        this.media_type = media_type;
+    }
+    
+    // Determines whether the source is included.
+    public override bool predicate(MediaSource source) {
+        // For the given type, check it against the MediaSource type
+        // and the given search context.
+        switch (media_type) {
+            case MediaType.PHOTO_ALL:
+                if (source is Photo)
+                    return context == Context.IS;
+                else
+                    return context == Context.IS_NOT;
+                    
+            case MediaType.PHOTO_RAW:
+                if (source is Photo && ((Photo) source).get_master_file_format() == PhotoFileFormat.RAW)
+                    return context == Context.IS;
+                else
+                    return context == Context.IS_NOT;
+                    
+            case MediaType.VIDEO:
+                if (source is VideoSource)
+                    return context == Context.IS;
+                else
+                    return context == Context.IS_NOT;
+                    
+            default:
+                    error("unrecognized media search type enumeration value");
+        }
+    }
+}
+
+// Condition for flag state matching.
+public class SearchConditionFlagged : SearchCondition {
+    public enum State {
+        FLAGGED = 0,
+        UNFLAGGED;
+        
+        public string to_string() {
+            switch (this) {
+                case State.FLAGGED:
+                    return "FLAGGED";
+                
+                case State.UNFLAGGED:
+                    return "UNFLAGGED";
+                
+                default:
+                    error("unrecognized flagged search state enumeration value");
+            }
+        }
+        
+        public static State from_string(string str) {
+            if (str == "FLAGGED")
+                return State.FLAGGED;
+            
+            else if (str == "UNFLAGGED")
+                return State.UNFLAGGED;
+            
+            else
+                error("unrecognized flagged search state name: %s", str);
+        }
+    }
+    
+    // What to match.
+    public State state { get; private set; }
+    
+    public SearchConditionFlagged(SearchCondition.SearchType search_type, State state) {
+        this.search_type = search_type;
+        this.state = state;
+    }
+    
+    // Determines whether the source is included.
+    public override bool predicate(MediaSource source) {
+        if (state == State.FLAGGED) {
+            return ((Flaggable) source).is_flagged();
+        } else if (state == State.UNFLAGGED) {
+            return !((Flaggable) source).is_flagged();
+        } else {
+            error("unrecognized flagged search state");
+        }
+    }
+}
+
+// Condition for modified state matching.
+public class SearchConditionModified : SearchCondition {
+
+    public enum Context {
+        HAS = 0,
+        HAS_NO;
+        
+        public string to_string() {
+            switch (this) {
+                case Context.HAS:
+                    return "HAS";
+                
+                case Context.HAS_NO:
+                    return "HAS_NO";
+                
+                default:
+                    error("unrecognized modified search context enumeration value");
+            }
+        }
+        
+        public static Context from_string(string str) {
+            if (str == "HAS")
+                return Context.HAS;
+            
+            else if (str == "HAS_NO")
+                return Context.HAS_NO;
+            
+            else
+                error("unrecognized modified search context name: %s", str);
+        }
+    }
+    
+    public enum State {
+        MODIFIED = 0,
+        INTERNAL_CHANGES,
+        EXTERNAL_CHANGES;
+        
+        public string to_string() {
+            switch (this) {
+                case State.MODIFIED:
+                    return "MODIFIED";
+                
+                case State.INTERNAL_CHANGES:
+                    return "INTERNAL_CHANGES";
+                    
+                 case State.EXTERNAL_CHANGES:
+                    return "EXTERNAL_CHANGES";
+                
+                default:
+                    error("unrecognized modified search state enumeration value");
+            }
+        }
+        
+        public static State from_string(string str) {
+            if (str == "MODIFIED")
+                return State.MODIFIED;
+            
+            else if (str == "INTERNAL_CHANGES")
+                return State.INTERNAL_CHANGES;
+                
+            else if (str == "EXTERNAL_CHANGES")
+                return State.EXTERNAL_CHANGES;
+            
+            else
+                error("unrecognized modified search state name: %s", str);
+        }
+    }
+
+    // What to match.
+    public State state { get; private set; }
+
+    // How to match.
+    public Context context { get; private set; }
+
+    public SearchConditionModified(SearchCondition.SearchType search_type, Context context, State state) {
+        this.search_type = search_type;
+        this.context = context;
+        this.state = state;
+    }
+    
+    // Determines whether the source is included.
+    public override bool predicate(MediaSource source) {
+        // check against state and the given search context.
+        Photo? photo = source as Photo;
+        if (photo == null)
+            return false;
+        
+        bool match;
+        if (state == State.MODIFIED)
+            match = photo.has_transformations() || photo.has_editable();
+        else if (state == State.INTERNAL_CHANGES)
+            match = photo.has_transformations();
+        else if (state == State.EXTERNAL_CHANGES)
+            match = photo.has_editable();
+        else
+            error("unrecognized modified search state");
+
+        if (match)
+            return context == Context.HAS;
+        else
+            return context == Context.HAS_NO;
+    }
+}
+
+
+// Condition for rating matching.
+public class SearchConditionRating : SearchCondition {
+    public enum Context {
+        AND_HIGHER = 0,
+        ONLY,
+        AND_LOWER;
+        
+        public string to_string() {
+            switch (this) {
+                case Context.AND_HIGHER:
+                    return "AND_HIGHER";
+                
+                case Context.ONLY:
+                    return "ONLY";
+                
+                case Context.AND_LOWER:
+                    return "AND_LOWER";
+                
+                default:
+                    error("unrecognized rating search context enumeration value");
+            }
+        }
+        
+        public static Context from_string(string str) {
+            if (str == "AND_HIGHER")
+                return Context.AND_HIGHER;
+            
+            else if (str == "ONLY")
+                return Context.ONLY;
+            
+            else if (str == "AND_LOWER")
+                return Context.AND_LOWER;
+            
+            else
+                error("unrecognized rating search context name: %s", str);
+        }
+    }
+    
+    // Rating to check against.
+    public Rating rating { get; private set; }
+    
+    // How to match.
+    public Context context { get; private set; }
+    
+    public SearchConditionRating(SearchCondition.SearchType search_type, Rating rating, Context context) {
+        this.search_type = search_type;
+        this.rating = rating;
+        this.context = context;
+    }
+    
+    // Determines whether the source is included.
+    public override bool predicate(MediaSource source) {
+        Rating source_rating = source.get_rating();
+        if (context == Context.AND_HIGHER)
+            return source_rating >= rating;
+        else if (context == Context.ONLY)
+            return source_rating == rating;
+        else if (context == Context.AND_LOWER)
+            return source_rating <= rating;
+        else
+            error("unknown rating search context");
+    }
+}
+
+
+// Condition for date range.
+public class SearchConditionDate : SearchCondition {
+    public enum Context {
+        EXACT = 0,
+        AFTER,
+        BEFORE,
+        BETWEEN,
+        IS_NOT_SET;
+        
+        public string to_string() {
+            switch (this) {
+                case Context.EXACT:
+                    return "EXACT";
+                
+                case Context.AFTER:
+                    return "AFTER";
+                
+                case Context.BEFORE:
+                    return "BEFORE";
+                
+                case Context.BETWEEN:
+                    return "BETWEEN";
+                    
+                case Context.IS_NOT_SET:
+                    return "IS_NOT_SET";
+                
+                default:
+                    error("unrecognized date search context enumeration value");
+            }
+        }
+        
+        public static Context from_string(string str) {
+            if (str == "EXACT")
+                return Context.EXACT;
+            
+            if (str == "AFTER")
+                return Context.AFTER;
+            
+            else if (str == "BEFORE")
+                return Context.BEFORE;
+            
+            else if (str == "BETWEEN")
+                return Context.BETWEEN;
+            
+            else if (str == "IS_NOT_SET")
+                return Context.IS_NOT_SET;
+            
+            else
+                error("unrecognized date search context name: %s", str);
+        }
+    }
+    
+    // Date to check against.  Second date only used for between searches.
+    public DateTime date_one { get; private set; }
+    public DateTime date_two { get; private set; }
+    
+    // How to match.
+    public Context context { get; private set; }
+    
+    public SearchConditionDate(SearchCondition.SearchType search_type, Context context, 
+        DateTime date_one, DateTime date_two) {
+        this.search_type = search_type;
+        this.context = context;
+        if (context != Context.BETWEEN || date_two.compare(date_one) >= 1) {
+            this.date_one = date_one;
+            this.date_two = date_two;
+        } else {
+            this.date_one = date_two;
+            this.date_two = date_one;
+        }
+       
+    }
+    
+    // Determines whether the source is included.
+    public override bool predicate(MediaSource source) {
+        time_t exposure_time = source.get_exposure_time();
+        if (exposure_time == 0)
+            return context == Context.IS_NOT_SET;
+        
+        DateTime dt = new DateTime.from_unix_local(exposure_time);
+        switch (context) {
+            case Context.EXACT:
+                DateTime second = date_one.add_days(1);
+                return (dt.compare(date_one) >= 0 && dt.compare(second) < 0);
+            
+            case Context.AFTER:
+                return (dt.compare(date_one) >= 0);
+            
+            case Context.BEFORE:
+                return (dt.compare(date_one) <= 0);
+            
+            case Context.BETWEEN:
+                DateTime second = date_two.add_days(1);
+                return (dt.compare(date_one) >= 0 && dt.compare(second) < 0);
+            
+            case Context.IS_NOT_SET:
+                return false; // Already checked above.
+            
+            default:
+                error("unrecognized date search context enumeration value");
+        }
+    }
+}
+
+// Contains the logic of a search.
+// A saved search requires a name, an AND/OR (all/any) operator, as well as a list of one or more conditions.
+public class SavedSearch : DataSource {
+    public const string TYPENAME = "saved_search";
+    
+    // Row from the database.
+    private SavedSearchRow row;
+    
+    public SavedSearch(SavedSearchRow row, int64 object_id = INVALID_OBJECT_ID) {
+        base (object_id);
+        
+        this.row = row;
+    }
+    
+    public override string get_name() {
+        return row.name;
+    }
+    
+    public override string to_string() {
+        return "SavedSearch " + get_name();
+    }
+    
+    public override string get_typename() {
+        return TYPENAME;
+    }
+    
+    public SavedSearchID get_saved_search_id() {
+        return row.search_id;
+    }
+
+    public override int64 get_instance_id() {
+        return get_saved_search_id().id;
+    }
+
+    public static int compare_names(void *a, void *b) {
+        SavedSearch *asearch = (SavedSearch *) a;
+        SavedSearch *bsearch = (SavedSearch *) b;
+        
+        return String.collated_compare(asearch->get_name(), bsearch->get_name());
+    }
+    
+    public bool predicate(MediaSource source) {
+        bool ret;
+        if (SearchOperator.ALL == row.operator || SearchOperator.NONE == row.operator)
+            ret = true;
+        else
+            ret = false; // assumes conditions.size() > 0
+        
+        foreach (SearchCondition c in row.conditions) {
+            if (SearchOperator.ALL == row.operator)
+                ret &= c.predicate(source);
+            else if (SearchOperator.ANY == row.operator)
+                ret |= c.predicate(source);
+            else if (SearchOperator.NONE == row.operator)
+                ret &= !c.predicate(source);
+        }
+        return ret;
+    }
+    
+    public void reconstitute() {
+        try {
+            row.search_id = SavedSearchDBTable.get_instance().create_from_row(row);
+        } catch (DatabaseError err) {
+            AppWindow.database_error(err);
+        }
+        
+        SavedSearchTable.get_instance().add_to_map(this);
+        debug("Reconstituted %s", to_string());
+    }
+    
+    // Returns false if the name already exists or a bad name.
+    public bool rename(string new_name) {
+        if (is_string_empty(new_name))
+            return false;
+        
+        if (SavedSearchTable.get_instance().exists(new_name))
+            return false;
+        
+        try {
+            SavedSearchDBTable.get_instance().rename(row.search_id, new_name);
+        } catch (DatabaseError err) {
+            AppWindow.database_error(err);
+            return false;
+        }
+        
+        SavedSearchTable.get_instance().remove_from_map(this);
+        row.name = new_name;
+        SavedSearchTable.get_instance().add_to_map(this);
+        
+        LibraryWindow.get_app().switch_to_saved_search(this);
+        return true;
+    }
+    
+    public Gee.List<SearchCondition> get_conditions() {
+        return row.conditions.read_only_view;
+    }
+    
+    public SearchOperator get_operator() {
+        return row.operator;
+    }
+}
+
+// This table contains every saved search.  It's the preferred way to add and destroy a saved 
+// search as well, since this table's create/destroy methods are tied to the database.
+public class SavedSearchTable {
+    private static SavedSearchTable? instance = null;
+    private Gee.HashMap<string, SavedSearch> search_map = new Gee.HashMap<string, SavedSearch>();
+
+    public signal void search_added(SavedSearch search);
+    public signal void search_removed(SavedSearch search);
+    
+    private SavedSearchTable() {
+        // Load existing searches from DB.
+        try {
+            foreach(SavedSearchRow row in SavedSearchDBTable.get_instance().get_all_rows())
+                add_to_map(new SavedSearch(row));
+        } catch (DatabaseError err) {
+            AppWindow.database_error(err);
+        }
+        
+    }
+    
+    public static SavedSearchTable get_instance() {
+        if (instance == null)
+            instance = new SavedSearchTable();
+        
+        return instance;
+    }
+    
+    public Gee.Collection<SavedSearch> get_all() {
+        return search_map.values;
+    }
+    
+    // Creates a saved search with the given name, operator, and conditions.  The saved search is
+    // added to the database and to this table.
+    public SavedSearch create(string name, SearchOperator operator, 
+        Gee.ArrayList<SearchCondition> conditions) {
+        SavedSearch? search = null;
+        // Create a new SavedSearch in the database.
+        try {
+            search = new SavedSearch(SavedSearchDBTable.get_instance().add(name, operator, conditions));
+        } catch (DatabaseError err) {
+            AppWindow.database_error(err);
+        }
+        
+        // Add search to table.
+        add_to_map(search);
+        LibraryWindow.get_app().switch_to_saved_search(search);
+        return search;
+    }
+    
+    // Removes a saved search, both from here and from the table.
+    public void remove(SavedSearch search) {
+        try {
+            SavedSearchDBTable.get_instance().remove(search.get_saved_search_id());
+        } catch (DatabaseError err) {
+            AppWindow.database_error(err);
+        }
+        
+        remove_from_map(search);
+    }
+    
+    public void add_to_map(SavedSearch search) {
+        search_map.set(search.get_name(), search);
+        search_added(search);
+    }
+    
+    public void remove_from_map(SavedSearch search) {
+        search_map.unset(search.get_name());
+        search_removed(search);
+    }
+    
+    public Gee.Iterable<SavedSearch> get_saved_searches() {
+        return search_map.values;
+    }
+    
+    public int get_count() {
+        return search_map.size;
+    }
+    
+    public bool exists(string search_name) {
+        return search_map.has_key(search_name);
+    }
+    
+    // Generate a unique search name (not thread safe)
+    public string generate_unique_name() {
+        for (int ctr = 1; ctr < int.MAX; ctr++) {
+            string name = "%s %d".printf(Resources.DEFAULT_SAVED_SEARCH_NAME, ctr);
+            
+            if (!exists(name))
+                return name;
+        }
+        return ""; // If all names are used (unlikely!)
+    }
+}
diff --git a/src/searches/Searches.vala b/src/searches/Searches.vala
new file mode 100644
index 0000000..478de86
--- /dev/null
+++ b/src/searches/Searches.vala
@@ -0,0 +1,31 @@
+/* Copyright 2011-2014 Yorba Foundation
+ *
+ * This software is licensed under the GNU Lesser General Public License
+ * (version 2.1 or later).  See the COPYING file in this distribution.
+ */
+
+/* This file is the master unit file for the Searches unit.  It should be edited to include
+ * whatever code is deemed necessary.
+ *
+ * The init() and terminate() methods are mandatory.
+ *
+ * If the unit needs to be configured prior to initialization, add the proper parameters to
+ * the preconfigure() method, implement it, and ensure in init() that it's been called.
+ */
+
+namespace Searches {
+
+// preconfigure may be deleted if not used.
+public void preconfigure() {
+}
+
+public void init() throws Error {
+    Searches.SidebarEntry.init();
+}
+
+public void terminate() {
+    Searches.SidebarEntry.terminate();
+}
+
+}
+
diff --git a/src/searches/mk/searches.mk b/src/searches/mk/searches.mk
new file mode 100644
index 0000000..6df4b5d
--- /dev/null
+++ b/src/searches/mk/searches.mk
@@ -0,0 +1,31 @@
+
+# UNIT_NAME is the Vala namespace.  A file named UNIT_NAME.vala must be in this directory with
+# a init() and terminate() function declared in the namespace.
+UNIT_NAME := Searches
+
+# UNIT_DIR should match the subdirectory the files are located in.  Generally UNIT_NAME in all
+# lowercase.  The name of this file should be UNIT_DIR.mk.
+UNIT_DIR := searches
+
+# All Vala files in the unit should be listed here with no subdirectory prefix.
+#
+# NOTE: Do *not* include the unit's master file, i.e. UNIT_NAME.vala.
+UNIT_FILES := \
+	Branch.vala \
+	SearchBoolean.vala \
+	SavedSearchPage.vala \
+	SavedSearchDialog.vala
+
+# Any unit this unit relies upon (and should be initialized before it's initialized) should
+# be listed here using its Vala namespace.
+#
+# NOTE: All units are assumed to rely upon the unit-unit.  Do not include that here.
+UNIT_USES :=
+
+# List any additional files that are used in the build process as a part of this unit that should
+# be packaged in the tarball.  File names should be relative to the unit's home directory.
+UNIT_RC :=
+
+# unitize.mk must be called at the end of each UNIT_DIR.mk file.
+include unitize.mk
+