gecko-dev/toolkit/modules/Geometry.jsm
Ian Moody 57b82dd9be Bug 1544284 - toolkit/ automated ESLint no-throw-literal fixes. r=Standard8
Result of running:
$ mach eslint -funix toolkit/ | sed -Ee 's/:.+//' - | xargs sed -E \
    -e 's/throw ((["`])[^"]+\2);/throw new Error(\1);/g' \
    -e 's/throw ((["`])[^"]+\2 \+ [^ ";]+);/throw new Error(\1);/g' \
    -e 's/throw \(/throw new Error(/g' -i

...and then reverting a couple of places where comments were touched,
as well as changes to toolkit/components/ctypes/tests/unit/test_jsctypes.js
that required expectation changes to
toolkit/components/ctypes/tests/chrome/test_ctypes.xul

Differential Revision: https://phabricator.services.mozilla.com/D27448

--HG--
extra : moz-landing-system : lando
2019-04-16 19:30:27 +00:00

347 lines
8.8 KiB
JavaScript

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
var EXPORTED_SYMBOLS = ["Point", "Rect"];
/**
* Simple Point class.
*
* Any method that takes an x and y may also take a point.
*/
function Point(x, y) {
this.set(x, y);
}
Point.prototype = {
clone: function clone() {
return new Point(this.x, this.y);
},
set: function set(x, y) {
this.x = x;
this.y = y;
return this;
},
equals: function equals(x, y) {
return this.x == x && this.y == y;
},
toString: function toString() {
return "(" + this.x + "," + this.y + ")";
},
map: function map(f) {
this.x = f.call(this, this.x);
this.y = f.call(this, this.y);
return this;
},
add: function add(x, y) {
this.x += x;
this.y += y;
return this;
},
subtract: function subtract(x, y) {
this.x -= x;
this.y -= y;
return this;
},
scale: function scale(s) {
this.x *= s;
this.y *= s;
return this;
},
isZero() {
return this.x == 0 && this.y == 0;
},
};
(function() {
function takePointOrArgs(f) {
return function(arg1, arg2) {
if (arg2 === undefined)
return f.call(this, arg1.x, arg1.y);
return f.call(this, arg1, arg2);
};
}
for (let f of ["add", "subtract", "equals", "set"])
Point.prototype[f] = takePointOrArgs(Point.prototype[f]);
})();
/**
* Rect is a simple data structure for representation of a rectangle supporting
* many basic geometric operations.
*
* NOTE: Since its operations are closed, rectangles may be empty and will report
* non-positive widths and heights in that case.
*/
function Rect(x, y, w, h) {
this.left = x;
this.top = y;
this.right = x + w;
this.bottom = y + h;
}
Rect.fromRect = function fromRect(r) {
return new Rect(r.left, r.top, r.right - r.left, r.bottom - r.top);
};
Rect.prototype = {
get x() { return this.left; },
get y() { return this.top; },
get width() { return this.right - this.left; },
get height() { return this.bottom - this.top; },
set x(v) {
let diff = this.left - v;
this.left = v;
this.right -= diff;
},
set y(v) {
let diff = this.top - v;
this.top = v;
this.bottom -= diff;
},
set width(v) { this.right = this.left + v; },
set height(v) { this.bottom = this.top + v; },
isEmpty: function isEmpty() {
return this.left >= this.right || this.top >= this.bottom;
},
setRect(x, y, w, h) {
this.left = x;
this.top = y;
this.right = x + w;
this.bottom = y + h;
return this;
},
setBounds(l, t, r, b) {
this.top = t;
this.left = l;
this.bottom = b;
this.right = r;
return this;
},
equals: function equals(other) {
return other != null &&
(this.isEmpty() && other.isEmpty() ||
this.top == other.top &&
this.left == other.left &&
this.bottom == other.bottom &&
this.right == other.right);
},
clone: function clone() {
return new Rect(this.left, this.top, this.right - this.left, this.bottom - this.top);
},
center: function center() {
if (this.isEmpty())
throw new Error("Empty rectangles do not have centers");
return new Point(this.left + (this.right - this.left) / 2,
this.top + (this.bottom - this.top) / 2);
},
copyFrom(other) {
this.top = other.top;
this.left = other.left;
this.bottom = other.bottom;
this.right = other.right;
return this;
},
translate(x, y) {
this.left += x;
this.right += x;
this.top += y;
this.bottom += y;
return this;
},
toString() {
return "[" + this.x + "," + this.y + "," + this.width + "," + this.height + "]";
},
/** return a new rect that is the union of that one and this one */
union(other) {
return this.clone().expandToContain(other);
},
contains(other) {
if (other.isEmpty()) return true;
if (this.isEmpty()) return false;
return (other.left >= this.left &&
other.right <= this.right &&
other.top >= this.top &&
other.bottom <= this.bottom);
},
intersect(other) {
return this.clone().restrictTo(other);
},
intersects(other) {
if (this.isEmpty() || other.isEmpty())
return false;
let x1 = Math.max(this.left, other.left);
let x2 = Math.min(this.right, other.right);
let y1 = Math.max(this.top, other.top);
let y2 = Math.min(this.bottom, other.bottom);
return x1 < x2 && y1 < y2;
},
/** Restrict area of this rectangle to the intersection of both rectangles. */
restrictTo: function restrictTo(other) {
if (this.isEmpty() || other.isEmpty())
return this.setRect(0, 0, 0, 0);
let x1 = Math.max(this.left, other.left);
let x2 = Math.min(this.right, other.right);
let y1 = Math.max(this.top, other.top);
let y2 = Math.min(this.bottom, other.bottom);
// If width or height is 0, the intersection was empty.
return this.setRect(x1, y1, Math.max(0, x2 - x1), Math.max(0, y2 - y1));
},
/** Expand this rectangle to the union of both rectangles. */
expandToContain: function expandToContain(other) {
if (this.isEmpty()) return this.copyFrom(other);
if (other.isEmpty()) return this;
let l = Math.min(this.left, other.left);
let r = Math.max(this.right, other.right);
let t = Math.min(this.top, other.top);
let b = Math.max(this.bottom, other.bottom);
return this.setRect(l, t, r - l, b - t);
},
/**
* Expands to the smallest rectangle that contains original rectangle and is bounded
* by lines with integer coefficients.
*/
expandToIntegers: function round() {
this.left = Math.floor(this.left);
this.top = Math.floor(this.top);
this.right = Math.ceil(this.right);
this.bottom = Math.ceil(this.bottom);
return this;
},
scale: function scale(xscl, yscl) {
this.left *= xscl;
this.right *= xscl;
this.top *= yscl;
this.bottom *= yscl;
return this;
},
map: function map(f) {
this.left = f.call(this, this.left);
this.top = f.call(this, this.top);
this.right = f.call(this, this.right);
this.bottom = f.call(this, this.bottom);
return this;
},
/** Ensure this rectangle is inside the other, if possible. Preserves w, h. */
translateInside: function translateInside(other) {
let offsetX = 0;
if (this.left <= other.left)
offsetX = other.left - this.left;
else if (this.right > other.right)
offsetX = other.right - this.right;
let offsetY = 0;
if (this.top <= other.top)
offsetY = other.top - this.top;
else if (this.bottom > other.bottom)
offsetY = other.bottom - this.bottom;
return this.translate(offsetX, offsetY);
},
/** Subtract other area from this. Returns array of rects whose union is this-other. */
subtract: function subtract(other) {
let r = new Rect(0, 0, 0, 0);
let result = [];
other = other.intersect(this);
if (other.isEmpty())
return [this.clone()];
// left strip
r.setBounds(this.left, this.top, other.left, this.bottom);
if (!r.isEmpty())
result.push(r.clone());
// inside strip
r.setBounds(other.left, this.top, other.right, other.top);
if (!r.isEmpty())
result.push(r.clone());
r.setBounds(other.left, other.bottom, other.right, this.bottom);
if (!r.isEmpty())
result.push(r.clone());
// right strip
r.setBounds(other.right, this.top, this.right, this.bottom);
if (!r.isEmpty())
result.push(r.clone());
return result;
},
/**
* Blends two rectangles together.
* @param rect Rectangle to blend this one with
* @param scalar Ratio from 0 (returns a clone of this rect) to 1 (clone of rect).
* @return New blended rectangle.
*/
blend: function blend(rect, scalar) {
return new Rect(
this.left + (rect.left - this.left ) * scalar,
this.top + (rect.top - this.top ) * scalar,
this.width + (rect.width - this.width ) * scalar,
this.height + (rect.height - this.height) * scalar);
},
/**
* Grows or shrinks the rectangle while keeping the center point.
* Accepts single multipler, or separate for both axes.
*/
inflate: function inflate(xscl, yscl) {
let xAdj = (this.width * xscl - this.width) / 2;
let s = (arguments.length > 1) ? yscl : xscl;
let yAdj = (this.height * s - this.height) / 2;
this.left -= xAdj;
this.right += xAdj;
this.top -= yAdj;
this.bottom += yAdj;
return this;
},
/**
* Grows or shrinks the rectangle by fixed amount while keeping the center point.
* Accepts single fixed amount
*/
inflateFixed: function inflateFixed(fixed) {
this.left -= fixed;
this.right += fixed;
this.top -= fixed;
this.bottom += fixed;
return this;
},
};