Retourne les bounds par défaut du desktop en fonction de la résolution de l'écran et du menu.
@return Rectangle
175307
private Rectangle getDefaultBounds() {
		final Dimension size = getToolkit().getScreenSize();
		final Insets insets = getToolkit().getScreenInsets(getGraphicsConfiguration());
		return new Rectangle(insets.left, insets.top, size.width - insets.left - insets.right,
				size.height - insets.top - insets.bottom);
	}
438424
public Bbox getBounds() {
		double w = mapWidth * getResolution();
		double h = mapHeight * getResolution();
		double x = getPosition().getX() - w / 2;
		double y = getPosition().getY() - h / 2;
		return new Bbox(x, y, w, h);
	}
670080
private double getStartAngle() {
        ScaleDirection scaleDirection = gauge.getScaleDirection();
        Pos            knobPosition   = gauge.getKnobPosition();
        switch(knobPosition) {
            case BOTTOM_LEFT : return ScaleDirection.CLOCKWISE == scaleDirection ? 180 : 90;
            case TOP_LEFT    : return ScaleDirection.CLOCKWISE == scaleDirection ?  90 : 0;
            case TOP_RIGHT   : return ScaleDirection.CLOCKWISE == scaleDirection ?   0 : 270;
            case BOTTOM_RIGHT:
            default          : return ScaleDirection.CLOCKWISE == scaleDirection ? 270 : 180;
        }
    }
816690
public Rectangle2D getBoundingBox() {
		Dimension glyphDimension = getMetrics().getGlyphDimension(getNotationContext());
		if (isStemUp()) {
			return new Rectangle2D.Double(
				(int)(getBase().getX()),
                stemYEnd,
				getWidth(),
				getStemBeginPosition().getY()-stemYEnd+glyphDimension.getHeight()/2);
		}
		else {
			return new Rectangle2D.Double(
				(int)(getBase().getX()),
				getStemBeginPosition().getY()-glyphDimension.getHeight()/2,
				getWidth(),
				stemYEnd-getStemBeginPosition().getY()+1+glyphDimension.getHeight()/2);
		}
	}
278367
protected Rectangle getCancelButtonBounds() {
        JTextComponent c = getComponent();
        final int      x = c.getWidth() - c.getHeight() / 2 - 9;
        final int      y = c.getHeight() / 2 - 8;

        return new Rectangle(x, y, 17, 17);
    }
274977
protected Rectangle getRectOnScreen (JComponent comp)
    {
        Rectangle r = comp.getVisibleRect();
        Point p = comp.getLocationOnScreen();
        r.translate(p.x, p.y);
        return r;
    }
1336837
def rectangle(self, rect, attr=None, fill=u' '):
        '''
        x0, y0, x1, y1 = rect
        n = DWORD(0)
        if attr is None:
            attr = self.attr
        for y in range(y0, y1):
            pos = self.fixcoord(x0, y)
            self.FillConsoleOutputAttribute(self.hout, attr, x1 - x0, 
                                            pos, byref(n))
            self.FillConsoleOutputCharacterW(self.hout, ord(fill[0]), x1 - x0,
                                             pos, byref(n))
956350
function () {
                    var rect = this._anchorElement.getBoundingClientRect();

                    return {
                        x: rect.left,
                        y: rect.top,
                        width: rect.width,
                        height: rect.height
                    };
                }
206310
public Rectangle getRect() {
        verifyPropertyPresence(RECT);
        //noinspection unchecked
        return mapToRect((Map<String, Object>) getCommandResult().get(RECT));
    }
1220648
private Rectangle2D getBounds(ServletRequest pReq, BufferedImage pImage,
                                  double pAng) {
        // Get dimensions of original image
        int width = pImage.getWidth(); // loads the image
        int height = pImage.getHeight();

        // Test if we want to crop image (default)
        // if true
        //  - find the largest bounding box INSIDE the rotated image,
        //    that matches the original proportions (nearest 90deg)
        //    (scale up to fit dimensions?)
        // else
        //  - find the smallest bounding box OUTSIDE the rotated image.
        //    - that matches the original proportions (nearest 90deg) ?
        //      (scale down to fit dimensions?)
        AffineTransform at =
                AffineTransform.getRotateInstance(pAng, width / 2.0, height / 2.0);

        Rectangle2D orig = new Rectangle(width, height);
        Shape rotated = at.createTransformedShape(orig);

        if (ServletUtil.getBooleanParameter(pReq, PARAM_CROP, false)) {
            // TODO: Inside box
            return rotated.getBounds2D();
        }
        else {
            return rotated.getBounds2D();
        }
    }
820990
public GeoPosition getSouthEast()
    {
        Rectangle2D r = rects[0];
        if (rects.length > 1)
        {
            r = rects[1];
        }
        return new GeoPosition(r.getY(), r.getMaxX());
    }
487044
public Rectangle2D.Double getRectangle() {
        return new Rectangle2D.Double(west, south, east - west, north - south);
    }
933793
@Pure
	protected Rectangle2d calcBounds() {
		final Rectangle2d bb = new Rectangle2d();
		boolean first = true;
		Rectangle2afp<?, ?, ?, ?, ?, ?> b;

		// Child bounds
		N child;
		for (int i = 0; i < getChildCount(); ++i) {
			child = getChildAt(i);
			if (child != null) {
				b = child.getBounds();
				if (b != null) {
					if (first) {
						first = false;
						bb.setFromCorners(
								b.getMinX(),
								b.getMinY(),
								b.getMaxX(),
								b.getMaxY());
					} else {
						bb.setUnion(b);
					}
				}
			}
		}

		// Data bounds
		P primitive;
		GeoLocation location;
		for (int i = 0; i < getUserDataCount(); ++i) {
			primitive = getUserDataAt(i);
			if (primitive != null) {
				location = primitive.getGeoLocation();
				if (location != null) {
					b = location.toBounds2D();
					if (b != null) {
						if (first) {
							first = false;
							bb.setFromCorners(
									b.getMinX(),
									b.getMinY(),
									b.getMaxX(),
									b.getMaxY());
						} else {
							bb.setUnion(b);
						}
					}
				}
			}
		}

		return first ? null : bb;
	}
381322
public Rectangle toRelative(Rectangle rect) {
		return new Rectangle(rect.getLeft() - origX, rect.getBottom() - origY, rect.getRight() - origX, rect.getTop()
				- origY);
	}
1184184
function getBoundingVisibleRect(el) {
    // Get the element bounding rect in the layout viewport.
    const rect = getBoundingRect(el);

    // Apply the visual viewport transform (i.e. pinch-zoom) to the bounding
    // rect. The viewportX|Y values are in CSS pixels so they don't change
    // with page scale. We first translate so that the viewport offset is
    // at the origin and then we apply the scaling factor.
    const scale = getPageScaleFactor();
    const visualViewportX = chrome.gpuBenchmarking.visualViewportX();
    const visualViewportY = chrome.gpuBenchmarking.visualViewportY();
    rect.top = (rect.top - visualViewportY) * scale;
    rect.left = (rect.left - visualViewportX) * scale;
    rect.width *= scale;
    rect.height *= scale;

    // Get the window dimensions.
    const windowHeight = getWindowHeight();
    const windowWidth = getWindowWidth();

    // Then clip the rect to the screen size.
    rect.top = clamp(0, rect.top, windowHeight);
    rect.left = clamp(0, rect.left, windowWidth);
    rect.height = clamp(0, rect.height, windowHeight - rect.top);
    rect.width = clamp(0, rect.width, windowWidth - rect.left);

    return rect;
  }
256322
public Rectangle getMinRectabgle(){
		return new Rectangle((int)xLB.min, (int)yLB.min, (int)(xUB.min - xLB.min), (int)(yUB.min - yLB.min));
	}
464624
protected Rectangle getCloseButtonBounds(int tabIndex) {
        Rectangle bounds = new Rectangle(rects[tabIndex]);

        bounds.width  = closeButtonSize;
        bounds.height = closeButtonSize;

        bounds.y += (rects[tabIndex].height - closeButtonSize - closeButtonInsets.top - closeButtonInsets.bottom) / 2
            + closeButtonInsets.top;

        boolean onLeft = isCloseButtonOnLeft();

        if (onLeft) {
            int offset = orientation == ControlOrientation.VERTICAL || tabIndex == 0 ? 6 : 3;

            bounds.x += offset;
        } else {
            int offset = orientation == ControlOrientation.VERTICAL || tabIndex == tabPane.getTabCount() - 1 ? 6 : 4;

            bounds.x += rects[tabIndex].width - bounds.width - offset;
        }

        return bounds;
    }