Update upstream source from tag 'upstream/0.30.1'

Update to upstream version '0.30.1'
with Debian dir dc242531effff8d9c6fab093414edee28b403c6a

1 files changed, 783 insertions, 0 deletions

diff --git a/src/faces/FaceShape.vala b/src/faces/FaceShape.vala
new file mode 100644
index 0000000..c14b43b
--- /dev/null
+++ b/src/faces/FaceShape.vala
@@ -0,0 +1,783 @@
+/* Copyright 2016 Software Freedom Conservancy Inc.
+ *
+ * This software is licensed under the GNU Lesser General Public License
+ * (version 2.1 or later).  See the COPYING file in this distribution.
+ */
+
+#if ENABLE_FACES
+
+public abstract class FaceShape : Object {
+    public const string SHAPE_TYPE = null;
+    
+    protected const int FACE_WINDOW_MARGIN = 5;
+    protected const int LABEL_MARGIN = 12;
+    protected const int LABEL_PADDING = 9;
+    
+    public signal void add_me_requested(FaceShape face_shape);
+    public signal void delete_me_requested();
+    
+    protected FacesTool.EditingFaceToolWindow face_window;
+    protected Gdk.CursorType current_cursor_type = Gdk.CursorType.BOTTOM_RIGHT_CORNER;
+    protected EditingTools.PhotoCanvas canvas;
+    protected string serialized = null;
+    
+    private bool editable = true;
+    private bool visible = true;
+    private bool known = true;
+    
+    private weak FacesTool.FaceWidget face_widget = null;
+    
+    public FaceShape(EditingTools.PhotoCanvas canvas) {
+        this.canvas = canvas;
+        this.canvas.new_surface.connect(prepare_ctx);
+        
+        prepare_ctx(this.canvas.get_default_ctx(), this.canvas.get_surface_dim());
+        
+        face_window = new FacesTool.EditingFaceToolWindow(this.canvas.get_container());
+        face_window.key_pressed.connect(key_press_event);
+        
+        face_window.show_all();
+        face_window.hide();
+        
+        this.canvas.get_drawing_window().set_cursor(new Gdk.Cursor(current_cursor_type));
+    }
+    
+    ~FaceShape() {
+        if (visible)
+            erase();
+        
+        face_window.destroy();
+        
+        canvas.new_surface.disconnect(prepare_ctx);
+        
+        // make sure the cursor isn't set to a modify indicator
+        canvas.get_drawing_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.LEFT_PTR));
+    }
+    
+    public static FaceShape from_serialized(EditingTools.PhotoCanvas canvas, string serialized)
+    throws FaceShapeError {
+        FaceShape face_shape;
+        
+        string[] args = serialized.split(";");
+        switch (args[0]) {
+            case "Rectangle":
+                face_shape = FaceRectangle.from_serialized(canvas, args);
+                
+                break;
+            default:
+                assert_not_reached();
+        }
+        
+        face_shape.serialized = serialized;
+        
+        return face_shape;
+    }
+    
+    public void set_name(string face_name) {
+        face_window.entry.set_text(face_name);
+    }
+    
+    public string? get_name() {
+        string face_name = face_window.entry.get_text();
+        
+        return face_name == "" ? null : face_name;
+    }
+    
+    public void set_known(bool known) {
+        this.known = known;
+    }
+    
+    public bool get_known() {
+        return known;
+    }
+    
+    public void set_widget(FacesTool.FaceWidget face_widget) {
+        this.face_widget = face_widget;
+    }
+    
+    public FacesTool.FaceWidget get_widget() {
+        assert(face_widget != null);
+        
+        return face_widget;
+    }
+    
+    public void hide() {
+        visible = false;
+        erase();
+        
+        if (editable)
+            face_window.hide();
+        
+        // make sure the cursor isn't set to a modify indicator
+        canvas.get_drawing_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.LEFT_PTR));
+    }
+    
+    public void show() {
+        visible = true;
+        paint();
+        
+        if (editable) {
+            update_face_window_position();
+            face_window.show();
+            face_window.present();
+            
+            if (!known)
+                face_window.entry.select_region(0, -1);
+        }
+    }
+    
+    public bool is_visible() {
+        return visible;
+    }
+    
+    public bool is_editable() {
+        return editable;
+    }
+    
+    public void set_editable(bool editable) {
+        if (visible && editable != is_editable()) {
+            hide();
+            this.editable = editable;
+            show();
+            
+            return;
+        }
+        
+        this.editable = editable;
+    }
+    
+    public bool key_press_event(Gdk.EventKey event) {
+        switch (Gdk.keyval_name(event.keyval)) {
+            case "Escape":
+                delete_me_requested();
+            break;
+            case "Return":
+            case "KP_Enter":
+                add_me_requested(this);
+            break;
+            default:
+                return false;
+        }
+        
+        return true;
+    }
+    
+    public abstract string serialize();
+    public abstract void update_face_window_position();
+    public abstract void prepare_ctx(Cairo.Context ctx, Dimensions dim);
+    public abstract void on_resized_pixbuf(Dimensions old_dim, Gdk.Pixbuf scaled);
+    public abstract void on_motion(int x, int y, Gdk.ModifierType mask);
+    public abstract void on_left_released(int x, int y);
+    public abstract bool on_left_click(int x, int y);
+    public abstract bool cursor_is_over(int x, int y);
+    public abstract bool equals(FaceShape face_shape);
+    public abstract double get_distance(int x, int y);
+    
+    protected abstract void paint();
+    protected abstract void erase();
+}
+
+public class FaceRectangle : FaceShape {
+    public new const string SHAPE_TYPE = "Rectangle";
+    
+    private const int FACE_MIN_SIZE = 8;
+    public const int NULL_SIZE = 0;
+    
+    private Box box;
+    private Box? label_box;
+    private BoxLocation in_manipulation = BoxLocation.OUTSIDE;
+    private Cairo.Context wide_black_ctx = null;
+    private Cairo.Context wide_white_ctx = null;
+    private Cairo.Context thin_white_ctx = null;
+    private int last_grab_x = -1;
+    private int last_grab_y = -1;
+    
+    public FaceRectangle(EditingTools.PhotoCanvas canvas, int x, int y,
+        int half_width = NULL_SIZE, int half_height = NULL_SIZE) {
+        base(canvas);
+        
+        Gdk.Rectangle scaled_pixbuf_pos = canvas.get_scaled_pixbuf_position();
+        x -= scaled_pixbuf_pos.x;
+        y -= scaled_pixbuf_pos.y;
+        
+        // If half_width is NULL_SIZE we are creating a new FaceShape,
+        // otherwise we are only showing a previously created one.
+        if (half_width == NULL_SIZE) {
+            box = Box(x, y, x, y);
+            
+            in_manipulation = BoxLocation.BOTTOM_RIGHT;
+            last_grab_x = x;
+            last_grab_y = y;
+        } else {
+            Dimensions pixbuf_dimensions = Dimensions.for_pixbuf(canvas.get_scaled_pixbuf());
+            int right = (x + half_width).clamp(x, pixbuf_dimensions.width);
+            int bottom = (y + half_height).clamp(y, pixbuf_dimensions.height);
+        
+            box = Box(x - half_width, y - half_height, right, bottom);
+        }
+    }
+    
+    ~FaceRectangle() {
+        if (!is_editable())
+            erase_label();
+    }
+    
+    public static new FaceRectangle from_serialized(EditingTools.PhotoCanvas canvas, string[] args)
+        throws FaceShapeError {
+        assert(args[0] == SHAPE_TYPE);
+        
+        Photo photo = canvas.get_photo();
+        Dimensions raw_dim = photo.get_raw_dimensions();
+        
+        int x = (int) (raw_dim.width * double.parse(args[1]));
+        int y = (int) (raw_dim.height * double.parse(args[2]));
+        int half_width = (int) (raw_dim.width * double.parse(args[3]));
+        int half_height = (int) (raw_dim.height * double.parse(args[4]));
+        
+        Box box = Box(x - half_width, y - half_height, x + half_width, y + half_height);
+        
+        Dimensions current_dim = Dimensions.for_pixbuf(canvas.get_scaled_pixbuf());
+        Box raw_cropped;
+        
+        if (photo.get_raw_crop(out raw_cropped)) {
+            box.left = box.left.clamp(raw_cropped.left, box.left) - raw_cropped.left;
+            box.right = box.right.clamp(box.right, raw_cropped.right) - raw_cropped.left;
+            box.top = box.top.clamp(raw_cropped.top, box.top) - raw_cropped.top;
+            box.bottom = box.bottom.clamp(box.bottom, raw_cropped.bottom) - raw_cropped.top;
+            
+            box = photo.get_orientation().rotate_box(raw_cropped.get_dimensions(), box);
+            
+            Box cropped;
+            photo.get_crop(out cropped);
+            box = box.get_scaled_similar(cropped.get_dimensions(), current_dim);
+        } else {
+            box = photo.get_orientation().rotate_box(raw_dim, box);
+            
+            box = box.get_scaled_similar(photo.get_dimensions(), current_dim);
+        }
+        
+        Gdk.Rectangle scaled_pixbuf_pos = canvas.get_scaled_pixbuf_position();
+        box.left += scaled_pixbuf_pos.x;
+        box.right += scaled_pixbuf_pos.x;
+        box.top += scaled_pixbuf_pos.y;
+        box.bottom += scaled_pixbuf_pos.y;
+        
+        half_width = box.get_width() / 2;
+        half_height = box.get_height() / 2;
+        
+        if (half_width < FACE_MIN_SIZE || half_height < FACE_MIN_SIZE)
+            throw new FaceShapeError.CANT_CREATE("FaceShape is out of cropped photo area");
+        
+        return new FaceRectangle(canvas, box.left + half_width, box.top + half_height,
+            half_width, half_height);
+    }
+    
+    public override void update_face_window_position() {
+        AppWindow appWindow = AppWindow.get_instance();
+        Gtk.Allocation face_window_alloc;
+        Gdk.Rectangle scaled_pixbuf_pos = canvas.get_scaled_pixbuf_position();
+        int x = 0;
+        int y = 0;
+        
+        if (canvas.get_container() == appWindow) {
+            appWindow.get_current_page().get_window().get_origin(out x, out y);
+        } else assert(canvas.get_container() is FullscreenWindow);
+        
+        face_window.get_allocation(out face_window_alloc);
+        
+        x += scaled_pixbuf_pos.x + box.left + ((box.get_width() - face_window_alloc.width) >> 1);
+        y += scaled_pixbuf_pos.y + box.bottom + FACE_WINDOW_MARGIN;
+        
+        face_window.move(x, y);
+    }
+    
+    protected override void paint() {
+        canvas.draw_box(wide_black_ctx, box);
+        canvas.draw_box(wide_white_ctx, box.get_reduced(1));
+        canvas.draw_box(wide_white_ctx, box.get_reduced(2));
+        
+        canvas.invalidate_area(box);
+        
+        if (!is_editable())
+            paint_label();
+    }
+    
+    protected override void erase() {
+        canvas.erase_box(box);
+        canvas.erase_box(box.get_reduced(1));
+        canvas.erase_box(box.get_reduced(2));
+        
+        canvas.invalidate_area(box);
+        
+        if (!is_editable())
+            erase_label();
+    }
+    
+    private void paint_label() {
+        Cairo.Context ctx = canvas.get_default_ctx();
+        Gdk.Rectangle scaled_pixbuf_pos = canvas.get_scaled_pixbuf_position();
+        
+        ctx.save();
+        
+        Cairo.TextExtents text_extents = Cairo.TextExtents();
+        ctx.text_extents(get_name(), out text_extents);
+        
+        int width = (int) text_extents.width + LABEL_PADDING;
+        int height = (int) text_extents.height;
+        int x = box.left + (box.get_width() - width) / 2;
+        int y = box.bottom + LABEL_MARGIN;
+        
+        label_box = Box(x, y, x + width, y + height + LABEL_PADDING);
+        
+        x += scaled_pixbuf_pos.x;
+        y += scaled_pixbuf_pos.y;
+        
+        ctx.rectangle(x, y, width, height + LABEL_PADDING);
+        ctx.set_source_rgba(0, 0, 0, 0.6);
+        ctx.fill();
+        
+        ctx.set_source_rgb(1, 1, 1);
+        ctx.move_to(x + LABEL_PADDING / 2, y + height + LABEL_PADDING / 2);
+        ctx.show_text(get_name());
+        
+        ctx.restore();
+    }
+    
+    private void erase_label() {
+        if (label_box == null)
+            return;
+        
+        Gdk.Rectangle scaled_pixbuf_pos = canvas.get_scaled_pixbuf_position();
+        int x = scaled_pixbuf_pos.x + label_box.left;
+        int y = scaled_pixbuf_pos.y + label_box.top;
+        
+        Cairo.Context ctx = canvas.get_default_ctx();
+        ctx.save();
+        
+        ctx.set_operator(Cairo.Operator.OVER);
+        ctx.rectangle(x, y, label_box.get_width(), label_box.get_height());
+        
+        ctx.set_source_rgb(0.0, 0.0, 0.0);
+        ctx.fill_preserve();
+        
+        ctx.set_source_surface(canvas.get_scaled_surface(),
+            scaled_pixbuf_pos.x, scaled_pixbuf_pos.y);
+        ctx.fill();
+        
+        canvas.invalidate_area(label_box);
+        label_box = null;
+        
+        ctx.restore();
+    }
+    
+    public override string serialize() {
+        if (serialized != null)
+            return serialized;
+        
+        double x;
+        double y;
+        double half_width;
+        double half_height;
+        
+        get_geometry(out x, out y, out half_width, out half_height);
+        
+        serialized = "%s;%s;%s;%s;%s".printf(SHAPE_TYPE, x.to_string(),
+            y.to_string(), half_width.to_string(), half_height.to_string());
+        
+        return serialized;
+    }
+    
+    public void get_geometry(out double x, out double y,
+        out double half_width, out double half_height) {
+        Photo photo = canvas.get_photo();
+        Dimensions raw_dim = photo.get_raw_dimensions();
+        
+        Box temp_box = box;
+        
+        Dimensions current_dim = Dimensions.for_pixbuf(canvas.get_scaled_pixbuf());
+        Box cropped;
+        
+        if (photo.get_crop(out cropped)) {
+            temp_box = temp_box.get_scaled_similar(current_dim, cropped.get_dimensions());
+            
+            Box raw_cropped;
+            photo.get_raw_crop(out raw_cropped);
+            
+            temp_box =
+                photo.get_orientation().derotate_box(raw_cropped.get_dimensions(), temp_box);
+            
+            temp_box.left += raw_cropped.left;
+            temp_box.right += raw_cropped.left;
+            temp_box.top += raw_cropped.top;
+            temp_box.bottom += raw_cropped.top;
+        } else {
+            temp_box = temp_box.get_scaled_similar(current_dim, photo.get_dimensions());
+            
+            temp_box = photo.get_orientation().derotate_box(raw_dim, temp_box);
+        }
+        
+        x = (temp_box.left + (temp_box.get_width() / 2)) / (double) raw_dim.width;
+        y = (temp_box.top + (temp_box.get_height() / 2)) / (double) raw_dim.height;
+        
+        double width_left_end = temp_box.left / (double) raw_dim.width;
+        double width_right_end = temp_box.right / (double) raw_dim.width;
+        double height_top_end = temp_box.top / (double) raw_dim.height;
+        double height_bottom_end = temp_box.bottom / (double) raw_dim.height;
+        
+        half_width = (width_right_end - width_left_end) / 2;
+        half_height = (height_bottom_end - height_top_end) / 2;
+    }
+    
+    public override bool equals(FaceShape face_shape) {
+        return serialize() == face_shape.serialize();
+    }
+    
+    public override void prepare_ctx(Cairo.Context ctx, Dimensions dim) {
+        wide_black_ctx = new Cairo.Context(ctx.get_target());
+        set_source_color_from_string(wide_black_ctx, "#000");
+        wide_black_ctx.set_line_width(1);
+        
+        wide_white_ctx = new Cairo.Context(ctx.get_target());
+        set_source_color_from_string(wide_black_ctx, "#FFF");
+        wide_white_ctx.set_line_width(1);
+        
+        thin_white_ctx = new Cairo.Context(ctx.get_target());
+        set_source_color_from_string(wide_black_ctx, "#FFF");
+        thin_white_ctx.set_line_width(0.5);
+    }
+    
+    private bool on_canvas_manipulation(int x, int y) {
+        Gdk.Rectangle scaled_pos = canvas.get_scaled_pixbuf_position();
+        
+        // box is maintained in coordinates non-relative to photo's position on canvas ...
+        // but bound tool to photo itself
+        x -= scaled_pos.x;
+        if (x < 0)
+            x = 0;
+        else if (x >= scaled_pos.width)
+            x = scaled_pos.width - 1;
+        
+        y -= scaled_pos.y;
+        if (y < 0)
+            y = 0;
+        else if (y >= scaled_pos.height)
+            y = scaled_pos.height - 1;
+        
+        // need to make manipulations outside of box structure, because its methods do sanity
+        // checking
+        int left = box.left;
+        int top = box.top;
+        int right = box.right;
+        int bottom = box.bottom;
+
+        // get extra geometric information needed to enforce constraints
+        int photo_right_edge = canvas.get_scaled_pixbuf().width - 1;
+        int photo_bottom_edge = canvas.get_scaled_pixbuf().height - 1;
+        
+        switch (in_manipulation) {
+            case BoxLocation.LEFT_SIDE:
+                left = x;
+            break;
+
+            case BoxLocation.TOP_SIDE:
+                top = y;
+            break;
+
+            case BoxLocation.RIGHT_SIDE:
+                right = x;
+            break;
+
+            case BoxLocation.BOTTOM_SIDE:
+                bottom = y;
+            break;
+
+            case BoxLocation.TOP_LEFT:
+                top = y;
+                left = x;
+            break;
+
+            case BoxLocation.BOTTOM_LEFT:
+                bottom = y;
+                left = x;
+            break;
+
+            case BoxLocation.TOP_RIGHT:
+                top = y;
+                right = x;
+            break;
+
+            case BoxLocation.BOTTOM_RIGHT:
+                bottom = y;
+                right = x;
+            break;
+
+            case BoxLocation.INSIDE:
+                assert(last_grab_x >= 0);
+                assert(last_grab_y >= 0);
+                
+                int delta_x = (x - last_grab_x);
+                int delta_y = (y - last_grab_y);
+                
+                last_grab_x = x;
+                last_grab_y = y;
+
+                int width = right - left + 1;
+                int height = bottom - top + 1;
+                
+                left += delta_x;
+                top += delta_y;
+                right += delta_x;
+                bottom += delta_y;
+                
+                // bound box inside of photo
+                if (left < 0)
+                    left = 0;
+                
+                if (top < 0)
+                    top = 0;
+                
+                if (right >= scaled_pos.width)
+                    right = scaled_pos.width - 1;
+                
+                if (bottom >= scaled_pos.height)
+                    bottom = scaled_pos.height - 1;
+                
+                int adj_width = right - left + 1;
+                int adj_height = bottom - top + 1;
+                
+                // don't let adjustments affect the size of the box
+                if (adj_width != width) {
+                    if (delta_x < 0)
+                        right = left + width - 1;
+                    else left = right - width + 1;
+                }
+                
+                if (adj_height != height) {
+                    if (delta_y < 0)
+                        bottom = top + height - 1;
+                    else top = bottom - height + 1;
+                }
+            break;
+            
+            default:
+                // do nothing, not even a repaint
+                return false;
+        }
+
+        // Check if the mouse has gone out of bounds, and if it has, make sure that the
+        // face shape edges stay within the photo bounds.
+        int width = right - left + 1;
+        int height = bottom - top + 1;
+        
+        if (left < 0)
+            left = 0;
+        if (top < 0)
+            top = 0;
+        if (right > photo_right_edge)
+            right = photo_right_edge;
+        if (bottom > photo_bottom_edge)
+            bottom = photo_bottom_edge;
+
+        width = right - left + 1;
+        height = bottom - top + 1;
+
+        switch (in_manipulation) {
+            case BoxLocation.LEFT_SIDE:
+            case BoxLocation.TOP_LEFT:
+            case BoxLocation.BOTTOM_LEFT:
+                if (width < FACE_MIN_SIZE)
+                    left = right - FACE_MIN_SIZE;
+            break;
+            
+            case BoxLocation.RIGHT_SIDE:
+            case BoxLocation.TOP_RIGHT:
+            case BoxLocation.BOTTOM_RIGHT:
+                if (width < FACE_MIN_SIZE)
+                    right = left + FACE_MIN_SIZE;
+            break;
+
+            default:
+            break;
+        }
+
+        switch (in_manipulation) {
+            case BoxLocation.TOP_SIDE:
+            case BoxLocation.TOP_LEFT:
+            case BoxLocation.TOP_RIGHT:
+                if (height < FACE_MIN_SIZE)
+                    top = bottom - FACE_MIN_SIZE;
+            break;
+
+            case BoxLocation.BOTTOM_SIDE:
+            case BoxLocation.BOTTOM_LEFT:
+            case BoxLocation.BOTTOM_RIGHT:
+                if (height < FACE_MIN_SIZE)
+                    bottom = top + FACE_MIN_SIZE;
+            break;
+            
+            default:
+            break;
+        }
+       
+        Box new_box = Box(left, top, right, bottom);
+        
+        if (!box.equals(new_box)) {
+            erase();
+            
+            if (in_manipulation != BoxLocation.INSIDE)
+                check_resized_box(new_box);
+            
+            box = new_box;
+            paint();
+        }
+        
+        if (is_editable())
+            update_face_window_position();
+        
+        serialized = null;
+        
+        return false;
+    }
+    
+    private void check_resized_box(Box new_box) {
+        Box horizontal;
+        bool horizontal_enlarged;
+        Box vertical;
+        bool vertical_enlarged;
+        BoxComplements complements = box.resized_complements(new_box, out horizontal,
+            out horizontal_enlarged, out vertical, out vertical_enlarged);
+        
+        // this should never happen ... this means that the operation wasn't a resize
+        assert(complements != BoxComplements.NONE);
+    }
+    
+    private void update_cursor(int x, int y) {
+        // box is not maintained relative to photo's position on canvas
+        Gdk.Rectangle scaled_pos = canvas.get_scaled_pixbuf_position();
+        Box offset_scaled_box = box.get_offset(scaled_pos.x, scaled_pos.y);
+        
+        Gdk.CursorType cursor_type = Gdk.CursorType.LEFT_PTR;
+        switch (offset_scaled_box.approx_location(x, y)) {
+            case BoxLocation.LEFT_SIDE:
+                cursor_type = Gdk.CursorType.LEFT_SIDE;
+            break;
+
+            case BoxLocation.TOP_SIDE:
+                cursor_type = Gdk.CursorType.TOP_SIDE;
+            break;
+
+            case BoxLocation.RIGHT_SIDE:
+                cursor_type = Gdk.CursorType.RIGHT_SIDE;
+            break;
+
+            case BoxLocation.BOTTOM_SIDE:
+                cursor_type = Gdk.CursorType.BOTTOM_SIDE;
+            break;
+
+            case BoxLocation.TOP_LEFT:
+                cursor_type = Gdk.CursorType.TOP_LEFT_CORNER;
+            break;
+
+            case BoxLocation.BOTTOM_LEFT:
+                cursor_type = Gdk.CursorType.BOTTOM_LEFT_CORNER;
+            break;
+
+            case BoxLocation.TOP_RIGHT:
+                cursor_type = Gdk.CursorType.TOP_RIGHT_CORNER;
+            break;
+
+            case BoxLocation.BOTTOM_RIGHT:
+                cursor_type = Gdk.CursorType.BOTTOM_RIGHT_CORNER;
+            break;
+
+            case BoxLocation.INSIDE:
+                cursor_type = Gdk.CursorType.FLEUR;
+            break;
+            
+            default:
+                // use Gdk.CursorType.LEFT_PTR
+            break;
+        }
+        
+        if (cursor_type != current_cursor_type) {
+            Gdk.Cursor cursor = new Gdk.Cursor(cursor_type);
+            canvas.get_drawing_window().set_cursor(cursor);
+            current_cursor_type = cursor_type;
+        }
+    }
+    
+    public override void on_motion(int x, int y, Gdk.ModifierType mask) {
+        // only deal with manipulating the box when click-and-dragging one of the edges
+        // or the interior
+        if (in_manipulation != BoxLocation.OUTSIDE)
+            on_canvas_manipulation(x, y);
+        
+        update_cursor(x, y);
+    }
+    
+    public override bool on_left_click(int x, int y) {
+        Gdk.Rectangle scaled_pixbuf_pos = canvas.get_scaled_pixbuf_position();
+        
+        // box is not maintained relative to photo's position on canvas
+        Box offset_scaled_box = box.get_offset(scaled_pixbuf_pos.x, scaled_pixbuf_pos.y);
+        
+        // determine where the mouse down landed and store for future events
+        in_manipulation = offset_scaled_box.approx_location(x, y);
+        last_grab_x = x -= scaled_pixbuf_pos.x;
+        last_grab_y = y -= scaled_pixbuf_pos.y;
+        
+        return box.approx_location(x, y) != BoxLocation.OUTSIDE;
+    }
+    
+    public override void on_left_released(int x, int y) {
+        if (box.get_width() < FACE_MIN_SIZE) {
+            delete_me_requested();
+            
+            return;
+        }
+        
+        if (is_editable()) {
+            face_window.show();
+            face_window.present();
+        }
+        
+        // nothing to do if released outside of the face box
+        if (in_manipulation == BoxLocation.OUTSIDE)
+            return;
+        
+        // end manipulation
+        in_manipulation = BoxLocation.OUTSIDE;
+        last_grab_x = -1;
+        last_grab_y = -1;
+        
+        update_cursor(x, y);
+    }
+    
+    public override void on_resized_pixbuf(Dimensions old_dim, Gdk.Pixbuf scaled) {
+        Dimensions new_dim = Dimensions.for_pixbuf(scaled);
+        Dimensions uncropped_dim = canvas.get_photo().get_original_dimensions();
+        
+        Box new_box = box.get_scaled_similar(old_dim, uncropped_dim);
+        
+        // rescale back to new size
+        box = new_box.get_scaled_similar(uncropped_dim, new_dim);
+        update_face_window_position();
+    }
+    
+    public override bool cursor_is_over(int x, int y) {
+        // box is not maintained relative to photo's position on canvas
+        Gdk.Rectangle scaled_pos = canvas.get_scaled_pixbuf_position();
+        Box offset_scaled_box = box.get_offset(scaled_pos.x, scaled_pos.y);
+        
+        return offset_scaled_box.approx_location(x, y) != BoxLocation.OUTSIDE;
+    }
+    
+    public override double get_distance(int x, int y) {
+        double center_x = box.left + box.get_width() / 2.0;
+        double center_y = box.top + box.get_height() / 2.0;
+        
+        return Math.sqrt((center_x - x) * (center_x - x) + (center_y - y) * (center_y - y));
+    }
+}
+
+#endif