graphene/org.gtkkn.bindings.graphene/Rect

Rect

class Rect(pointer: <Error class: unknown class><<Error class: unknown class>>)

The location and size of a rectangle region.

The width and height of a #graphene_rect_t can be negative; for instance, a #graphene_rect_t with an origin of 0, 0 and a size of 10, 10 is equivalent to a #graphene_rect_t with an origin of 10, 10 and a size of -10, -10 .

Application code can normalize rectangles using graphene_rect_normalize(); this function will ensure that the width and height of a rectangle are positive values. All functions taking a #graphene_rect_t as an argument will internally operate on a normalized copy; all functions returning a #graphene_rect_t will always return a normalized rectangle.

Skipped during bindings generation

parameter vertices: vertices: Out parameter is not supported
field origin: Point
field size: Size

Since

1.0

Constructors

Rect

constructor(pointer: <Error class: unknown class><<Error class: unknown class>>)

Types

Companion

object Companion

Properties

grapheneRectPointer

val grapheneRectPointer: <Error class: unknown class><<Error class: unknown class>>

Functions

containsPoint

fun containsPoint(p: Point): Boolean

Checks whether a #graphene_rect_t contains the given coordinates.

containsRect

fun containsRect(b: Rect): Boolean

Checks whether a #graphene_rect_t fully contains the given rectangle.

equal

fun equal(b: Rect): Boolean

Checks whether the two given rectangle are equal.

expand

fun expand(p: Point, res: Rect)

Expands a #graphene_rect_t to contain the given #graphene_point_t.

free

fun free()

Frees the resources allocated by graphene_rect_alloc().

getArea

fun getArea(): Float

Compute the area of given normalized rectangle.

getBottomLeft

fun getBottomLeft(p: Point)

Retrieves the coordinates of the bottom-left corner of the given rectangle.

getBottomRight

fun getBottomRight(p: Point)

Retrieves the coordinates of the bottom-right corner of the given rectangle.

getCenter

fun getCenter(p: Point)

Retrieves the coordinates of the center of the given rectangle.

getHeight

fun getHeight(): Float

Retrieves the normalized height of the given rectangle.

getTopLeft

fun getTopLeft(p: Point)

Retrieves the coordinates of the top-left corner of the given rectangle.

getTopRight

fun getTopRight(p: Point)

Retrieves the coordinates of the top-right corner of the given rectangle.

getWidth

fun getWidth(): Float

Retrieves the normalized width of the given rectangle.

getX

fun getX(): Float

Retrieves the normalized X coordinate of the origin of the given rectangle.

getY

fun getY(): Float

Retrieves the normalized Y coordinate of the origin of the given rectangle.

init

fun init(x: Float, y: Float, width: Float, height: Float): Rect

Initializes the given #graphene_rect_t with the given values.

initFromRect

fun initFromRect(src: Rect): Rect

Initializes @r using the given @src rectangle.

inset

fun inset(dX: Float, dY: Float): Rect

Changes the given rectangle to be smaller, or larger depending on the given inset parameters.

insetR

fun insetR(dX: Float, dY: Float, res: Rect)

Changes the given rectangle to be smaller, or larger depending on the given inset parameters.

interpolate

fun interpolate(b: Rect, factor: Double, res: Rect)

Linearly interpolates the origin and size of the two given rectangles.

intersection

fun intersection(b: Rect, res: Rect?): Boolean

Computes the intersection of the two given rectangles.

normalize

fun normalize(): Rect

Normalizes the passed rectangle.

normalizeR

fun normalizeR(res: Rect)

Normalizes the passed rectangle.

offset

fun offset(dX: Float, dY: Float): Rect

Offsets the origin by @d_x and @d_y.

offsetR

fun offsetR(dX: Float, dY: Float, res: Rect)

Offsets the origin of the given rectangle by @d_x and @d_y.

round

fun round(res: Rect)

Rounds the origin and size of the given rectangle to their nearest integer values; the rounding is guaranteed to be large enough to have an area bigger or equal to the original rectangle, but might not fully contain its extents. Use graphene_rect_round_extents() in case you need to round to a rectangle that covers fully the original one.

roundExtents

fun roundExtents(res: Rect)

Rounds the origin of the given rectangle to its nearest integer value and and recompute the size so that the rectangle is large enough to contain all the conrners of the original rectangle.

roundToPixel

fun roundToPixel(): Rect

Rounds the origin and the size of the given rectangle to their nearest integer values; the rounding is guaranteed to be large enough to contain the original rectangle.

scale

fun scale(sH: Float, sV: Float, res: Rect)

Scales the size and origin of a rectangle horizontaly by @s_h, and vertically by @s_v. The result @res is normalized.

union

fun union(b: Rect, res: Rect)

Computes the union of the two given rectangles.