Creates a new rectangle object form a clientRects object.

@method fromClientRect
@param {ClientRect} clientRect DOM ClientRect object.
@return {Rect} New rectangle object.
352281
function fromClientRect(clientRect) {
      return create(clientRect.left, clientRect.top, clientRect.width, clientRect.height);
    }
842197
function Client(name, password) {

    if (!(this instanceof Client)) {
        return new Client(name, password);
    }

    this.name = name || 'RETS-Connector1/2';
    this.password = password || '';

}
1274054
function(delta) {
        return new $.Rect(
            this.x + delta.x,
            this.y + delta.y,
            this.width,
            this.height,
            this.degrees);
    }
435106
protected function normalizeRectangle(\Jdenticon\Rendering\Rectangle $rect)
    {
        $size = (int)min($rect->width, $rect->height);
        
        // Make size a multiple of the cell count
        $size -= $size % $this->getCellCount();
        
        return new Rectangle(
            (int)($rect->x + ($rect->width - $size) / 2),
            (int)($rect->y + ($rect->height - $size) / 2),
            $size,
            $size);
    }
533245
public Rectangle getBoundingClientRect(final By by) {
		WebElement el = findElement(by);

		@SuppressWarnings("unchecked")
		Map<String, Number> result = (Map<String, Number>) executeScript(JS_GET_BOUNDING_CLIENT_RECT, el);
		Rectangle rectangle = new Rectangle(result.get("top").intValue(), result.get("left").intValue(),
			result.get("bottom").intValue(), result.get("right").intValue(), result.get("width").intValue(),
			result.get("height").intValue());

		LOGGER.info("Bounding client rect for {}: {}", by, rectangle);
		return rectangle;
	}
472880
function() {

        var crect = this.viewport.getBoundingClientRect();

        // Using Screen CTM was the only way to get the real viewport bounding box working in both
        // Google Chrome and Firefox.
        var clientCTM = this.clientMatrix();

        // for non-default origin we need to take the viewport translation into account
        var currentTranslate = this.translate();

        return new g.Rect({
            x: crect.left - clientCTM.e + currentTranslate.tx,
            y: crect.top - clientCTM.f + currentTranslate.ty,
            width: crect.width,
            height: crect.height
        });
    }
1146636
function _createMaskRect() {
  const element = document.createElementNS(svgNS, 'rect');

  _setAttributes(element, {
    fill: '#FFFFFF',
    height: '100%',
    id: elementIds.modalOverlayMaskRect,
    width: '100%',
    x: '0',
    y: '0'
  });

  return element;
}
459979
function()
	{
		var b = document.body;
		var d = document.documentElement;
		
		try
		{
			return new mxRectangle(0, 0, b.clientWidth || d.clientWidth, Math.max(b.clientHeight || 0, d.clientHeight));
		}
		catch (e)
		{
			return new mxRectangle();
		}
	}
218372
function(callback) {
      var el = fabric.document.createElement('canvas');
      if (!el.getContext && typeof G_vmlCanvasManager != 'undefined') {
        G_vmlCanvasManager.initElement(el);
      }

      el.width = this.getBoundingRectWidth();
      el.height = this.getBoundingRectHeight();

      fabric.util.wrapElement(el, 'div');

      var canvas = new fabric.Canvas(el);
      canvas.backgroundColor = 'transparent';
      canvas.renderAll();

      if (this.constructor.async) {
        this.clone(proceed);
      }
      else {
        proceed(this.clone());
      }

      function proceed(clone) {
        clone.left = el.width / 2;
        clone.top = el.height / 2;

        clone.setActive(false);

        canvas.add(clone);
        var data = canvas.toDataURL('png');

        canvas.dispose();
        canvas = clone = null;

        callback && callback(data);
      }
    }
212938
function(rectangle) {
        return $.Rect.fromSummits(
            this.pointFromPixel(rectangle.getTopLeft(), true),
            this.pointFromPixel(rectangle.getTopRight(), true),
            this.pointFromPixel(rectangle.getBottomLeft(), true)
        );
    }
35855
function createGridClipShape(rect, seriesModel, cb) {
    var rectEl = new graphic.Rect({
        shape: {
            x: rect.x - 10,
            y: rect.y - 10,
            width: 0,
            height: rect.height + 20
        }
    });
    graphic.initProps(rectEl, {
        shape: {
            width: rect.width + 20,
            height: rect.height + 20
        }
    }, seriesModel, cb);

    return rectEl;
}
378247
public static Rectangle getInteriorRectangle(Component c, Border b, int x, int y, int width, int height) {

        final Insets insets;
        if (b != null) {
            insets = b.getBorderInsets(c);
        } else {
            insets = new Insets(0, 0, 0, 0);
        }

        return new Rectangle(x + insets.left, //
                y + insets.top, //
                width - insets.right - insets.left, //
                height - insets.top - insets.bottom);
    }
1026284
function(element) {
    var comp, rects, coords = null;
    comp = window.getComputedStyle(element, null);
    rects=element.getClientRects();
    if('none' !== comp.pointerEvents && rects.length) {
      mainLoop: for(var i=rects.length-1; i>=0; i--) {
        for(var x=rects[i].left, mX=rects[i].right; x<mX; x++) {
          for(var y=rects[i].top, mY=rects[i].bottom; y<mY; y++) {
            if(element === document.elementFromPoint(x,y)) {
              coords = {x: x, y: y};
              break mainLoop;
            }
          }
        }
      }
    }
    return coords;
  }
722295
@Override
	@Pure
	protected Rectangle2d calcBounds() {
		double x = this.getX();
		double y = this.getY();

		final double w = this.radius * 2;
		final double h = w;

		x -= w / 2.;
		y -= h / 2.;

		return new Rectangle2d(x, y, w, h);
	}
68611
function() {
        var boundingBox = this.getBoundingBox();
        var x = Math.floor(boundingBox.x);
        var y = Math.floor(boundingBox.y);
        var width = Math.ceil(boundingBox.width + boundingBox.x - x);
        var height = Math.ceil(boundingBox.height + boundingBox.y - y);
        return new $.Rect(x, y, width, height);
    }
1073126
@Override
  public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(MethodDescriptor<ReqT, RespT> method,
      CallOptions callOptions) {
    return interceptorChannel.newCall(method, callOptions);
  }
509603
function recalc() {
         this._super(me.Polygon, "recalc");

         this._width = this.points[2].x;
         this._height = this.points[2].y;
         return this;
       }