--- /dev/null
+<!DOCTYPE html><html><head><title>Sencha Documentation Project</title><link rel="stylesheet" href="../reset.css" type="text/css"><link rel="stylesheet" href="../prettify.css" type="text/css"><link rel="stylesheet" href="../prettify_sa.css" type="text/css"><script type="text/javascript" src="../prettify.js"></script></head><body onload="prettyPrint()"><pre class="prettyprint"><pre><span id='Ext-util.Region'>/**
+</span> * @class Ext.util.Region
+ * @extends Object
+ *
+ * Represents a rectangular region and provides a number of utility methods
+ * to compare regions.
+ */
+
+Ext.define('Ext.util.Region', {
+
+ /* Begin Definitions */
+
+ requires: ['Ext.util.Offset'],
+
+ statics: {
+<span id='Ext-util.Region-method-getRegion'> /**
+</span> * @static
+ * @param {Mixed} el A string, DomElement or Ext.core.Element representing an element
+ * on the page.
+ * @returns {Ext.util.Region} region
+ * Retrieves an Ext.util.Region for a particular element.
+ */
+ getRegion: function(el) {
+ return Ext.fly(el).getPageBox(true);
+ },
+
+<span id='Ext-util.Region-method-from'> /**
+</span> * @static
+ * @param {Object} o An object with top, right, bottom, left properties
+ * @return {Ext.util.Region} region The region constructed based on the passed object
+ */
+ from: function(o) {
+ return new this(o.top, o.right, o.bottom, o.left);
+ }
+ },
+
+ /* End Definitions */
+
+<span id='Ext-util.Region-method-constructor'> /**
+</span> * @constructor
+ * @param {Number} top Top
+ * @param {Number} right Right
+ * @param {Number} bottom Bottom
+ * @param {Number} left Left
+ */
+ constructor : function(t, r, b, l) {
+ var me = this;
+ me.y = me.top = me[1] = t;
+ me.right = r;
+ me.bottom = b;
+ me.x = me.left = me[0] = l;
+ },
+
+<span id='Ext-util.Region-method-contains'> /**
+</span> * Checks if this region completely contains the region that is passed in.
+ * @param {Ext.util.Region} region
+ */
+ contains : function(region) {
+ var me = this;
+ return (region.x >= me.x &&
+ region.right <= me.right &&
+ region.y >= me.y &&
+ region.bottom <= me.bottom);
+
+ },
+
+<span id='Ext-util.Region-method-intersect'> /**
+</span> * Checks if this region intersects the region passed in.
+ * @param {Ext.util.Region} region
+ * @return {Ext.util.Region/Boolean} Returns the intersected region or false if there is no intersection.
+ */
+ intersect : function(region) {
+ var me = this,
+ t = Math.max(me.y, region.y),
+ r = Math.min(me.right, region.right),
+ b = Math.min(me.bottom, region.bottom),
+ l = Math.max(me.x, region.x);
+
+ if (b > t && r > l) {
+ return new this.self(t, r, b, l);
+ }
+ else {
+ return false;
+ }
+ },
+
+<span id='Ext-util.Region-method-union'> /**
+</span> * Returns the smallest region that contains the current AND targetRegion.
+ * @param {Ext.util.Region} region
+ */
+ union : function(region) {
+ var me = this,
+ t = Math.min(me.y, region.y),
+ r = Math.max(me.right, region.right),
+ b = Math.max(me.bottom, region.bottom),
+ l = Math.min(me.x, region.x);
+
+ return new this.self(t, r, b, l);
+ },
+
+<span id='Ext-util.Region-method-constrainTo'> /**
+</span> * Modifies the current region to be constrained to the targetRegion.
+ * @param {Ext.util.Region} targetRegion
+ */
+ constrainTo : function(r) {
+ var me = this,
+ constrain = Ext.Number.constrain;
+ me.top = me.y = constrain(me.top, r.y, r.bottom);
+ me.bottom = constrain(me.bottom, r.y, r.bottom);
+ me.left = me.x = constrain(me.left, r.x, r.right);
+ me.right = constrain(me.right, r.x, r.right);
+ return me;
+ },
+
+<span id='Ext-util.Region-method-adjust'> /**
+</span> * Modifies the current region to be adjusted by offsets.
+ * @param {Number} top top offset
+ * @param {Number} right right offset
+ * @param {Number} bottom bottom offset
+ * @param {Number} left left offset
+ */
+ adjust : function(t, r, b, l) {
+ var me = this;
+ me.top = me.y += t;
+ me.left = me.x += l;
+ me.right += r;
+ me.bottom += b;
+ return me;
+ },
+
+<span id='Ext-util.Region-method-getOutOfBoundOffset'> /**
+</span> * Get the offset amount of a point outside the region
+ * @param {String} axis optional
+ * @param {Ext.util.Point} p the point
+ * @return {Ext.util.Offset}
+ */
+ getOutOfBoundOffset: function(axis, p) {
+ if (!Ext.isObject(axis)) {
+ if (axis == 'x') {
+ return this.getOutOfBoundOffsetX(p);
+ } else {
+ return this.getOutOfBoundOffsetY(p);
+ }
+ } else {
+ p = axis;
+ var d = Ext.create('Ext.util.Offset');
+ d.x = this.getOutOfBoundOffsetX(p.x);
+ d.y = this.getOutOfBoundOffsetY(p.y);
+ return d;
+ }
+
+ },
+
+<span id='Ext-util.Region-method-getOutOfBoundOffsetX'> /**
+</span> * Get the offset amount on the x-axis
+ * @param {Number} p the offset
+ * @return {Number}
+ */
+ getOutOfBoundOffsetX: function(p) {
+ if (p <= this.x) {
+ return this.x - p;
+ } else if (p >= this.right) {
+ return this.right - p;
+ }
+
+ return 0;
+ },
+
+<span id='Ext-util.Region-method-getOutOfBoundOffsetY'> /**
+</span> * Get the offset amount on the y-axis
+ * @param {Number} p the offset
+ * @return {Number}
+ */
+ getOutOfBoundOffsetY: function(p) {
+ if (p <= this.y) {
+ return this.y - p;
+ } else if (p >= this.bottom) {
+ return this.bottom - p;
+ }
+
+ return 0;
+ },
+
+<span id='Ext-util.Region-method-isOutOfBound'> /**
+</span> * Check whether the point / offset is out of bound
+ * @param {String} axis optional
+ * @param {Ext.util.Point/Number} p the point / offset
+ * @return {Boolean}
+ */
+ isOutOfBound: function(axis, p) {
+ if (!Ext.isObject(axis)) {
+ if (axis == 'x') {
+ return this.isOutOfBoundX(p);
+ } else {
+ return this.isOutOfBoundY(p);
+ }
+ } else {
+ p = axis;
+ return (this.isOutOfBoundX(p.x) || this.isOutOfBoundY(p.y));
+ }
+ },
+
+<span id='Ext-util.Region-method-isOutOfBoundX'> /**
+</span> * Check whether the offset is out of bound in the x-axis
+ * @param {Number} p the offset
+ * @return {Boolean}
+ */
+ isOutOfBoundX: function(p) {
+ return (p < this.x || p > this.right);
+ },
+
+<span id='Ext-util.Region-method-isOutOfBoundY'> /**
+</span> * Check whether the offset is out of bound in the y-axis
+ * @param {Number} p the offset
+ * @return {Boolean}
+ */
+ isOutOfBoundY: function(p) {
+ return (p < this.y || p > this.bottom);
+ },
+
+ /*
+ * Restrict a point within the region by a certain factor.
+ * @param {String} axis Optional
+ * @param {Ext.util.Point/Ext.util.Offset/Object} p
+ * @param {Number} factor
+ * @return {Ext.util.Point/Ext.util.Offset/Object/Number}
+ */
+ restrict: function(axis, p, factor) {
+ if (Ext.isObject(axis)) {
+ var newP;
+
+ factor = p;
+ p = axis;
+
+ if (p.copy) {
+ newP = p.copy();
+ }
+ else {
+ newP = {
+ x: p.x,
+ y: p.y
+ };
+ }
+
+ newP.x = this.restrictX(p.x, factor);
+ newP.y = this.restrictY(p.y, factor);
+ return newP;
+ } else {
+ if (axis == 'x') {
+ return this.restrictX(p, factor);
+ } else {
+ return this.restrictY(p, factor);
+ }
+ }
+ },
+
+ /*
+ * Restrict an offset within the region by a certain factor, on the x-axis
+ * @param {Number} p
+ * @param {Number} factor The factor, optional, defaults to 1
+ * @return
+ */
+ restrictX : function(p, factor) {
+ if (!factor) {
+ factor = 1;
+ }
+
+ if (p <= this.x) {
+ p -= (p - this.x) * factor;
+ }
+ else if (p >= this.right) {
+ p -= (p - this.right) * factor;
+ }
+ return p;
+ },
+
+ /*
+ * Restrict an offset within the region by a certain factor, on the y-axis
+ * @param {Number} p
+ * @param {Number} factor The factor, optional, defaults to 1
+ */
+ restrictY : function(p, factor) {
+ if (!factor) {
+ factor = 1;
+ }
+
+ if (p <= this.y) {
+ p -= (p - this.y) * factor;
+ }
+ else if (p >= this.bottom) {
+ p -= (p - this.bottom) * factor;
+ }
+ return p;
+ },
+
+ /*
+ * Get the width / height of this region
+ * @return {Object} an object with width and height properties
+ */
+ getSize: function() {
+ return {
+ width: this.right - this.x,
+ height: this.bottom - this.y
+ };
+ },
+
+<span id='Ext-util.Region-method-copy'> /**
+</span> * Copy a new instance
+ * @return {Ext.util.Region}
+ */
+ copy: function() {
+ return new this.self(this.y, this.right, this.bottom, this.x);
+ },
+
+<span id='Ext-util.Region-method-copyFrom'> /**
+</span> * Copy the values of another Region to this Region
+ * @param {Region} The region to copy from.
+ * @return {Ext.util.Point} this This point
+ */
+ copyFrom: function(p) {
+ var me = this;
+ me.top = me.y = me[1] = p.y;
+ me.right = p.right;
+ me.bottom = p.bottom;
+ me.left = me.x = me[0] = p.x;
+
+ return this;
+ },
+
+<span id='Ext-util.Region-method-toString'> /**
+</span> * Dump this to an eye-friendly string, great for debugging
+ * @return {String}
+ */
+ toString: function() {
+ return "Region[" + this.top + "," + this.right + "," + this.bottom + "," + this.left + "]";
+ },
+
+
+<span id='Ext-util.Region-method-translateBy'> /**
+</span> * Translate this region by the given offset amount
+ * @param {Ext.util.Offset/Object} offset Object containing the <code>x</code> and <code>y</code> properties.
+ * Or the x value is using the two argument form.
+ * @param {Number} The y value unless using an Offset object.
+ * @return {Ext.util.Region} this This Region
+ */
+ translateBy: function(x, y) {
+ if (arguments.length == 1) {
+ y = x.y;
+ x = x.x;
+ }
+ var me = this;
+ me.top = me.y += y;
+ me.right += x;
+ me.bottom += y;
+ me.left = me.x += x;
+
+ return me;
+ },
+
+<span id='Ext-util.Region-method-round'> /**
+</span> * Round all the properties of this region
+ * @return {Ext.util.Region} this This Region
+ */
+ round: function() {
+ var me = this;
+ me.top = me.y = Math.round(me.y);
+ me.right = Math.round(me.right);
+ me.bottom = Math.round(me.bottom);
+ me.left = me.x = Math.round(me.x);
+
+ return me;
+ },
+
+<span id='Ext-util.Region-method-equals'> /**
+</span> * Check whether this region is equivalent to the given region
+ * @param {Ext.util.Region} region The region to compare with
+ * @return {Boolean}
+ */
+ equals: function(region) {
+ return (this.top == region.top && this.right == region.right && this.bottom == region.bottom && this.left == region.left);
+ }
+});
+</pre></pre></body></html>
\ No newline at end of file
git.ithinksw.org / extjs.git / blobdiff