graphene/org.gtkkn.bindings.graphene/Rect

Rect

class Rect(val grapheneRectPointer: <Error class: unknown class><<Error class: unknown class>>, cleaner: <Error class: unknown class>? = null)

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: Field with not-pointer record/union graphene_point_t is not supported
field size: Field with not-pointer record/union graphene_size_t is not supported

Since

1.0

Constructors

Rect

constructor()

Allocate a new Rect.

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

Allocate a new Rect using the provided AutofreeScope.

constructor(grapheneRectPointer: <Error class: unknown class><<Error class: unknown class>>, cleaner: <Error class: unknown class>? = null)

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(): <Error class: unknown class>

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(): <Error class: unknown class>

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(): <Error class: unknown class>

Retrieves the normalized width of the given rectangle.

getX

fun getX(): <Error class: unknown class>

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

getY

fun getY(): <Error class: unknown class>

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

init

fun init(x: <Error class: unknown class>, y: <Error class: unknown class>, width: <Error class: unknown class>, height: <Error class: unknown class>): 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: <Error class: unknown class>, dY: <Error class: unknown class>): Rect

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

insetR

fun insetR(dX: <Error class: unknown class>, dY: <Error class: unknown class>, res: Rect)

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

interpolate

fun interpolate(b: Rect, factor: <Error class: unknown class>, 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: <Error class: unknown class>, dY: <Error class: unknown class>): Rect

Offsets the origin by @d_x and @d_y.

offsetR

fun offsetR(dX: <Error class: unknown class>, dY: <Error class: unknown class>, 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: <Error class: unknown class>, sV: <Error class: unknown class>, 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.