mirror of
https://github.com/WordPress/WordPress.git
synced 2024-11-12 13:44:21 +01:00
9b15db20d3
Significant restructure of the admin image editor interface, but no new functionality. Reorganize editing buttons into a common region at the top of the editor. Move image rotation tools into a pop-out menu. Add 180 degree rotation option. Add scale button to control group. Move sidebar tools next to the editing canvas to improve visual proximity between action and result. Enlarge editing canvas and crop handles. Separate activating crop functions from applying crop. Add numeric inputs for crop & scale values. A long term goal is to move undo/redo and cancel/save into the modal title bar, but that is not feasible without significant updates to the modal framework. Props afercia, karmatosed, nrqsnchz, antpb, chaion07, costdev, peterwilsoncc, antpb, sabernhardt, prashantbhivsane, joedolson. Fixes #50523. Built from https://develop.svn.wordpress.org/trunk@55919 git-svn-id: http://core.svn.wordpress.org/trunk@55431 1a063a9b-81f0-0310-95a4-ce76da25c4cd
1249 lines
38 KiB
JavaScript
1249 lines
38 KiB
JavaScript
/*
|
|
* imgAreaSelect jQuery plugin
|
|
* version 0.9.10-wp-6.2
|
|
*
|
|
* Copyright (c) 2008-2013 Michal Wojciechowski (odyniec.net)
|
|
*
|
|
* Dual licensed under the MIT (MIT-LICENSE.txt)
|
|
* and GPL (GPL-LICENSE.txt) licenses.
|
|
*
|
|
* https://github.com/odyniec/imgareaselect
|
|
*
|
|
*/
|
|
|
|
(function($) {
|
|
|
|
/*
|
|
* Math functions will be used extensively, so it's convenient to make a few
|
|
* shortcuts
|
|
*/
|
|
var abs = Math.abs,
|
|
max = Math.max,
|
|
min = Math.min,
|
|
floor = Math.floor;
|
|
|
|
/**
|
|
* Create a new HTML div element
|
|
*
|
|
* @return A jQuery object representing the new element
|
|
*/
|
|
function div() {
|
|
return $('<div/>');
|
|
}
|
|
|
|
/**
|
|
* imgAreaSelect initialization
|
|
*
|
|
* @param img
|
|
* A HTML image element to attach the plugin to
|
|
* @param options
|
|
* An options object
|
|
*/
|
|
$.imgAreaSelect = function (img, options) {
|
|
var
|
|
/* jQuery object representing the image */
|
|
$img = $(img),
|
|
|
|
/* Has the image finished loading? */
|
|
imgLoaded,
|
|
|
|
/* Plugin elements */
|
|
|
|
/* Container box */
|
|
$box = div(),
|
|
/* Selection area */
|
|
$area = div(),
|
|
/* Border (four divs) */
|
|
$border = div().add(div()).add(div()).add(div()),
|
|
/* Outer area (four divs) */
|
|
$outer = div().add(div()).add(div()).add(div()),
|
|
/* Handles (empty by default, initialized in setOptions()) */
|
|
$handles = $([]),
|
|
|
|
/*
|
|
* Additional element to work around a cursor problem in Opera
|
|
* (explained later)
|
|
*/
|
|
$areaOpera,
|
|
|
|
/* Image position (relative to viewport) */
|
|
left, top,
|
|
|
|
/* Image offset (as returned by .offset()) */
|
|
imgOfs = { left: 0, top: 0 },
|
|
|
|
/* Image dimensions (as returned by .width() and .height()) */
|
|
imgWidth, imgHeight,
|
|
|
|
/*
|
|
* jQuery object representing the parent element that the plugin
|
|
* elements are appended to
|
|
*/
|
|
$parent,
|
|
|
|
/* Parent element offset (as returned by .offset()) */
|
|
parOfs = { left: 0, top: 0 },
|
|
|
|
/* Base z-index for plugin elements */
|
|
zIndex = 0,
|
|
|
|
/* Plugin elements position */
|
|
position = 'absolute',
|
|
|
|
/* X/Y coordinates of the starting point for move/resize operations */
|
|
startX, startY,
|
|
|
|
/* Horizontal and vertical scaling factors */
|
|
scaleX, scaleY,
|
|
|
|
/* Current resize mode ("nw", "se", etc.) */
|
|
resize,
|
|
|
|
/* Selection area constraints */
|
|
minWidth, minHeight, maxWidth, maxHeight,
|
|
|
|
/* Aspect ratio to maintain (floating point number) */
|
|
aspectRatio,
|
|
|
|
/* Are the plugin elements currently displayed? */
|
|
shown,
|
|
|
|
/* Current selection (relative to parent element) */
|
|
x1, y1, x2, y2,
|
|
|
|
/* Current selection (relative to scaled image) */
|
|
selection = { x1: 0, y1: 0, x2: 0, y2: 0, width: 0, height: 0 },
|
|
|
|
/* Document element */
|
|
docElem = document.documentElement,
|
|
|
|
/* User agent */
|
|
ua = navigator.userAgent,
|
|
|
|
/* Various helper variables used throughout the code */
|
|
$p, d, i, o, w, h, adjusted;
|
|
|
|
/*
|
|
* Translate selection coordinates (relative to scaled image) to viewport
|
|
* coordinates (relative to parent element)
|
|
*/
|
|
|
|
/**
|
|
* Translate selection X to viewport X
|
|
*
|
|
* @param x
|
|
* Selection X
|
|
* @return Viewport X
|
|
*/
|
|
function viewX(x) {
|
|
return x + imgOfs.left - parOfs.left;
|
|
}
|
|
|
|
/**
|
|
* Translate selection Y to viewport Y
|
|
*
|
|
* @param y
|
|
* Selection Y
|
|
* @return Viewport Y
|
|
*/
|
|
function viewY(y) {
|
|
return y + imgOfs.top - parOfs.top;
|
|
}
|
|
|
|
/*
|
|
* Translate viewport coordinates to selection coordinates
|
|
*/
|
|
|
|
/**
|
|
* Translate viewport X to selection X
|
|
*
|
|
* @param x
|
|
* Viewport X
|
|
* @return Selection X
|
|
*/
|
|
function selX(x) {
|
|
return x - imgOfs.left + parOfs.left;
|
|
}
|
|
|
|
/**
|
|
* Translate viewport Y to selection Y
|
|
*
|
|
* @param y
|
|
* Viewport Y
|
|
* @return Selection Y
|
|
*/
|
|
function selY(y) {
|
|
return y - imgOfs.top + parOfs.top;
|
|
}
|
|
|
|
/*
|
|
* Translate event coordinates (relative to document) to viewport
|
|
* coordinates
|
|
*/
|
|
|
|
/**
|
|
* Get event X and translate it to viewport X
|
|
*
|
|
* @param event
|
|
* The event object
|
|
* @return Viewport X
|
|
*/
|
|
function evX(event) {
|
|
return max(event.pageX || 0, touchCoords(event).x) - parOfs.left;
|
|
}
|
|
|
|
/**
|
|
* Get event Y and translate it to viewport Y
|
|
*
|
|
* @param event
|
|
* The event object
|
|
* @return Viewport Y
|
|
*/
|
|
function evY(event) {
|
|
return max(event.pageY || 0, touchCoords(event).y) - parOfs.top;
|
|
}
|
|
|
|
/**
|
|
* Get X and Y coordinates of a touch event
|
|
*
|
|
* @param event
|
|
* The event object
|
|
* @return Coordinates object
|
|
*/
|
|
function touchCoords(event) {
|
|
var oev = event.originalEvent || {};
|
|
|
|
if (oev.touches && oev.touches.length)
|
|
return { x: oev.touches[0].pageX, y: oev.touches[0].pageY };
|
|
else
|
|
return { x: 0, y: 0 };
|
|
}
|
|
|
|
/**
|
|
* Get the current selection
|
|
*
|
|
* @param noScale
|
|
* If set to <code>true</code>, scaling is not applied to the
|
|
* returned selection
|
|
* @return Selection object
|
|
*/
|
|
function getSelection(noScale) {
|
|
var sx = noScale || scaleX, sy = noScale || scaleY;
|
|
|
|
return { x1: floor(selection.x1 * sx),
|
|
y1: floor(selection.y1 * sy),
|
|
x2: floor(selection.x2 * sx),
|
|
y2: floor(selection.y2 * sy),
|
|
width: floor(selection.x2 * sx) - floor(selection.x1 * sx),
|
|
height: floor(selection.y2 * sy) - floor(selection.y1 * sy) };
|
|
}
|
|
|
|
/**
|
|
* Set the current selection
|
|
*
|
|
* @param x1
|
|
* X coordinate of the upper left corner of the selection area
|
|
* @param y1
|
|
* Y coordinate of the upper left corner of the selection area
|
|
* @param x2
|
|
* X coordinate of the lower right corner of the selection area
|
|
* @param y2
|
|
* Y coordinate of the lower right corner of the selection area
|
|
* @param noScale
|
|
* If set to <code>true</code>, scaling is not applied to the
|
|
* new selection
|
|
*/
|
|
function setSelection(x1, y1, x2, y2, noScale) {
|
|
var sx = noScale || scaleX, sy = noScale || scaleY;
|
|
|
|
selection = {
|
|
x1: floor(x1 / sx || 0),
|
|
y1: floor(y1 / sy || 0),
|
|
x2: floor(x2 / sx || 0),
|
|
y2: floor(y2 / sy || 0)
|
|
};
|
|
|
|
selection.width = selection.x2 - selection.x1;
|
|
selection.height = selection.y2 - selection.y1;
|
|
}
|
|
|
|
/**
|
|
* Recalculate image and parent offsets
|
|
*/
|
|
function adjust() {
|
|
/*
|
|
* Do not adjust if image has not yet loaded or if width is not a
|
|
* positive number. The latter might happen when imgAreaSelect is put
|
|
* on a parent element which is then hidden.
|
|
*/
|
|
if (!imgLoaded || !$img.width())
|
|
return;
|
|
|
|
/*
|
|
* Get image offset. The .offset() method returns float values, so they
|
|
* need to be rounded.
|
|
*/
|
|
imgOfs = { left: floor($img.offset().left), top: floor($img.offset().top) };
|
|
|
|
/* Get image dimensions */
|
|
imgWidth = $img.innerWidth();
|
|
imgHeight = $img.innerHeight();
|
|
|
|
imgOfs.top += ($img.outerHeight() - imgHeight) >> 1;
|
|
imgOfs.left += ($img.outerWidth() - imgWidth) >> 1;
|
|
|
|
/* Set minimum and maximum selection area dimensions */
|
|
minWidth = floor(options.minWidth / scaleX) || 0;
|
|
minHeight = floor(options.minHeight / scaleY) || 0;
|
|
maxWidth = floor(min(options.maxWidth / scaleX || 1<<24, imgWidth));
|
|
maxHeight = floor(min(options.maxHeight / scaleY || 1<<24, imgHeight));
|
|
|
|
/*
|
|
* Workaround for jQuery 1.3.2 incorrect offset calculation, originally
|
|
* observed in Safari 3. Firefox 2 is also affected.
|
|
*/
|
|
if ($().jquery == '1.3.2' && position == 'fixed' &&
|
|
!docElem['getBoundingClientRect'])
|
|
{
|
|
imgOfs.top += max(document.body.scrollTop, docElem.scrollTop);
|
|
imgOfs.left += max(document.body.scrollLeft, docElem.scrollLeft);
|
|
}
|
|
|
|
/* Determine parent element offset */
|
|
parOfs = /absolute|relative/.test($parent.css('position')) ?
|
|
{ left: floor($parent.offset().left) - $parent.scrollLeft(),
|
|
top: floor($parent.offset().top) - $parent.scrollTop() } :
|
|
position == 'fixed' ?
|
|
{ left: $(document).scrollLeft(), top: $(document).scrollTop() } :
|
|
{ left: 0, top: 0 };
|
|
|
|
left = viewX(0);
|
|
top = viewY(0);
|
|
|
|
/*
|
|
* Check if selection area is within image boundaries, adjust if
|
|
* necessary
|
|
*/
|
|
if (selection.x2 > imgWidth || selection.y2 > imgHeight)
|
|
doResize();
|
|
}
|
|
|
|
/**
|
|
* Update plugin elements
|
|
*
|
|
* @param resetKeyPress
|
|
* If set to <code>false</code>, this instance's keypress
|
|
* event handler is not activated
|
|
*/
|
|
function update(resetKeyPress) {
|
|
/* If plugin elements are hidden, do nothing */
|
|
if (!shown) return;
|
|
|
|
/*
|
|
* Set the position and size of the container box and the selection area
|
|
* inside it
|
|
*/
|
|
$box.css({ left: viewX(selection.x1), top: viewY(selection.y1) })
|
|
.add($area).width(w = selection.width).height(h = selection.height);
|
|
|
|
/*
|
|
* Reset the position of selection area, borders, and handles (IE6/IE7
|
|
* position them incorrectly if we don't do this)
|
|
*/
|
|
$area.add($border).add($handles).css({ left: 0, top: 0 });
|
|
|
|
/* Set border dimensions */
|
|
$border
|
|
.width(max(w - $border.outerWidth() + $border.innerWidth(), 0))
|
|
.height(max(h - $border.outerHeight() + $border.innerHeight(), 0));
|
|
|
|
/* Arrange the outer area elements */
|
|
$($outer[0]).css({ left: left, top: top,
|
|
width: selection.x1, height: imgHeight });
|
|
$($outer[1]).css({ left: left + selection.x1, top: top,
|
|
width: w, height: selection.y1 });
|
|
$($outer[2]).css({ left: left + selection.x2, top: top,
|
|
width: imgWidth - selection.x2, height: imgHeight });
|
|
$($outer[3]).css({ left: left + selection.x1, top: top + selection.y2,
|
|
width: w, height: imgHeight - selection.y2 });
|
|
|
|
w -= $handles.outerWidth();
|
|
h -= $handles.outerHeight();
|
|
|
|
/* Arrange handles */
|
|
switch ($handles.length) {
|
|
case 8:
|
|
$($handles[4]).css({ left: w >> 1 });
|
|
$($handles[5]).css({ left: w, top: h >> 1 });
|
|
$($handles[6]).css({ left: w >> 1, top: h });
|
|
$($handles[7]).css({ top: h >> 1 });
|
|
case 4:
|
|
$handles.slice(1,3).css({ left: w });
|
|
$handles.slice(2,4).css({ top: h });
|
|
}
|
|
|
|
if (resetKeyPress !== false) {
|
|
/*
|
|
* Need to reset the document keypress event handler -- unbind the
|
|
* current handler
|
|
*/
|
|
if ($.imgAreaSelect.onKeyPress != docKeyPress)
|
|
$(document).off($.imgAreaSelect.keyPress,
|
|
$.imgAreaSelect.onKeyPress);
|
|
|
|
if (options.keys)
|
|
/*
|
|
* Set the document keypress event handler to this instance's
|
|
* docKeyPress() function
|
|
*/
|
|
$(document).on( $.imgAreaSelect.keyPress, function() {
|
|
$.imgAreaSelect.onKeyPress = docKeyPress;
|
|
});
|
|
}
|
|
|
|
/*
|
|
* Internet Explorer displays 1px-wide dashed borders incorrectly by
|
|
* filling the spaces between dashes with white. Toggling the margin
|
|
* property between 0 and "auto" fixes this in IE6 and IE7 (IE8 is still
|
|
* broken). This workaround is not perfect, as it requires setTimeout()
|
|
* and thus causes the border to flicker a bit, but I haven't found a
|
|
* better solution.
|
|
*
|
|
* Note: This only happens with CSS borders, set with the borderWidth,
|
|
* borderOpacity, borderColor1, and borderColor2 options (which are now
|
|
* deprecated). Borders created with GIF background images are fine.
|
|
*/
|
|
if (msie && $border.outerWidth() - $border.innerWidth() == 2) {
|
|
$border.css('margin', 0);
|
|
setTimeout(function () { $border.css('margin', 'auto'); }, 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Do the complete update sequence: recalculate offsets, update the
|
|
* elements, and set the correct values of x1, y1, x2, and y2.
|
|
*
|
|
* @param resetKeyPress
|
|
* If set to <code>false</code>, this instance's keypress
|
|
* event handler is not activated
|
|
*/
|
|
function doUpdate(resetKeyPress) {
|
|
adjust();
|
|
update(resetKeyPress);
|
|
updateSelectionRelativeToParentElement();
|
|
}
|
|
|
|
/**
|
|
* Set the correct values of x1, y1, x2, and y2.
|
|
*/
|
|
function updateSelectionRelativeToParentElement() {
|
|
x1 = viewX(selection.x1); y1 = viewY(selection.y1);
|
|
x2 = viewX(selection.x2); y2 = viewY(selection.y2);
|
|
}
|
|
|
|
/**
|
|
* Hide or fade out an element (or multiple elements)
|
|
*
|
|
* @param $elem
|
|
* A jQuery object containing the element(s) to hide/fade out
|
|
* @param fn
|
|
* Callback function to be called when fadeOut() completes
|
|
*/
|
|
function hide($elem, fn) {
|
|
options.fadeSpeed ? $elem.fadeOut(options.fadeSpeed, fn) : $elem.hide();
|
|
}
|
|
|
|
/**
|
|
* Selection area mousemove event handler
|
|
*
|
|
* @param event
|
|
* The event object
|
|
*/
|
|
function areaMouseMove(event) {
|
|
var x = selX(evX(event)) - selection.x1,
|
|
y = selY(evY(event)) - selection.y1;
|
|
|
|
if (!adjusted) {
|
|
adjust();
|
|
adjusted = true;
|
|
|
|
$box.one('mouseout', function () { adjusted = false; });
|
|
}
|
|
|
|
/* Clear the resize mode */
|
|
resize = '';
|
|
|
|
if (options.resizable) {
|
|
/*
|
|
* Check if the mouse pointer is over the resize margin area and set
|
|
* the resize mode accordingly
|
|
*/
|
|
if (y <= options.resizeMargin)
|
|
resize = 'n';
|
|
else if (y >= selection.height - options.resizeMargin)
|
|
resize = 's';
|
|
if (x <= options.resizeMargin)
|
|
resize += 'w';
|
|
else if (x >= selection.width - options.resizeMargin)
|
|
resize += 'e';
|
|
}
|
|
|
|
$box.css('cursor', resize ? resize + '-resize' :
|
|
options.movable ? 'move' : '');
|
|
if ($areaOpera)
|
|
$areaOpera.toggle();
|
|
}
|
|
|
|
/**
|
|
* Document mouseup event handler
|
|
*
|
|
* @param event
|
|
* The event object
|
|
*/
|
|
function docMouseUp(event) {
|
|
/* Set back the default cursor */
|
|
$('body').css('cursor', '');
|
|
/*
|
|
* If autoHide is enabled, or if the selection has zero width/height,
|
|
* hide the selection and the outer area
|
|
*/
|
|
if (options.autoHide || selection.width * selection.height == 0)
|
|
hide($box.add($outer), function () { $(this).hide(); });
|
|
|
|
$(document).off('mousemove touchmove', selectingMouseMove);
|
|
$box.on('mousemove touchmove', areaMouseMove);
|
|
|
|
options.onSelectEnd(img, getSelection());
|
|
}
|
|
|
|
/**
|
|
* Selection area mousedown event handler
|
|
*
|
|
* @param event
|
|
* The event object
|
|
* @return false
|
|
*/
|
|
function areaMouseDown(event) {
|
|
if (event.type == 'mousedown' && event.which != 1) return false;
|
|
|
|
/*
|
|
* With mobile browsers, there is no "moving the pointer over" action,
|
|
* so we need to simulate one mousemove event happening prior to
|
|
* mousedown/touchstart.
|
|
*/
|
|
areaMouseMove(event);
|
|
|
|
adjust();
|
|
|
|
if (resize) {
|
|
/* Resize mode is in effect */
|
|
$('body').css('cursor', resize + '-resize');
|
|
|
|
x1 = viewX(selection[/w/.test(resize) ? 'x2' : 'x1']);
|
|
y1 = viewY(selection[/n/.test(resize) ? 'y2' : 'y1']);
|
|
|
|
$(document).on('mousemove touchmove', selectingMouseMove)
|
|
.one('mouseup touchend', docMouseUp);
|
|
$box.off('mousemove touchmove', areaMouseMove);
|
|
}
|
|
else if (options.movable) {
|
|
startX = left + selection.x1 - evX(event);
|
|
startY = top + selection.y1 - evY(event);
|
|
|
|
$box.off('mousemove touchmove', areaMouseMove);
|
|
|
|
$(document).on('mousemove touchmove', movingMouseMove)
|
|
.one('mouseup touchend', function () {
|
|
options.onSelectEnd(img, getSelection());
|
|
|
|
$(document).off('mousemove touchmove', movingMouseMove);
|
|
$box.on('mousemove touchmove', areaMouseMove);
|
|
});
|
|
}
|
|
else
|
|
$img.mousedown(event);
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Adjust the x2/y2 coordinates to maintain aspect ratio (if defined)
|
|
*
|
|
* @param xFirst
|
|
* If set to <code>true</code>, calculate x2 first. Otherwise,
|
|
* calculate y2 first.
|
|
*/
|
|
function fixAspectRatio(xFirst) {
|
|
if (aspectRatio)
|
|
if (xFirst) {
|
|
x2 = max(left, min(left + imgWidth,
|
|
x1 + abs(y2 - y1) * aspectRatio * (x2 > x1 || -1)));
|
|
y2 = floor(max(top, min(top + imgHeight,
|
|
y1 + abs(x2 - x1) / aspectRatio * (y2 > y1 || -1))));
|
|
x2 = floor(x2);
|
|
}
|
|
else {
|
|
y2 = max(top, min(top + imgHeight,
|
|
y1 + abs(x2 - x1) / aspectRatio * (y2 > y1 || -1)));
|
|
x2 = floor(max(left, min(left + imgWidth,
|
|
x1 + abs(y2 - y1) * aspectRatio * (x2 > x1 || -1))));
|
|
y2 = floor(y2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resize the selection area respecting the minimum/maximum dimensions and
|
|
* aspect ratio
|
|
*/
|
|
function doResize() {
|
|
/*
|
|
* Make sure x1, x2, y1, y2 are initialized to avoid the following calculation
|
|
* getting incorrect results.
|
|
*/
|
|
if ( x1 == null || x2 == null || y1 == null || y2 == null ) {
|
|
updateSelectionRelativeToParentElement();
|
|
}
|
|
|
|
/*
|
|
* Make sure the top left corner of the selection area stays within
|
|
* image boundaries (it might not if the image source was dynamically
|
|
* changed).
|
|
*/
|
|
x1 = min(x1, left + imgWidth);
|
|
y1 = min(y1, top + imgHeight);
|
|
|
|
if (abs(x2 - x1) < minWidth) {
|
|
/* Selection width is smaller than minWidth */
|
|
x2 = x1 - minWidth * (x2 < x1 || -1);
|
|
|
|
if (x2 < left)
|
|
x1 = left + minWidth;
|
|
else if (x2 > left + imgWidth)
|
|
x1 = left + imgWidth - minWidth;
|
|
}
|
|
|
|
if (abs(y2 - y1) < minHeight) {
|
|
/* Selection height is smaller than minHeight */
|
|
y2 = y1 - minHeight * (y2 < y1 || -1);
|
|
|
|
if (y2 < top)
|
|
y1 = top + minHeight;
|
|
else if (y2 > top + imgHeight)
|
|
y1 = top + imgHeight - minHeight;
|
|
}
|
|
|
|
x2 = max(left, min(x2, left + imgWidth));
|
|
y2 = max(top, min(y2, top + imgHeight));
|
|
|
|
fixAspectRatio(abs(x2 - x1) < abs(y2 - y1) * aspectRatio);
|
|
|
|
if (abs(x2 - x1) > maxWidth) {
|
|
/* Selection width is greater than maxWidth */
|
|
x2 = x1 - maxWidth * (x2 < x1 || -1);
|
|
fixAspectRatio();
|
|
}
|
|
|
|
if (abs(y2 - y1) > maxHeight) {
|
|
/* Selection height is greater than maxHeight */
|
|
y2 = y1 - maxHeight * (y2 < y1 || -1);
|
|
fixAspectRatio(true);
|
|
}
|
|
|
|
selection = { x1: selX(min(x1, x2)), x2: selX(max(x1, x2)),
|
|
y1: selY(min(y1, y2)), y2: selY(max(y1, y2)),
|
|
width: abs(x2 - x1), height: abs(y2 - y1) };
|
|
|
|
update();
|
|
|
|
options.onSelectChange(img, getSelection());
|
|
}
|
|
|
|
/**
|
|
* Mousemove event handler triggered when the user is selecting an area
|
|
*
|
|
* @param event
|
|
* The event object
|
|
* @return false
|
|
*/
|
|
function selectingMouseMove(event) {
|
|
x2 = /w|e|^$/.test(resize) || aspectRatio ? evX(event) : viewX(selection.x2);
|
|
y2 = /n|s|^$/.test(resize) || aspectRatio ? evY(event) : viewY(selection.y2);
|
|
|
|
doResize();
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Move the selection area
|
|
*
|
|
* @param newX1
|
|
* New viewport X1
|
|
* @param newY1
|
|
* New viewport Y1
|
|
*/
|
|
function doMove(newX1, newY1) {
|
|
x2 = (x1 = newX1) + selection.width;
|
|
y2 = (y1 = newY1) + selection.height;
|
|
|
|
$.extend(selection, { x1: selX(x1), y1: selY(y1), x2: selX(x2),
|
|
y2: selY(y2) });
|
|
|
|
update();
|
|
|
|
options.onSelectChange(img, getSelection());
|
|
}
|
|
|
|
/**
|
|
* Mousemove event handler triggered when the selection area is being moved
|
|
*
|
|
* @param event
|
|
* The event object
|
|
* @return false
|
|
*/
|
|
function movingMouseMove(event) {
|
|
x1 = max(left, min(startX + evX(event), left + imgWidth - selection.width));
|
|
y1 = max(top, min(startY + evY(event), top + imgHeight - selection.height));
|
|
|
|
doMove(x1, y1);
|
|
|
|
event.preventDefault();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Start selection
|
|
*/
|
|
function startSelection() {
|
|
$(document).off('mousemove touchmove', startSelection);
|
|
adjust();
|
|
|
|
x2 = x1;
|
|
y2 = y1;
|
|
doResize();
|
|
|
|
resize = '';
|
|
|
|
if (!$outer.is(':visible'))
|
|
/* Show the plugin elements */
|
|
$box.add($outer).hide().fadeIn(options.fadeSpeed||0);
|
|
|
|
shown = true;
|
|
|
|
$(document).off('mouseup touchend', cancelSelection)
|
|
.on('mousemove touchmove', selectingMouseMove)
|
|
.one('mouseup touchend', docMouseUp);
|
|
$box.off('mousemove touchmove', areaMouseMove);
|
|
|
|
options.onSelectStart(img, getSelection());
|
|
}
|
|
|
|
/**
|
|
* Cancel selection
|
|
*/
|
|
function cancelSelection() {
|
|
$(document).off('mousemove touchmove', startSelection)
|
|
.off('mouseup touchend', cancelSelection);
|
|
hide($box.add($outer));
|
|
|
|
setSelection(selX(x1), selY(y1), selX(x1), selY(y1));
|
|
|
|
/* If this is an API call, callback functions should not be triggered */
|
|
if (!(this instanceof $.imgAreaSelect)) {
|
|
options.onSelectChange(img, getSelection());
|
|
options.onSelectEnd(img, getSelection());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Image mousedown event handler
|
|
*
|
|
* @param event
|
|
* The event object
|
|
* @return false
|
|
*/
|
|
function imgMouseDown(event) {
|
|
/* Ignore the event if animation is in progress */
|
|
if (event.which > 1 || $outer.is(':animated')) return false;
|
|
|
|
adjust();
|
|
startX = x1 = evX(event);
|
|
startY = y1 = evY(event);
|
|
|
|
/* Selection will start when the mouse is moved */
|
|
$(document).on({ 'mousemove touchmove': startSelection,
|
|
'mouseup touchend': cancelSelection });
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Window resize event handler
|
|
*/
|
|
function windowResize() {
|
|
doUpdate(false);
|
|
}
|
|
|
|
/**
|
|
* Image load event handler. This is the final part of the initialization
|
|
* process.
|
|
*/
|
|
function imgLoad() {
|
|
imgLoaded = true;
|
|
|
|
/* Set options */
|
|
setOptions(options = $.extend({
|
|
classPrefix: 'imgareaselect',
|
|
movable: true,
|
|
parent: 'body',
|
|
resizable: true,
|
|
resizeMargin: 10,
|
|
onInit: function () {},
|
|
onSelectStart: function () {},
|
|
onSelectChange: function () {},
|
|
onSelectEnd: function () {}
|
|
}, options));
|
|
|
|
$box.add($outer).css({ visibility: '' });
|
|
|
|
if (options.show) {
|
|
shown = true;
|
|
adjust();
|
|
update();
|
|
$box.add($outer).hide().fadeIn(options.fadeSpeed||0);
|
|
}
|
|
|
|
/*
|
|
* Call the onInit callback. The setTimeout() call is used to ensure
|
|
* that the plugin has been fully initialized and the object instance is
|
|
* available (so that it can be obtained in the callback).
|
|
*/
|
|
setTimeout(function () { options.onInit(img, getSelection()); }, 0);
|
|
}
|
|
|
|
/**
|
|
* Document keypress event handler
|
|
*
|
|
* @param event
|
|
* The event object
|
|
* @return false
|
|
*/
|
|
var docKeyPress = function(event) {
|
|
var k = options.keys, d, t, key = event.keyCode;
|
|
|
|
d = !isNaN(k.alt) && (event.altKey || event.originalEvent.altKey) ? k.alt :
|
|
!isNaN(k.ctrl) && event.ctrlKey ? k.ctrl :
|
|
!isNaN(k.shift) && event.shiftKey ? k.shift :
|
|
!isNaN(k.arrows) ? k.arrows : 10;
|
|
|
|
if (k.arrows == 'resize' || (k.shift == 'resize' && event.shiftKey) ||
|
|
(k.ctrl == 'resize' && event.ctrlKey) ||
|
|
(k.alt == 'resize' && (event.altKey || event.originalEvent.altKey)))
|
|
{
|
|
/* Resize selection */
|
|
|
|
switch (key) {
|
|
case 37:
|
|
/* Left */
|
|
d = -d;
|
|
case 39:
|
|
/* Right */
|
|
t = max(x1, x2);
|
|
x1 = min(x1, x2);
|
|
x2 = max(t + d, x1);
|
|
fixAspectRatio();
|
|
break;
|
|
case 38:
|
|
/* Up */
|
|
d = -d;
|
|
case 40:
|
|
/* Down */
|
|
t = max(y1, y2);
|
|
y1 = min(y1, y2);
|
|
y2 = max(t + d, y1);
|
|
fixAspectRatio(true);
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
doResize();
|
|
}
|
|
else {
|
|
/* Move selection */
|
|
|
|
x1 = min(x1, x2);
|
|
y1 = min(y1, y2);
|
|
|
|
switch (key) {
|
|
case 37:
|
|
/* Left */
|
|
doMove(max(x1 - d, left), y1);
|
|
break;
|
|
case 38:
|
|
/* Up */
|
|
doMove(x1, max(y1 - d, top));
|
|
break;
|
|
case 39:
|
|
/* Right */
|
|
doMove(x1 + min(d, imgWidth - selX(x2)), y1);
|
|
break;
|
|
case 40:
|
|
/* Down */
|
|
doMove(x1, y1 + min(d, imgHeight - selY(y2)));
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Apply style options to plugin element (or multiple elements)
|
|
*
|
|
* @param $elem
|
|
* A jQuery object representing the element(s) to style
|
|
* @param props
|
|
* An object that maps option names to corresponding CSS
|
|
* properties
|
|
*/
|
|
function styleOptions($elem, props) {
|
|
for (var option in props)
|
|
if (options[option] !== undefined)
|
|
$elem.css(props[option], options[option]);
|
|
}
|
|
|
|
/**
|
|
* Set plugin options
|
|
*
|
|
* @param newOptions
|
|
* The new options object
|
|
*/
|
|
function setOptions(newOptions) {
|
|
if (newOptions.parent)
|
|
($parent = $(newOptions.parent)).append($box.add($outer));
|
|
|
|
/* Merge the new options with the existing ones */
|
|
$.extend(options, newOptions);
|
|
|
|
adjust();
|
|
|
|
if (newOptions.handles != null) {
|
|
/* Recreate selection area handles */
|
|
$handles.remove();
|
|
$handles = $([]);
|
|
|
|
i = newOptions.handles ? newOptions.handles == 'corners' ? 4 : 8 : 0;
|
|
|
|
while (i--)
|
|
$handles = $handles.add(div());
|
|
|
|
/* Add a class to handles and set the CSS properties */
|
|
$handles.addClass(options.classPrefix + '-handle').css({
|
|
position: 'absolute',
|
|
/*
|
|
* The font-size property needs to be set to zero, otherwise
|
|
* Internet Explorer makes the handles too large
|
|
*/
|
|
fontSize: '0',
|
|
zIndex: zIndex + 1 || 1
|
|
});
|
|
|
|
/*
|
|
* If handle width/height has not been set with CSS rules, set the
|
|
* default 5px
|
|
*/
|
|
if (!parseInt($handles.css('width')) >= 0)
|
|
$handles.width(10).height(10);
|
|
|
|
/*
|
|
* If the borderWidth option is in use, add a solid border to
|
|
* handles
|
|
*/
|
|
if (o = options.borderWidth)
|
|
$handles.css({ borderWidth: o, borderStyle: 'solid' });
|
|
|
|
/* Apply other style options */
|
|
styleOptions($handles, { borderColor1: 'border-color',
|
|
borderColor2: 'background-color',
|
|
borderOpacity: 'opacity' });
|
|
}
|
|
|
|
/* Calculate scale factors */
|
|
scaleX = options.imageWidth / imgWidth || 1;
|
|
scaleY = options.imageHeight / imgHeight || 1;
|
|
|
|
/* Set selection */
|
|
if (newOptions.x1 != null) {
|
|
setSelection(newOptions.x1, newOptions.y1, newOptions.x2,
|
|
newOptions.y2);
|
|
newOptions.show = !newOptions.hide;
|
|
}
|
|
|
|
if (newOptions.keys)
|
|
/* Enable keyboard support */
|
|
options.keys = $.extend({ shift: 1, ctrl: 'resize' },
|
|
newOptions.keys);
|
|
|
|
/* Add classes to plugin elements */
|
|
$outer.addClass(options.classPrefix + '-outer');
|
|
$area.addClass(options.classPrefix + '-selection');
|
|
for (i = 0; i++ < 4;)
|
|
$($border[i-1]).addClass(options.classPrefix + '-border' + i);
|
|
|
|
/* Apply style options */
|
|
styleOptions($area, { selectionColor: 'background-color',
|
|
selectionOpacity: 'opacity' });
|
|
styleOptions($border, { borderOpacity: 'opacity',
|
|
borderWidth: 'border-width' });
|
|
styleOptions($outer, { outerColor: 'background-color',
|
|
outerOpacity: 'opacity' });
|
|
if (o = options.borderColor1)
|
|
$($border[0]).css({ borderStyle: 'solid', borderColor: o });
|
|
if (o = options.borderColor2)
|
|
$($border[1]).css({ borderStyle: 'dashed', borderColor: o });
|
|
|
|
/* Append all the selection area elements to the container box */
|
|
$box.append($area.add($border).add($areaOpera)).append($handles);
|
|
|
|
if (msie) {
|
|
if (o = ($outer.css('filter')||'').match(/opacity=(\d+)/))
|
|
$outer.css('opacity', o[1]/100);
|
|
if (o = ($border.css('filter')||'').match(/opacity=(\d+)/))
|
|
$border.css('opacity', o[1]/100);
|
|
}
|
|
|
|
if (newOptions.hide)
|
|
hide($box.add($outer));
|
|
else if (newOptions.show && imgLoaded) {
|
|
shown = true;
|
|
$box.add($outer).fadeIn(options.fadeSpeed||0);
|
|
doUpdate();
|
|
}
|
|
|
|
/* Calculate the aspect ratio factor */
|
|
aspectRatio = (d = (options.aspectRatio || '').split(/:/))[0] / d[1];
|
|
|
|
$img.add($outer).off('mousedown', imgMouseDown);
|
|
|
|
if (options.disable || options.enable === false) {
|
|
/* Disable the plugin */
|
|
$box.off({ 'mousemove touchmove': areaMouseMove,
|
|
'mousedown touchstart': areaMouseDown });
|
|
$(window).off('resize', windowResize);
|
|
}
|
|
else {
|
|
if (options.enable || options.disable === false) {
|
|
/* Enable the plugin */
|
|
if (options.resizable || options.movable)
|
|
$box.on({ 'mousemove touchmove': areaMouseMove,
|
|
'mousedown touchstart': areaMouseDown });
|
|
|
|
$(window).on( 'resize', windowResize);
|
|
}
|
|
|
|
if (!options.persistent)
|
|
$img.add($outer).on('mousedown touchstart', imgMouseDown);
|
|
}
|
|
|
|
options.enable = options.disable = undefined;
|
|
}
|
|
|
|
/**
|
|
* Remove plugin completely
|
|
*/
|
|
this.remove = function () {
|
|
/*
|
|
* Call setOptions with { disable: true } to unbind the event handlers
|
|
*/
|
|
setOptions({ disable: true });
|
|
$box.add($outer).remove();
|
|
};
|
|
|
|
/*
|
|
* Public API
|
|
*/
|
|
|
|
/**
|
|
* Get current options
|
|
*
|
|
* @return An object containing the set of options currently in use
|
|
*/
|
|
this.getOptions = function () { return options; };
|
|
|
|
/**
|
|
* Set plugin options
|
|
*
|
|
* @param newOptions
|
|
* The new options object
|
|
*/
|
|
this.setOptions = setOptions;
|
|
|
|
/**
|
|
* Get the current selection
|
|
*
|
|
* @param noScale
|
|
* If set to <code>true</code>, scaling is not applied to the
|
|
* returned selection
|
|
* @return Selection object
|
|
*/
|
|
this.getSelection = getSelection;
|
|
|
|
/**
|
|
* Set the current selection
|
|
*
|
|
* @param x1
|
|
* X coordinate of the upper left corner of the selection area
|
|
* @param y1
|
|
* Y coordinate of the upper left corner of the selection area
|
|
* @param x2
|
|
* X coordinate of the lower right corner of the selection area
|
|
* @param y2
|
|
* Y coordinate of the lower right corner of the selection area
|
|
* @param noScale
|
|
* If set to <code>true</code>, scaling is not applied to the
|
|
* new selection
|
|
*/
|
|
this.setSelection = setSelection;
|
|
|
|
/**
|
|
* Cancel selection
|
|
*/
|
|
this.cancelSelection = cancelSelection;
|
|
|
|
/**
|
|
* Update plugin elements
|
|
*
|
|
* @param resetKeyPress
|
|
* If set to <code>false</code>, this instance's keypress
|
|
* event handler is not activated
|
|
*/
|
|
this.update = doUpdate;
|
|
|
|
/* Do the dreaded browser detection */
|
|
var msie = (/msie ([\w.]+)/i.exec(ua)||[])[1],
|
|
opera = /opera/i.test(ua),
|
|
safari = /webkit/i.test(ua) && !/chrome/i.test(ua);
|
|
|
|
/*
|
|
* Traverse the image's parent elements (up to <body>) and find the
|
|
* highest z-index
|
|
*/
|
|
$p = $img;
|
|
|
|
while ($p.length) {
|
|
zIndex = max(zIndex,
|
|
!isNaN($p.css('z-index')) ? $p.css('z-index') : zIndex);
|
|
/* Also check if any of the ancestor elements has fixed position */
|
|
if ($p.css('position') == 'fixed')
|
|
position = 'fixed';
|
|
|
|
$p = $p.parent(':not(body)');
|
|
}
|
|
|
|
/*
|
|
* If z-index is given as an option, it overrides the one found by the
|
|
* above loop
|
|
*/
|
|
zIndex = options.zIndex || zIndex;
|
|
|
|
if (msie)
|
|
$img.attr('unselectable', 'on');
|
|
|
|
/*
|
|
* In MSIE and WebKit, we need to use the keydown event instead of keypress
|
|
*/
|
|
$.imgAreaSelect.keyPress = msie || safari ? 'keydown' : 'keypress';
|
|
|
|
/*
|
|
* There is a bug affecting the CSS cursor property in Opera (observed in
|
|
* versions up to 10.00) that prevents the cursor from being updated unless
|
|
* the mouse leaves and enters the element again. To trigger the mouseover
|
|
* event, we're adding an additional div to $box and we're going to toggle
|
|
* it when mouse moves inside the selection area.
|
|
*/
|
|
if (opera)
|
|
$areaOpera = div().css({ width: '100%', height: '100%',
|
|
position: 'absolute', zIndex: zIndex + 2 || 2 });
|
|
|
|
/*
|
|
* We initially set visibility to "hidden" as a workaround for a weird
|
|
* behaviour observed in Google Chrome 1.0.154.53 (on Windows XP). Normally
|
|
* we would just set display to "none", but, for some reason, if we do so
|
|
* then Chrome refuses to later display the element with .show() or
|
|
* .fadeIn().
|
|
*/
|
|
$box.add($outer).css({ visibility: 'hidden', position: position,
|
|
overflow: 'hidden', zIndex: zIndex || '0' });
|
|
$box.css({ zIndex: zIndex + 2 || 2 });
|
|
$area.add($border).css({ position: 'absolute', fontSize: '0' });
|
|
|
|
/*
|
|
* If the image has been fully loaded, or if it is not really an image (eg.
|
|
* a div), call imgLoad() immediately; otherwise, bind it to be called once
|
|
* on image load event.
|
|
*/
|
|
img.complete || img.readyState == 'complete' || !$img.is('img') ?
|
|
imgLoad() : $img.one('load', imgLoad);
|
|
|
|
/*
|
|
* MSIE 9.0 doesn't always fire the image load event -- resetting the src
|
|
* attribute seems to trigger it. The check is for version 7 and above to
|
|
* accommodate for MSIE 9 running in compatibility mode.
|
|
*/
|
|
if (!imgLoaded && msie && msie >= 7)
|
|
img.src = img.src;
|
|
};
|
|
|
|
/**
|
|
* Invoke imgAreaSelect on a jQuery object containing the image(s)
|
|
*
|
|
* @param options
|
|
* Options object
|
|
* @return The jQuery object or a reference to imgAreaSelect instance (if the
|
|
* <code>instance</code> option was specified)
|
|
*/
|
|
$.fn.imgAreaSelect = function (options) {
|
|
options = options || {};
|
|
|
|
this.each(function () {
|
|
/* Is there already an imgAreaSelect instance bound to this element? */
|
|
if ($(this).data('imgAreaSelect')) {
|
|
/* Yes there is -- is it supposed to be removed? */
|
|
if (options.remove) {
|
|
/* Remove the plugin */
|
|
$(this).data('imgAreaSelect').remove();
|
|
$(this).removeData('imgAreaSelect');
|
|
}
|
|
else
|
|
/* Reset options */
|
|
$(this).data('imgAreaSelect').setOptions(options);
|
|
}
|
|
else if (!options.remove) {
|
|
/* No exising instance -- create a new one */
|
|
|
|
/*
|
|
* If neither the "enable" nor the "disable" option is present, add
|
|
* "enable" as the default
|
|
*/
|
|
if (options.enable === undefined && options.disable === undefined)
|
|
options.enable = true;
|
|
|
|
$(this).data('imgAreaSelect', new $.imgAreaSelect(this, options));
|
|
}
|
|
});
|
|
|
|
if (options.instance)
|
|
/*
|
|
* Return the imgAreaSelect instance bound to the first element in the
|
|
* set
|
|
*/
|
|
return $(this).data('imgAreaSelect');
|
|
|
|
return this;
|
|
};
|
|
|
|
})(jQuery);
|