Imported Upstream version 0.18.1upstream/0.18.1

1 files changed, 1308 insertions, 0 deletions

diff --git a/src/MediaPage.vala b/src/MediaPage.vala
new file mode 100644
index 0000000..4d7ee2a
--- /dev/null
+++ b/src/MediaPage.vala
@@ -0,0 +1,1308 @@
+/* Copyright 2010-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 MediaSourceItem : CheckerboardItem {
+    private static Gdk.Pixbuf basis_sprocket_pixbuf = null;
+    private static Gdk.Pixbuf current_sprocket_pixbuf = null;
+
+    private bool enable_sprockets = false;
+
+    // preserve the same constructor arguments and semantics as CheckerboardItem so that we're
+    // a drop-in replacement
+    public MediaSourceItem(ThumbnailSource source, Dimensions initial_pixbuf_dim, string title, 
+        string? comment, bool marked_up = false, Pango.Alignment alignment = Pango.Alignment.LEFT) {
+        base(source, initial_pixbuf_dim, title, comment, marked_up, alignment);
+        if (basis_sprocket_pixbuf == null)
+            basis_sprocket_pixbuf = Resources.load_icon("sprocket.png", 0);
+    }
+
+    protected override void paint_image(Cairo.Context ctx, Gdk.Pixbuf pixbuf,
+        Gdk.Point origin) {
+        Dimensions pixbuf_dim = Dimensions.for_pixbuf(pixbuf);
+        // sprocket geometry calculation (and possible adjustment) has to occur before we call
+        // base.paint_image( ) because the base-class method needs the correct trinket horizontal
+        // offset
+        
+        if (!enable_sprockets) {
+            set_horizontal_trinket_offset(0);
+        } else {
+            double reduction_factor = ((double) pixbuf_dim.major_axis()) /
+                ((double) ThumbnailCache.Size.LARGEST);
+            int reduced_size = (int) (reduction_factor * basis_sprocket_pixbuf.width);
+
+            if (current_sprocket_pixbuf == null || reduced_size != current_sprocket_pixbuf.width) {
+                current_sprocket_pixbuf = basis_sprocket_pixbuf.scale_simple(reduced_size,
+                    reduced_size, Gdk.InterpType.HYPER);
+            }
+
+            set_horizontal_trinket_offset(current_sprocket_pixbuf.width);
+        }
+                
+        base.paint_image(ctx, pixbuf, origin);
+
+        if (enable_sprockets) {
+            paint_sprockets(ctx, origin, pixbuf_dim);
+        }
+    }
+
+    protected void paint_one_sprocket(Cairo.Context ctx, Gdk.Point origin) {
+        ctx.save();
+        Gdk.cairo_set_source_pixbuf(ctx, current_sprocket_pixbuf, origin.x, origin.y);
+        ctx.paint();
+        ctx.restore();
+    }
+
+    protected void paint_sprockets(Cairo.Context ctx, Gdk.Point item_origin,
+        Dimensions item_dimensions) {
+        int num_sprockets = item_dimensions.height / current_sprocket_pixbuf.height;
+
+        Gdk.Point left_paint_location = item_origin;
+        Gdk.Point right_paint_location = item_origin;
+        right_paint_location.x += (item_dimensions.width - current_sprocket_pixbuf.width);
+        for (int i = 0; i < num_sprockets; i++) {
+            paint_one_sprocket(ctx, left_paint_location);
+            paint_one_sprocket(ctx, right_paint_location);
+
+            left_paint_location.y += current_sprocket_pixbuf.height;
+            right_paint_location.y += current_sprocket_pixbuf.height;
+        }
+
+        int straggler_pixels = item_dimensions.height % current_sprocket_pixbuf.height;
+        if (straggler_pixels > 0) {
+            ctx.save();
+
+            Gdk.cairo_set_source_pixbuf(ctx, current_sprocket_pixbuf, left_paint_location.x,
+                left_paint_location.y);
+            ctx.rectangle(left_paint_location.x, left_paint_location.y,
+                current_sprocket_pixbuf.get_width(), straggler_pixels);
+            ctx.fill();
+
+            Gdk.cairo_set_source_pixbuf(ctx, current_sprocket_pixbuf, right_paint_location.x,
+                right_paint_location.y);
+            ctx.rectangle(right_paint_location.x, right_paint_location.y,
+                current_sprocket_pixbuf.get_width(), straggler_pixels);
+            ctx.fill();
+
+            ctx.restore();
+        }
+    }
+    
+    public void set_enable_sprockets(bool enable_sprockets) {
+        this.enable_sprockets = enable_sprockets;
+    }
+}
+
+public abstract class MediaPage : CheckerboardPage {
+    public const int SORT_ORDER_ASCENDING = 0;
+    public const int SORT_ORDER_DESCENDING = 1;
+
+    // steppings should divide evenly into (Thumbnail.MAX_SCALE - Thumbnail.MIN_SCALE)
+    public const int MANUAL_STEPPING = 16;
+    public const int SLIDER_STEPPING = 4;
+
+    public enum SortBy {
+        MIN = 1,
+        TITLE = 1,
+        EXPOSURE_DATE = 2,
+        RATING = 3,
+        MAX = 3
+    }
+
+    protected class ZoomSliderAssembly : Gtk.ToolItem {
+        private Gtk.Scale slider;
+        private Gtk.Adjustment adjustment;
+        
+        public signal void zoom_changed();
+
+        public ZoomSliderAssembly() {
+            Gtk.Box zoom_group = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 0);
+
+            Gtk.Image zoom_out = new Gtk.Image.from_pixbuf(Resources.load_icon(
+                Resources.ICON_ZOOM_OUT, Resources.ICON_ZOOM_SCALE));
+            Gtk.EventBox zoom_out_box = new Gtk.EventBox();
+            zoom_out_box.set_above_child(true);
+            zoom_out_box.set_visible_window(false);
+            zoom_out_box.add(zoom_out);
+            zoom_out_box.button_press_event.connect(on_zoom_out_pressed);
+            
+            zoom_group.pack_start(zoom_out_box, false, false, 0);
+
+            // virgin ZoomSliderAssemblies are created such that they have whatever value is
+            // persisted in the configuration system for the photo thumbnail scale
+            int persisted_scale = Config.Facade.get_instance().get_photo_thumbnail_scale();
+            adjustment = new Gtk.Adjustment(ZoomSliderAssembly.scale_to_slider(persisted_scale), 0,
+                ZoomSliderAssembly.scale_to_slider(Thumbnail.MAX_SCALE), 1, 10, 0);
+
+            slider = new Gtk.Scale(Gtk.Orientation.HORIZONTAL, adjustment);
+            slider.value_changed.connect(on_slider_changed);
+            slider.set_draw_value(false);
+            slider.set_size_request(200, -1);
+            slider.set_tooltip_text(_("Adjust the size of the thumbnails"));
+
+            zoom_group.pack_start(slider, false, false, 0);
+
+            Gtk.Image zoom_in = new Gtk.Image.from_pixbuf(Resources.load_icon(
+                Resources.ICON_ZOOM_IN, Resources.ICON_ZOOM_SCALE));
+            Gtk.EventBox zoom_in_box = new Gtk.EventBox();
+            zoom_in_box.set_above_child(true);
+            zoom_in_box.set_visible_window(false);
+            zoom_in_box.add(zoom_in);
+            zoom_in_box.button_press_event.connect(on_zoom_in_pressed);
+
+            zoom_group.pack_start(zoom_in_box, false, false, 0);
+
+            add(zoom_group);
+        }
+        
+        public static double scale_to_slider(int value) {
+            assert(value >= Thumbnail.MIN_SCALE);
+            assert(value <= Thumbnail.MAX_SCALE);
+            
+            return (double) ((value - Thumbnail.MIN_SCALE) / SLIDER_STEPPING);
+        }
+
+        public static int slider_to_scale(double value) {
+            int res = ((int) (value * SLIDER_STEPPING)) + Thumbnail.MIN_SCALE;
+
+            assert(res >= Thumbnail.MIN_SCALE);
+            assert(res <= Thumbnail.MAX_SCALE);
+            
+            return res;
+        }
+
+        private bool on_zoom_out_pressed(Gdk.EventButton event) {
+            snap_to_min();
+            return true;
+        }
+        
+        private bool on_zoom_in_pressed(Gdk.EventButton event) {
+            snap_to_max();
+            return true;
+        }
+        
+        private void on_slider_changed() {
+            zoom_changed();
+        }
+        
+        public void snap_to_min() {
+            slider.set_value(scale_to_slider(Thumbnail.MIN_SCALE));
+        }
+
+        public void snap_to_max() {
+            slider.set_value(scale_to_slider(Thumbnail.MAX_SCALE));
+        }
+        
+        public void increase_step() {
+            int new_scale = compute_zoom_scale_increase(get_scale());
+
+            if (get_scale() == new_scale)
+                return;
+
+            slider.set_value(scale_to_slider(new_scale));
+        }
+        
+        public void decrease_step() {
+            int new_scale = compute_zoom_scale_decrease(get_scale());
+
+            if (get_scale() == new_scale)
+                return;
+            
+            slider.set_value(scale_to_slider(new_scale));
+        }
+        
+        public int get_scale() {
+            return slider_to_scale(slider.get_value());
+        }
+        
+        public void set_scale(int scale) {
+            if (get_scale() == scale)
+                return;
+
+            slider.set_value(scale_to_slider(scale));
+        }
+    }
+    
+    private ZoomSliderAssembly? connected_slider = null;
+    private DragAndDropHandler dnd_handler = null;
+    private MediaViewTracker tracker;
+    
+    public MediaPage(string page_name) {
+        base (page_name);
+        
+        tracker = new MediaViewTracker(get_view());
+        
+        get_view().items_altered.connect(on_media_altered);
+
+        get_view().freeze_notifications();
+        get_view().set_property(CheckerboardItem.PROP_SHOW_TITLES, 
+            Config.Facade.get_instance().get_display_photo_titles());
+        get_view().set_property(CheckerboardItem.PROP_SHOW_COMMENTS, 
+            Config.Facade.get_instance().get_display_photo_comments());
+        get_view().set_property(Thumbnail.PROP_SHOW_TAGS, 
+            Config.Facade.get_instance().get_display_photo_tags());
+        get_view().set_property(Thumbnail.PROP_SIZE, get_thumb_size());
+        get_view().set_property(Thumbnail.PROP_SHOW_RATINGS,
+            Config.Facade.get_instance().get_display_photo_ratings());
+        get_view().thaw_notifications();
+
+        // enable drag-and-drop export of media
+        dnd_handler = new DragAndDropHandler(this);
+    }
+   
+    private static int compute_zoom_scale_increase(int current_scale) {
+        int new_scale = current_scale + MANUAL_STEPPING;
+        return new_scale.clamp(Thumbnail.MIN_SCALE, Thumbnail.MAX_SCALE);
+    }
+    
+    private static int compute_zoom_scale_decrease(int current_scale) {
+        int new_scale = current_scale - MANUAL_STEPPING;
+        return new_scale.clamp(Thumbnail.MIN_SCALE, Thumbnail.MAX_SCALE);
+    }
+    
+    protected override void init_collect_ui_filenames(Gee.List<string> ui_filenames) {
+        base.init_collect_ui_filenames(ui_filenames);
+        
+        ui_filenames.add("media.ui");
+    }
+    
+    protected override Gtk.ActionEntry[] init_collect_action_entries() {
+        Gtk.ActionEntry[] actions = base.init_collect_action_entries();
+        
+        Gtk.ActionEntry export = { "Export", Gtk.Stock.SAVE_AS, TRANSLATABLE, "<Ctrl><Shift>E",
+            TRANSLATABLE, on_export };
+        export.label = Resources.EXPORT_MENU;
+        actions += export;
+
+        Gtk.ActionEntry send_to = { "SendTo", "document-send", TRANSLATABLE, null, 
+            TRANSLATABLE, on_send_to };
+        send_to.label = Resources.SEND_TO_MENU;
+        actions += send_to;
+
+        // This is identical to the above action, except that it has different 
+        // mnemonics and is _only_ for use in the context menu.
+        Gtk.ActionEntry send_to_context_menu = { "SendToContextMenu", "document-send", TRANSLATABLE, null,
+            TRANSLATABLE, on_send_to };
+        send_to_context_menu.label = Resources.SEND_TO_CONTEXT_MENU;
+        actions += send_to_context_menu;
+        
+        Gtk.ActionEntry remove_from_library = { "RemoveFromLibrary", Gtk.Stock.REMOVE, TRANSLATABLE,
+            "<Shift>Delete", TRANSLATABLE, on_remove_from_library };
+        remove_from_library.label = Resources.REMOVE_FROM_LIBRARY_MENU;
+        actions += remove_from_library;
+        
+        Gtk.ActionEntry move_to_trash = { "MoveToTrash", "user-trash-full", TRANSLATABLE, "Delete",
+            TRANSLATABLE, on_move_to_trash };
+        move_to_trash.label = Resources.MOVE_TO_TRASH_MENU;
+        actions += move_to_trash;
+        
+        Gtk.ActionEntry new_event = { "NewEvent", Gtk.Stock.NEW, TRANSLATABLE, "<Ctrl>N",
+            TRANSLATABLE, on_new_event };
+        new_event.label = Resources.NEW_EVENT_MENU;
+        actions += new_event;
+
+        Gtk.ActionEntry add_tags = { "AddTags", null, TRANSLATABLE, "<Ctrl>T", TRANSLATABLE, 
+            on_add_tags };
+        add_tags.label = Resources.ADD_TAGS_MENU;
+        actions += add_tags;
+
+        // This is identical to the above action, except that it has different 
+        // mnemonics and is _only_ for use in the context menu.
+        Gtk.ActionEntry add_tags_context_menu = { "AddTagsContextMenu", null, TRANSLATABLE, "<Ctrl>A", TRANSLATABLE,
+            on_add_tags };
+        add_tags_context_menu.label = Resources.ADD_TAGS_CONTEXT_MENU;
+        actions += add_tags_context_menu;
+
+        Gtk.ActionEntry modify_tags = { "ModifyTags", null, TRANSLATABLE, "<Ctrl>M", TRANSLATABLE, 
+            on_modify_tags };
+        modify_tags.label = Resources.MODIFY_TAGS_MENU;
+        actions += modify_tags;
+
+        Gtk.ActionEntry increase_size = { "IncreaseSize", Gtk.Stock.ZOOM_IN, TRANSLATABLE,
+            "<Ctrl>plus", TRANSLATABLE, on_increase_size };
+        increase_size.label = _("Zoom _In");
+        increase_size.tooltip = _("Increase the magnification of the thumbnails");
+        actions += increase_size;
+
+        Gtk.ActionEntry decrease_size = { "DecreaseSize", Gtk.Stock.ZOOM_OUT, TRANSLATABLE,
+            "<Ctrl>minus", TRANSLATABLE, on_decrease_size };
+        decrease_size.label = _("Zoom _Out");
+        decrease_size.tooltip = _("Decrease the magnification of the thumbnails");
+        actions += decrease_size;
+        
+        Gtk.ActionEntry flag = { "Flag", null, TRANSLATABLE, "<Ctrl>G", TRANSLATABLE, on_flag_unflag };
+        flag.label = Resources.FLAG_MENU;
+        actions += flag;
+        
+        Gtk.ActionEntry set_rating = { "Rate", null, TRANSLATABLE, null, null, null };
+        set_rating.label = Resources.RATING_MENU;
+        actions += set_rating;
+
+        Gtk.ActionEntry increase_rating = { "IncreaseRating", null, TRANSLATABLE, 
+            "greater", TRANSLATABLE, on_increase_rating };
+        increase_rating.label = Resources.INCREASE_RATING_MENU;
+        actions += increase_rating;
+
+        Gtk.ActionEntry decrease_rating = { "DecreaseRating", null, TRANSLATABLE, 
+            "less", TRANSLATABLE, on_decrease_rating };
+        decrease_rating.label = Resources.DECREASE_RATING_MENU;
+        actions += decrease_rating;
+
+        Gtk.ActionEntry rate_rejected = { "RateRejected", null, TRANSLATABLE, 
+            "9", TRANSLATABLE, on_rate_rejected };
+        rate_rejected.label = Resources.rating_menu(Rating.REJECTED);
+        actions += rate_rejected;
+
+        Gtk.ActionEntry rate_unrated = { "RateUnrated", null, TRANSLATABLE, 
+            "0", TRANSLATABLE, on_rate_unrated };
+        rate_unrated.label = Resources.rating_menu(Rating.UNRATED);
+        actions += rate_unrated;
+
+        Gtk.ActionEntry rate_one = { "RateOne", null, TRANSLATABLE, 
+            "1", TRANSLATABLE, on_rate_one };
+        rate_one.label = Resources.rating_menu(Rating.ONE);
+        actions += rate_one;
+
+        Gtk.ActionEntry rate_two = { "RateTwo", null, TRANSLATABLE, 
+            "2", TRANSLATABLE, on_rate_two };
+        rate_two.label = Resources.rating_menu(Rating.TWO);
+        actions += rate_two;
+
+        Gtk.ActionEntry rate_three = { "RateThree", null, TRANSLATABLE, 
+            "3", TRANSLATABLE, on_rate_three };
+        rate_three.label = Resources.rating_menu(Rating.THREE);
+        actions += rate_three;
+
+        Gtk.ActionEntry rate_four = { "RateFour", null, TRANSLATABLE, 
+            "4", TRANSLATABLE, on_rate_four };
+        rate_four.label = Resources.rating_menu(Rating.FOUR);
+        actions += rate_four;
+
+        Gtk.ActionEntry rate_five = { "RateFive", null, TRANSLATABLE, 
+            "5", TRANSLATABLE, on_rate_five };
+        rate_five.label = Resources.rating_menu(Rating.FIVE);
+        actions += rate_five;
+
+        Gtk.ActionEntry edit_title = { "EditTitle", null, TRANSLATABLE, "F2", TRANSLATABLE,
+            on_edit_title };
+        edit_title.label = Resources.EDIT_TITLE_MENU;
+        actions += edit_title;
+
+        Gtk.ActionEntry edit_comment = { "EditComment", null, TRANSLATABLE, "F3", TRANSLATABLE,
+            on_edit_comment };
+        edit_comment.label = Resources.EDIT_COMMENT_MENU;
+        actions += edit_comment;
+
+        Gtk.ActionEntry sort_photos = { "SortPhotos", null, TRANSLATABLE, null, null, null };
+        sort_photos.label = _("Sort _Photos");
+        actions += sort_photos;
+
+        Gtk.ActionEntry filter_photos = { "FilterPhotos", null, TRANSLATABLE, null, null, null };
+        filter_photos.label = Resources.FILTER_PHOTOS_MENU;
+        actions += filter_photos;
+        
+        Gtk.ActionEntry play = { "PlayVideo", Gtk.Stock.MEDIA_PLAY, TRANSLATABLE, "<Ctrl>Y",
+            TRANSLATABLE, on_play_video };
+        play.label = _("_Play Video");
+        play.tooltip = _("Open the selected videos in the system video player");
+        actions += play;
+        
+        Gtk.ActionEntry raw_developer = { "RawDeveloper", null, TRANSLATABLE, null, null, null };
+        raw_developer.label = _("_Developer");
+        actions += raw_developer;
+        
+        // RAW developers.
+        
+        Gtk.ActionEntry dev_shotwell = { "RawDeveloperShotwell", null, TRANSLATABLE, null, TRANSLATABLE,
+            on_raw_developer_shotwell };
+        dev_shotwell.label = _("Shotwell");
+        actions += dev_shotwell;
+        
+        Gtk.ActionEntry dev_camera = { "RawDeveloperCamera", null, TRANSLATABLE, null, TRANSLATABLE,
+            on_raw_developer_camera };
+        dev_camera.label = _("Camera");
+        actions += dev_camera;
+
+        return actions;
+    }
+    
+    protected override Gtk.ToggleActionEntry[] init_collect_toggle_action_entries() {
+        Gtk.ToggleActionEntry[] toggle_actions = base.init_collect_toggle_action_entries();
+        
+        Gtk.ToggleActionEntry titles = { "ViewTitle", null, TRANSLATABLE, "<Ctrl><Shift>T",
+            TRANSLATABLE, on_display_titles, Config.Facade.get_instance().get_display_photo_titles() };
+        titles.label = _("_Titles");
+        titles.tooltip = _("Display the title of each photo");
+        toggle_actions += titles;
+        
+        Gtk.ToggleActionEntry comments = { "ViewComment", null, TRANSLATABLE, "<Ctrl><Shift>C",
+            TRANSLATABLE, on_display_comments, Config.Facade.get_instance().get_display_photo_comments() };
+        comments.label = _("_Comments");
+        comments.tooltip = _("Display the comment of each photo");
+        toggle_actions += comments;
+        
+        Gtk.ToggleActionEntry ratings = { "ViewRatings", null, TRANSLATABLE, "<Ctrl><Shift>N",
+            TRANSLATABLE, on_display_ratings, Config.Facade.get_instance().get_display_photo_ratings() };
+        ratings.label = Resources.VIEW_RATINGS_MENU;
+        ratings.tooltip = Resources.VIEW_RATINGS_TOOLTIP;
+        toggle_actions += ratings;
+
+        Gtk.ToggleActionEntry tags = { "ViewTags", null, TRANSLATABLE, "<Ctrl><Shift>G",
+            TRANSLATABLE, on_display_tags, Config.Facade.get_instance().get_display_photo_tags() };
+        tags.label = _("Ta_gs");
+        tags.tooltip = _("Display each photo's tags");
+        toggle_actions += tags;
+        
+        return toggle_actions;
+    }
+    
+    protected override void register_radio_actions(Gtk.ActionGroup action_group) {
+        bool sort_order;
+        int sort_by;
+        get_config_photos_sort(out sort_order, out sort_by);
+        
+        // Sort criteria.
+        Gtk.RadioActionEntry[] sort_crit_actions = new Gtk.RadioActionEntry[0];
+        
+        Gtk.RadioActionEntry by_title = { "SortByTitle", null, TRANSLATABLE, null, TRANSLATABLE,
+            SortBy.TITLE };
+        by_title.label = _("By _Title");
+        by_title.tooltip = _("Sort photos by title");
+        sort_crit_actions += by_title;
+        
+        Gtk.RadioActionEntry by_date = { "SortByExposureDate", null, TRANSLATABLE, null,
+            TRANSLATABLE, SortBy.EXPOSURE_DATE };
+        by_date.label = _("By Exposure _Date");
+        by_date.tooltip = _("Sort photos by exposure date");
+        sort_crit_actions += by_date;
+        
+        Gtk.RadioActionEntry by_rating = { "SortByRating", null, TRANSLATABLE, null,
+            TRANSLATABLE, SortBy.RATING };
+        by_rating.label = _("By _Rating");
+        by_rating.tooltip = _("Sort photos by rating");
+        sort_crit_actions += by_rating;
+        
+        action_group.add_radio_actions(sort_crit_actions, sort_by, on_sort_changed);
+        
+        // Sort order.
+        Gtk.RadioActionEntry[] sort_order_actions = new Gtk.RadioActionEntry[0];
+        
+        Gtk.RadioActionEntry ascending = { "SortAscending", Gtk.Stock.SORT_ASCENDING,
+            TRANSLATABLE, null, TRANSLATABLE, SORT_ORDER_ASCENDING };
+        ascending.label = _("_Ascending");
+        ascending.tooltip = _("Sort photos in an ascending order");
+        sort_order_actions += ascending;
+        
+        Gtk.RadioActionEntry descending = { "SortDescending", Gtk.Stock.SORT_DESCENDING,
+            TRANSLATABLE, null, TRANSLATABLE, SORT_ORDER_DESCENDING };
+        descending.label = _("D_escending");
+        descending.tooltip = _("Sort photos in a descending order");
+        sort_order_actions += descending;
+        
+        action_group.add_radio_actions(sort_order_actions,
+            sort_order ? SORT_ORDER_ASCENDING : SORT_ORDER_DESCENDING, on_sort_changed);
+        
+        base.register_radio_actions(action_group);
+    }
+    
+    protected override void update_actions(int selected_count, int count) {
+        set_action_sensitive("Export", selected_count > 0);
+        set_action_sensitive("EditTitle", selected_count > 0);
+        set_action_sensitive("EditComment", selected_count > 0);
+        set_action_sensitive("IncreaseSize", get_thumb_size() < Thumbnail.MAX_SCALE);
+        set_action_sensitive("DecreaseSize", get_thumb_size() > Thumbnail.MIN_SCALE);
+        set_action_sensitive("RemoveFromLibrary", selected_count > 0);
+        set_action_sensitive("MoveToTrash", selected_count > 0);
+        
+        if (DesktopIntegration.is_send_to_installed())
+            set_action_sensitive("SendTo", selected_count > 0);
+        else
+            set_action_visible("SendTo", false);
+        
+        set_action_sensitive("Rate", selected_count > 0);
+        update_rating_sensitivities();
+        
+        update_development_menu_item_sensitivity();
+        
+        set_action_sensitive("PlayVideo", selected_count == 1
+            && get_view().get_selected_source_at(0) is Video);
+        
+        update_flag_action(selected_count);
+        
+        base.update_actions(selected_count, count);
+    }
+    
+    private void on_media_altered(Gee.Map<DataObject, Alteration> altered) {
+        foreach (DataObject object in altered.keys) {
+            if (altered.get(object).has_detail("metadata", "flagged")) {
+                update_flag_action(get_view().get_selected_count());
+                
+                break;
+            }
+        }
+    }
+    
+    private void update_rating_sensitivities() {
+        set_action_sensitive("RateRejected", can_rate_selected(Rating.REJECTED));
+        set_action_sensitive("RateUnrated", can_rate_selected(Rating.UNRATED));
+        set_action_sensitive("RateOne", can_rate_selected(Rating.ONE));
+        set_action_sensitive("RateTwo", can_rate_selected(Rating.TWO));
+        set_action_sensitive("RateThree", can_rate_selected(Rating.THREE));
+        set_action_sensitive("RateFour", can_rate_selected(Rating.FOUR));
+        set_action_sensitive("RateFive", can_rate_selected(Rating.FIVE));
+        set_action_sensitive("IncreaseRating", can_increase_selected_rating());
+        set_action_sensitive("DecreaseRating", can_decrease_selected_rating());
+    }
+    
+    private void update_development_menu_item_sensitivity() {
+        if (get_view().get_selected().size == 0) {
+            set_action_sensitive("RawDeveloper", false);
+            return;
+        }
+        
+        // Collect some stats about what's selected.
+        bool avail_shotwell = false; // True if Shotwell developer is available.
+        bool avail_camera = false;   // True if camera developer is available.
+        bool is_raw = false;    // True if any RAW photos are selected
+        foreach (DataView view in get_view().get_selected()) {
+            Photo? photo = ((Thumbnail) view).get_media_source() as Photo;
+            if (photo != null && photo.get_master_file_format() == PhotoFileFormat.RAW) {
+                is_raw = true;
+                
+                if (!avail_shotwell && photo.is_raw_developer_available(RawDeveloper.SHOTWELL))
+                    avail_shotwell = true;
+                
+                if (!avail_camera && (photo.is_raw_developer_available(RawDeveloper.CAMERA) ||
+                    photo.is_raw_developer_available(RawDeveloper.EMBEDDED)))
+                    avail_camera = true;
+                
+                if (avail_shotwell && avail_camera)
+                    break; // optimization: break out of loop when all options available
+                
+            }
+        }
+        
+        // Enable/disable menu.
+        set_action_sensitive("RawDeveloper", is_raw);
+        
+        if (is_raw) {
+            // Set which developers are available.
+            set_action_sensitive("RawDeveloperShotwell", avail_shotwell);
+            set_action_sensitive("RawDeveloperCamera", avail_camera);
+        }
+    }
+    
+    private void update_flag_action(int selected_count) {
+        set_action_sensitive("Flag", selected_count > 0);
+        
+        string flag_label = Resources.FLAG_MENU;
+
+        if (selected_count > 0) {
+            bool all_flagged = true;
+            foreach (DataSource source in get_view().get_selected_sources()) {
+                Flaggable? flaggable = source as Flaggable;
+                if (flaggable != null && !flaggable.is_flagged()) {
+                    all_flagged = false;
+                    
+                    break;
+                }
+            }
+            
+            if (all_flagged) {
+                flag_label = Resources.UNFLAG_MENU;
+            }
+        }
+        
+        Gtk.Action? flag_action = get_action("Flag");
+        if (flag_action != null) {
+            flag_action.label = flag_label;
+        }
+    }
+    
+    public override Core.ViewTracker? get_view_tracker() {
+        return tracker;
+    }
+    
+    public void set_display_ratings(bool display) {
+        get_view().freeze_notifications();
+        get_view().set_property(Thumbnail.PROP_SHOW_RATINGS, display);
+        get_view().thaw_notifications();
+        
+        Gtk.ToggleAction? action = get_action("ViewRatings") as Gtk.ToggleAction;
+        if (action != null)
+            action.set_active(display);
+    }
+
+    private bool can_rate_selected(Rating rating) {
+        foreach (DataView view in get_view().get_selected()) {
+            if(((Thumbnail) view).get_media_source().get_rating() != rating)
+                return true;
+        }
+
+        return false;
+    }
+
+    private bool can_increase_selected_rating() {
+        foreach (DataView view in get_view().get_selected()) {
+            if(((Thumbnail) view).get_media_source().get_rating().can_increase())
+                return true;
+        }
+
+        return false;
+    }
+
+    private bool can_decrease_selected_rating() {
+        foreach (DataView view in get_view().get_selected()) {
+            if(((Thumbnail) view).get_media_source().get_rating().can_decrease())
+                return true;
+        }
+        
+        return false;
+    }
+    
+    public ZoomSliderAssembly create_zoom_slider_assembly() {
+        return new ZoomSliderAssembly();
+    }
+
+    protected override bool on_mousewheel_up(Gdk.EventScroll event) {
+        if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) {
+            increase_zoom_level();
+            return true;
+        } else {
+            return base.on_mousewheel_up(event);
+        }
+    }
+
+    protected override bool on_mousewheel_down(Gdk.EventScroll event) {
+        if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) {
+            decrease_zoom_level();
+            return true;
+        } else {
+            return base.on_mousewheel_down(event);
+        }
+    }
+    
+    private void on_send_to() {
+        DesktopIntegration.send_to((Gee.Collection<MediaSource>) get_view().get_selected_sources());
+    }
+    
+    protected void on_play_video() {
+        if (get_view().get_selected_count() != 1)
+            return;
+        
+        Video? video = get_view().get_selected_at(0).get_source() as Video;
+        if (video == null)
+            return;
+        
+        try {
+            AppInfo.launch_default_for_uri(video.get_file().get_uri(), null);
+        } catch (Error e) {
+            AppWindow.error_message(_("Shotwell was unable to play the selected video:\n%s").printf(
+                e.message));
+        }
+    }
+
+    protected override bool on_app_key_pressed(Gdk.EventKey event) {
+        bool handled = true;
+        switch (Gdk.keyval_name(event.keyval)) {
+            case "equal":
+            case "plus":
+            case "KP_Add":
+                activate_action("IncreaseSize");
+            break;
+            
+            case "minus":
+            case "underscore":
+            case "KP_Subtract":
+                activate_action("DecreaseSize");
+            break;
+            
+            case "period":
+                activate_action("IncreaseRating");
+            break;
+            
+            case "comma":
+                activate_action("DecreaseRating");
+            break;
+            
+            case "KP_1":
+                activate_action("RateOne");
+            break;
+            
+            case "KP_2":
+                activate_action("RateTwo");
+            break;
+            
+            case "KP_3":
+                activate_action("RateThree");
+            break;
+            
+            case "KP_4":
+                activate_action("RateFour");
+            break;
+            
+            case "KP_5":
+                activate_action("RateFive");
+            break;
+            
+            case "KP_0":
+                activate_action("RateUnrated");
+            break;
+            
+            case "KP_9":
+                activate_action("RateRejected");
+            break;
+            
+            case "exclam":
+                if (get_ctrl_pressed())
+                    get_search_view_filter().set_rating_filter(RatingFilter.ONE_OR_HIGHER);
+            break;
+            
+            case "at":
+                if (get_ctrl_pressed())
+                    get_search_view_filter().set_rating_filter(RatingFilter.TWO_OR_HIGHER);
+            break;
+
+            case "numbersign":
+                if (get_ctrl_pressed())
+                    get_search_view_filter().set_rating_filter(RatingFilter.THREE_OR_HIGHER);
+            break;
+
+            case "dollar":
+                if (get_ctrl_pressed())
+                    get_search_view_filter().set_rating_filter(RatingFilter.FOUR_OR_HIGHER);
+            break;
+
+            case "percent":
+                if (get_ctrl_pressed())
+                    get_search_view_filter().set_rating_filter(RatingFilter.FIVE_OR_HIGHER);
+            break;
+
+            case "parenright":
+                if (get_ctrl_pressed())
+                    get_search_view_filter().set_rating_filter(RatingFilter.UNRATED_OR_HIGHER);
+            break;
+
+            case "parenleft":
+                if (get_ctrl_pressed())
+                    get_search_view_filter().set_rating_filter(RatingFilter.REJECTED_OR_HIGHER);
+            break;
+            
+            case "asterisk":
+                if (get_ctrl_pressed())
+                    get_search_view_filter().set_rating_filter(RatingFilter.REJECTED_ONLY);
+            break;
+            
+            case "slash":
+                activate_action("Flag");
+            break;
+            
+            default:
+                handled = false;
+            break;
+        }
+        
+        return handled ? true : base.on_app_key_pressed(event);
+    }
+
+    public override void switched_to() {
+        base.switched_to();
+        
+        // set display options to match Configuration toggles (which can change while switched away)
+        get_view().freeze_notifications();
+        set_display_titles(Config.Facade.get_instance().get_display_photo_titles());
+        set_display_comments(Config.Facade.get_instance().get_display_photo_comments());
+        set_display_ratings(Config.Facade.get_instance().get_display_photo_ratings());
+        set_display_tags(Config.Facade.get_instance().get_display_photo_tags());
+        get_view().thaw_notifications();
+
+        sync_sort();
+    }
+    
+    public override void switching_from() {
+        disconnect_slider();
+
+        base.switching_from();
+    }
+
+    protected void connect_slider(ZoomSliderAssembly slider) {
+        connected_slider = slider;
+        connected_slider.zoom_changed.connect(on_zoom_changed);
+        load_persistent_thumbnail_scale();
+    }
+    
+    private void save_persistent_thumbnail_scale() {
+        if (connected_slider == null)
+            return;
+            
+        Config.Facade.get_instance().set_photo_thumbnail_scale(connected_slider.get_scale());
+    }
+    
+    private void load_persistent_thumbnail_scale() {
+        if (connected_slider == null)
+            return;
+
+        int persistent_scale = Config.Facade.get_instance().get_photo_thumbnail_scale();
+
+        connected_slider.set_scale(persistent_scale);
+        set_thumb_size(persistent_scale);
+    }
+    
+    protected void disconnect_slider() {
+        if (connected_slider == null)
+            return;
+        
+        connected_slider.zoom_changed.disconnect(on_zoom_changed);
+        connected_slider = null;
+    }
+
+    protected virtual void on_zoom_changed() {
+        if (connected_slider != null)
+            set_thumb_size(connected_slider.get_scale());
+
+        save_persistent_thumbnail_scale();
+    }
+    
+    protected abstract void on_export();
+
+    protected virtual void on_increase_size() {
+        increase_zoom_level();
+    }
+
+    protected virtual void on_decrease_size() {
+        decrease_zoom_level();
+    }
+
+    private void on_add_tags() {
+        if (get_view().get_selected_count() == 0)
+            return;
+        
+        AddTagsDialog dialog = new AddTagsDialog();
+        string[]? names = dialog.execute();
+        
+        if (names != null) {
+            get_command_manager().execute(new AddTagsCommand(
+                HierarchicalTagIndex.get_global_index().get_paths_for_names_array(names),
+                (Gee.Collection<MediaSource>) get_view().get_selected_sources()));
+        }
+    }
+
+    private void on_modify_tags() {
+        if (get_view().get_selected_count() != 1)
+            return;
+        
+        MediaSource media = (MediaSource) get_view().get_selected_at(0).get_source();
+        
+        ModifyTagsDialog dialog = new ModifyTagsDialog(media);
+        Gee.ArrayList<Tag>? new_tags = dialog.execute();
+        
+        if (new_tags == null)
+            return;
+        
+        get_command_manager().execute(new ModifyTagsCommand(media, new_tags));
+    }
+
+    private void set_display_tags(bool display) {
+        get_view().freeze_notifications();
+        get_view().set_property(Thumbnail.PROP_SHOW_TAGS, display);
+        get_view().thaw_notifications();
+        
+        Gtk.ToggleAction? action = get_action("ViewTags") as Gtk.ToggleAction;
+        if (action != null)
+            action.set_active(display);
+    }
+
+    private void on_new_event() {
+        if (get_view().get_selected_count() > 0)
+            get_command_manager().execute(new NewEventCommand(get_view().get_selected()));
+    }
+    
+    private void on_flag_unflag() {
+        if (get_view().get_selected_count() == 0)
+            return;
+        
+        Gee.Collection<MediaSource> sources =
+            (Gee.Collection<MediaSource>) get_view().get_selected_sources_of_type(typeof(MediaSource));
+        
+        // If all are flagged, then unflag, otherwise flag
+        bool flag = false;
+        foreach (MediaSource source in sources) {
+            Flaggable? flaggable = source as Flaggable;
+            if (flaggable != null && !flaggable.is_flagged()) {
+                flag = true;
+                
+                break;
+            }
+        }
+        
+        get_command_manager().execute(new FlagUnflagCommand(sources, flag));
+    }
+    
+    protected virtual void on_increase_rating() {
+        if (get_view().get_selected_count() == 0)
+            return;
+        
+        SetRatingCommand command = new SetRatingCommand.inc_dec(get_view().get_selected(), true);
+        get_command_manager().execute(command);
+
+        update_rating_sensitivities();
+    }
+
+    protected virtual void on_decrease_rating() {
+        if (get_view().get_selected_count() == 0)
+            return;
+        
+        SetRatingCommand command = new SetRatingCommand.inc_dec(get_view().get_selected(), false);
+        get_command_manager().execute(command);
+
+        update_rating_sensitivities();
+    }
+
+    protected virtual void on_set_rating(Rating rating) {
+        if (get_view().get_selected_count() == 0)
+            return;
+        
+        SetRatingCommand command = new SetRatingCommand(get_view().get_selected(), rating);
+        get_command_manager().execute(command);
+
+        update_rating_sensitivities();
+    }
+
+    protected virtual void on_rate_rejected() {
+        on_set_rating(Rating.REJECTED);
+    }
+    
+    protected virtual void on_rate_unrated() {
+        on_set_rating(Rating.UNRATED);
+    }
+
+    protected virtual void on_rate_one() {
+        on_set_rating(Rating.ONE);
+    }
+
+    protected virtual void on_rate_two() {
+        on_set_rating(Rating.TWO);
+    }
+
+    protected virtual void on_rate_three() {
+        on_set_rating(Rating.THREE);
+    }
+
+    protected virtual void on_rate_four() {
+        on_set_rating(Rating.FOUR);
+    }
+
+    protected virtual void on_rate_five() {
+        on_set_rating(Rating.FIVE);
+    }
+
+    private void on_remove_from_library() {
+        remove_photos_from_library((Gee.Collection<LibraryPhoto>) get_view().get_selected_sources());
+    }
+
+    protected virtual void on_move_to_trash() {
+        CheckerboardItem? restore_point = null;
+
+        if (cursor != null) {
+            restore_point = get_view().get_next(cursor) as CheckerboardItem;
+        }
+
+        if (get_view().get_selected_count() > 0) {
+            get_command_manager().execute(new TrashUntrashPhotosCommand(
+                (Gee.Collection<MediaSource>) get_view().get_selected_sources(), true));
+        }
+
+        if ((restore_point != null) && (get_view().contains(restore_point))) {
+            set_cursor(restore_point);
+        }
+    }
+
+    protected virtual void on_edit_title() {
+        if (get_view().get_selected_count() == 0)
+            return;
+        
+        Gee.List<MediaSource> media_sources = (Gee.List<MediaSource>) get_view().get_selected_sources();
+        
+        EditTitleDialog edit_title_dialog = new EditTitleDialog(media_sources[0].get_title());
+        string? new_title = edit_title_dialog.execute();
+        if (new_title != null)
+            get_command_manager().execute(new EditMultipleTitlesCommand(media_sources, new_title));
+    }
+
+    protected virtual void on_edit_comment() {
+        if (get_view().get_selected_count() == 0)
+            return;
+        
+        Gee.List<MediaSource> media_sources = (Gee.List<MediaSource>) get_view().get_selected_sources();
+        
+        EditCommentDialog edit_comment_dialog = new EditCommentDialog(media_sources[0].get_comment());
+        string? new_comment = edit_comment_dialog.execute();
+        if (new_comment != null)
+            get_command_manager().execute(new EditMultipleCommentsCommand(media_sources, new_comment));
+    }
+
+    protected virtual void on_display_titles(Gtk.Action action) {
+        bool display = ((Gtk.ToggleAction) action).get_active();
+        
+        set_display_titles(display);
+        
+        Config.Facade.get_instance().set_display_photo_titles(display);
+    }
+
+    protected virtual void on_display_comments(Gtk.Action action) {
+        bool display = ((Gtk.ToggleAction) action).get_active();
+        
+        set_display_comments(display);
+        
+        Config.Facade.get_instance().set_display_photo_comments(display);
+    }
+
+    protected virtual void on_display_ratings(Gtk.Action action) {
+        bool display = ((Gtk.ToggleAction) action).get_active();
+        
+        set_display_ratings(display);
+        
+        Config.Facade.get_instance().set_display_photo_ratings(display);
+    }
+
+    protected virtual void on_display_tags(Gtk.Action action) {
+        bool display = ((Gtk.ToggleAction) action).get_active();
+        
+        set_display_tags(display);
+        
+        Config.Facade.get_instance().set_display_photo_tags(display);
+    }
+
+    protected abstract void get_config_photos_sort(out bool sort_order, out int sort_by);
+
+    protected abstract void set_config_photos_sort(bool sort_order, int sort_by);
+
+    public virtual void on_sort_changed() {
+        int sort_by = get_menu_sort_by();
+        bool sort_order = get_menu_sort_order();
+        
+        set_view_comparator(sort_by, sort_order);
+        set_config_photos_sort(sort_order, sort_by);
+    }
+    
+    public void on_raw_developer_shotwell(Gtk.Action action) {
+        developer_changed(RawDeveloper.SHOTWELL);
+    }
+    
+    public void on_raw_developer_camera(Gtk.Action action) {
+        developer_changed(RawDeveloper.CAMERA);
+    }
+    
+    protected virtual void developer_changed(RawDeveloper rd) {
+        if (get_view().get_selected_count() == 0)
+            return;
+        
+        // Check if any photo has edits
+
+        // Display warning only when edits could be destroyed
+        bool need_warn = false;
+
+        // Make a list of all photos that need their developer changed.
+        Gee.ArrayList<DataView> to_set = new Gee.ArrayList<DataView>();
+        foreach (DataView view in get_view().get_selected()) {
+            Photo? p = view.get_source() as Photo;
+            if (p != null && (!rd.is_equivalent(p.get_raw_developer()))) {
+                to_set.add(view);
+                
+                if (p.has_transformations()) {
+                    need_warn = true;
+                }
+            }
+        }
+        
+        if (!need_warn || Dialogs.confirm_warn_developer_changed(to_set.size)) {
+            SetRawDeveloperCommand command = new SetRawDeveloperCommand(to_set, rd);
+            get_command_manager().execute(command);
+
+            update_development_menu_item_sensitivity();
+        }
+    }
+
+    protected override void set_display_titles(bool display) {
+        base.set_display_titles(display);
+    
+        Gtk.ToggleAction? action = get_action("ViewTitle") as Gtk.ToggleAction;
+        if (action != null)
+            action.set_active(display);
+    }
+
+    protected override void set_display_comments(bool display) {
+        base.set_display_comments(display);
+    
+        Gtk.ToggleAction? action = get_action("ViewComment") as Gtk.ToggleAction;
+        if (action != null)
+            action.set_active(display);
+    }
+
+    private Gtk.RadioAction sort_by_title_action() {
+        Gtk.RadioAction action = (Gtk.RadioAction) get_action("SortByTitle");
+        assert(action != null);
+        return action;
+    }
+
+    private Gtk.RadioAction sort_ascending_action() {
+        Gtk.RadioAction action = (Gtk.RadioAction) get_action("SortAscending");
+        assert(action != null);
+        return action;
+    }
+
+    protected int get_menu_sort_by() {
+        // any member of the group knows the current value
+        return sort_by_title_action().get_current_value();
+    }
+    
+    protected void set_menu_sort_by(int val) {
+        sort_by_title_action().set_current_value(val);
+    }
+    
+    protected bool get_menu_sort_order() {
+        // any member of the group knows the current value
+        return sort_ascending_action().get_current_value() == SORT_ORDER_ASCENDING;
+    }
+    
+    protected void set_menu_sort_order(bool ascending) {
+        sort_ascending_action().set_current_value(
+            ascending ? SORT_ORDER_ASCENDING : SORT_ORDER_DESCENDING);
+    }
+    
+    void set_view_comparator(int sort_by, bool ascending) {
+        Comparator comparator;
+        ComparatorPredicate predicate;
+        
+        switch (sort_by) {
+            case SortBy.TITLE:
+                if (ascending)
+                    comparator = Thumbnail.title_ascending_comparator;
+                else comparator = Thumbnail.title_descending_comparator;
+                predicate = Thumbnail.title_comparator_predicate;
+                break;
+            
+            case SortBy.EXPOSURE_DATE:
+                if (ascending)
+                    comparator = Thumbnail.exposure_time_ascending_comparator;
+                else comparator = Thumbnail.exposure_time_desending_comparator;
+                predicate = Thumbnail.exposure_time_comparator_predicate;
+                break;
+            
+            case SortBy.RATING:
+                if (ascending)
+                    comparator = Thumbnail.rating_ascending_comparator;
+                else comparator = Thumbnail.rating_descending_comparator;
+                predicate = Thumbnail.rating_comparator_predicate;
+                break;
+            
+            default:
+                debug("Unknown sort criteria: %s", get_menu_sort_by().to_string());
+                comparator = Thumbnail.title_descending_comparator;
+                predicate = Thumbnail.title_comparator_predicate;
+                break;
+        }
+        
+        get_view().set_comparator(comparator, predicate);
+    }
+
+    protected string get_sortby_path(int sort_by) {
+        switch(sort_by) {
+            case SortBy.TITLE:
+                return "/MenuBar/ViewMenu/SortPhotos/SortByTitle";
+            
+            case SortBy.EXPOSURE_DATE:
+                return "/MenuBar/ViewMenu/SortPhotos/SortByExposureDate";
+            
+            case SortBy.RATING:
+                return "/MenuBar/ViewMenu/SortPhotos/SortByRating";
+            
+            default:
+                debug("Unknown sort criteria: %d", sort_by);
+                return "/MenuBar/ViewMenu/SortPhotos/SortByTitle";
+        }
+    }
+
+    protected void sync_sort() {
+        // It used to be that the config and UI could both agree on what 
+        // sort order and criteria were selected, but the sorting wouldn't
+        // match them, due to the current view's comparator not actually 
+        // being set to match, and since there was a check to see if the 
+        // config and UI matched that would frequently succeed in this case,
+        // the sorting was often wrong until the user went in and changed 
+        // it.  Because there is no tidy way to query the current view's 
+        // comparator, we now set it any time we even think the sorting 
+        // might have changed to force them to always stay in sync.
+        //
+        // Although this means we pay for a re-sort every time, in practice,
+        // this isn't terribly expensive - it _might_ take as long as .5 sec.
+        // with a media page containing over 15000 items on a modern CPU.
+        
+        bool sort_ascending;
+        int sort_by;
+        get_config_photos_sort(out sort_ascending, out sort_by);
+        
+        set_menu_sort_by(sort_by);
+        set_menu_sort_order(sort_ascending);
+        
+        set_view_comparator(sort_by, sort_ascending);
+    }
+
+    public override void destroy() {
+        disconnect_slider();
+        
+        base.destroy();
+    }
+
+    public void increase_zoom_level() {
+        if (connected_slider != null) {
+            connected_slider.increase_step();
+        } else {
+            int new_scale = compute_zoom_scale_increase(get_thumb_size());
+            save_persistent_thumbnail_scale();
+            set_thumb_size(new_scale);
+        }
+    }
+
+    public void decrease_zoom_level() {
+        if (connected_slider != null) {
+            connected_slider.decrease_step();
+        } else {
+            int new_scale = compute_zoom_scale_decrease(get_thumb_size());
+            save_persistent_thumbnail_scale();
+            set_thumb_size(new_scale);
+        }
+    }
+
+    public virtual DataView create_thumbnail(DataSource source) {
+        return new Thumbnail((MediaSource) source, get_thumb_size());
+    }
+
+    // this is a view-level operation on this page only; it does not affect the persistent global
+    // thumbnail scale
+    public void set_thumb_size(int new_scale) {
+        if (get_thumb_size() == new_scale || !is_in_view())
+            return;
+        
+        new_scale = new_scale.clamp(Thumbnail.MIN_SCALE, Thumbnail.MAX_SCALE);
+        get_checkerboard_layout().set_scale(new_scale);
+        
+        // when doing mass operations on LayoutItems, freeze individual notifications
+        get_view().freeze_notifications();
+        get_view().set_property(Thumbnail.PROP_SIZE, new_scale);
+        get_view().thaw_notifications();
+        
+        set_action_sensitive("IncreaseSize", new_scale < Thumbnail.MAX_SCALE);
+        set_action_sensitive("DecreaseSize", new_scale > Thumbnail.MIN_SCALE);
+    }
+
+    public int get_thumb_size() {
+        if (get_checkerboard_layout().get_scale() <= 0)
+            get_checkerboard_layout().set_scale(Config.Facade.get_instance().get_photo_thumbnail_scale());
+            
+        return get_checkerboard_layout().get_scale();
+    }
+}
+