wRegion

    Dark Mode

A wxRegion represents a simple or complex region on a device context or window.

Superclass:wGdiObject
Seealso:wDC

Types

wRegionOp = enum
  wRegionAnd = RGN_AND, wRegionOr = RGN_OR, wRegionXor = RGN_XOR, wRegionDiff = RGN_DIFF,
  wRegionCopy = RGN_COPY

Procs

proc init(self: wRegion) {...}{.inline, raises: [], tags: [].}
Initializes am empty region. 
proc Region(): wRegion {...}{.inline, discardable, raises: [], tags: [].}
Constructor. 
proc init(self: wRegion; x, y, width, height: int; elliptic = false) {...}{.raises: [], tags: [].}
Initializes a rectangular or elliptic region. 
proc Region(x, y, width, height: int; elliptic = false): wRegion {...}{.inline, discardable,
    raises: [], tags: [].}
Constructor. 
proc init(self: wRegion; point: wPoint; size: wSize; elliptic = false) {...}{.inline,
    raises: [], tags: [].}
Initializes a rectangular or elliptic region. 
proc Region(point: wPoint; size: wSize; elliptic = false): wRegion {...}{.inline, discardable,
    raises: [], tags: [].}
Constructor. 
proc init(self: wRegion; rect: wRect; elliptic = false) {...}{.inline, raises: [], tags: [].}
Initializes a rectangular or elliptic region. 
proc Region(rect: wRect; elliptic = false): wRegion {...}{.inline, discardable, raises: [],
    tags: [].}
Constructor. 
proc init(self: wRegion; x, y, width, height: int; radius: float) {...}{.raises: [], tags: [].}
Initializes a rectangular region with rounded corners. If radius is positive, the value is assumed to be the radius of the rounded corner. If radius is negative, the absolute value is assumed to be the proportion of the smallest dimension of the rectangle 
proc Region(x, y, width, height: int; radius: float): wRegion {...}{.inline, discardable,
    raises: [], tags: [].}
Constructor. 
proc init(self: wRegion; point: wPoint; size: wSize; radius: float) {...}{.inline, raises: [],
    tags: [].}
Initializes a rectangular region with rounded corners. If radius is positive, the value is assumed to be the radius of the rounded corner. If radius is negative, the absolute value is assumed to be the proportion of the smallest dimension of the rectangle 
proc Region(point: wPoint; size: wSize; radius: float): wRegion {...}{.inline, discardable,
    raises: [], tags: [].}
Constructor. 
proc init(self: wRegion; rect: wRect; radius: float) {...}{.inline, raises: [], tags: [].}
Initializes a rectangular region with rounded corners. If radius is positive, the value is assumed to be the radius of the rounded corner. If radius is negative, the absolute value is assumed to be the proportion of the smallest dimension of the rectangle 
proc Region(rect: wRect; radius: float): wRegion {...}{.inline, discardable, raises: [],
    tags: [].}
Constructor. 
proc init(self: wRegion; image: wImage) {...}{.raises: [wNilAccess, wImageError], tags: [].}
Initializes a region from a wImage object. 
proc Region(image: wImage): wRegion {...}{.inline, discardable,
                                  raises: [wNilAccess, wImageError], tags: [].}
Constructor. 
proc init(self: wRegion; hRgn: HRGN; copy = true; shared = false) {...}{.raises: [], tags: [].}
Initializes a region from system region handle. If copy is false, the function only wrap the handle to wRegion object. If shared is false, the handle will be destroyed together with wRegion object by the GC. Otherwise, the caller is responsible for destroying it. 
proc Region(hRgn: HRGN; copy = true; shared = false): wRegion {...}{.inline, discardable,
    raises: [], tags: [].}
Constructor. 
proc init(self: wRegion; region: wRegion) {...}{.inline, raises: [wNilAccess], tags: [].}
Initializes a region from a wRegion object, aka. copy. 
proc Region(region: wRegion): wRegion {...}{.inline, discardable, raises: [wNilAccess],
                                    tags: [].}
Constructor. 
proc clear(self: wRegion) {...}{.raises: [Exception], tags: [RootEffect].}
Clears the current region. 
proc getBox(self: wRegion): wRect {...}{.raises: [], tags: [].}
Returns the outer bounds of the region. 
proc isEmpty(self: wRegion): bool {...}{.raises: [], tags: [].}
Returns true if the region is empty, false otherwise 
proc isEqual(self: wRegion; region: wRegion): bool {...}{.raises: [wNilAccess], tags: [].}
Returns true if the region is equal to another one. 
proc offset(self: wRegion; x, y: int) {...}{.raises: [], tags: [].}
Moves the region by the specified offsets in horizontal and vertical directions. 
proc combine(self: wRegion; region: wRegion; op: wRegionOp) {...}{.
    raises: [wNilAccess, Exception], tags: [RootEffect].}
Combine another region with this one. op can be wRegionAnd, wRegionOr, wRegionXor, wRegionDiff, or wRegionCopy. 
proc contains(self: wRegion; x: int; y: int): bool {...}{.raises: [], tags: [].}
Returns true if the given point is contained within the region. 
proc contains(self: wRegion; point: wPoint): bool {...}{.inline, raises: [], tags: [].}
Returns true if the given point is contained within the region. 
proc contains(self: wRegion; rect: wRect): bool {...}{.raises: [], tags: [].}
Returns true if the given rect is contained within the region. 
proc contains(self: wRegion; x, y, width, height: int): bool {...}{.inline, raises: [], tags: [].}
Returns true if the given rect is contained within the region. 
proc contains(self: wRegion; point: wPoint; size: wSize): bool {...}{.inline, raises: [],
    tags: [].}
Returns true if the given rect is contained within the region. 
proc `or`(region1, region2: wRegion): wRegion {...}{.raises: [wNilAccess, Exception],
    tags: [RootEffect].}
Or operator for regions. 
proc `and`(region1, region2: wRegion): wRegion {...}{.raises: [wNilAccess, Exception],
    tags: [RootEffect].}
And operator for regions. 
proc `xor`(region1, region2: wRegion): wRegion {...}{.raises: [wNilAccess, Exception],
    tags: [RootEffect].}
Xor operator for regions. 
proc `-`(region1, region2: wRegion): wRegion {...}{.raises: [wNilAccess, Exception],
    tags: [RootEffect].}
Subtract operator for regions. 
proc `|=`(region1, region2: wRegion) {...}{.inline, raises: [wNilAccess, Exception],
                                   tags: [RootEffect].}
Or in place operator for regions. 
proc `&=`(region1, region2: wRegion) {...}{.inline, raises: [wNilAccess, Exception],
                                   tags: [RootEffect].}
And in place operator for regions. 
proc `^=`(region1, region2: wRegion) {...}{.inline, raises: [wNilAccess, Exception],
                                   tags: [RootEffect].}
Xor in place operator for regions. 
proc `-=`(region1, region2: wRegion) {...}{.inline, raises: [wNilAccess, Exception],
                                   tags: [RootEffect].}
Subtract in place operator for regions. 
proc `==`(region1, region2: wRegion): bool {...}{.inline, raises: [wNilAccess], tags: [].}
== operator for regions.

Templates

template wNilRegion(): untyped
Predefined empty regin. Don't delete.

Made with Nim.