NAME

       wxRegion - Functions for wxRegion class

DESCRIPTION

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

       This  class  uses  reference  counting  and  copy-on-write  internally so that assignments
       between two instances of this class are very cheap. You can therefore use  actual  objects
       instead  of  pointers without efficiency problems. If an instance of this class is changed
       it will create its own data internally so that other instances,  which  previously  shared
       the data using the reference counting, are not affected.

       Predefined objects (include wx.hrl):

       See: wxRegionIterator (not implemented in wx)

       wxWidgets docs: wxRegion

DATA TYPES

       wxRegion() = wx:wx_object()

EXPORTS

       new() -> wxRegion()

              Default constructor.

              This  constructor  creates  an  invalid, or null, object, i.e. calling IsOk() on it
              returns false and isEmpty/1 returns true.

       new(Rect) -> wxRegion()

       new(Bmp) -> wxRegion()

              Types:

                 Bmp = wxBitmap:wxBitmap()

              Constructs a region using a bitmap.

              See union/5 for more details.

       new(TopLeft, BottomRight) -> wxRegion()

              Types:

                 TopLeft = BottomRight = {X :: integer(), Y :: integer()}

              Constructs a rectangular region from the top left point and the bottom right point.

       new(X, Y, Width, Height) -> wxRegion()

              Types:

                 X = Y = Width = Height = integer()

              Constructs a rectangular region with the given position and size.

       destroy(This :: wxRegion()) -> ok

              Destructor.

              See reference-counted object destruction for more info.

       clear(This) -> ok

              Types:

                 This = wxRegion()

              Clears the current region.

              The object becomes invalid, or null, after being cleared.

       contains(This, Pt) -> wx:wx_enum()

       contains(This, Rect) -> wx:wx_enum()

              Types:

                 This = wxRegion()
                 Rect =
                     {X :: integer(),
                      Y :: integer(),
                      W :: integer(),
                      H :: integer()}

              Returns a value indicating whether the given  rectangle  is  contained  within  the
              region.

              This method always returns wxOutRegion for an invalid region but may, nevertheless,
              be safely called in this case.

              Return: One of ?wxOutRegion, ?wxPartRegion or ?wxInRegion.

              Note:  On  Windows,  only  ?wxOutRegion  and  ?wxInRegion  are  returned;  a  value
              ?wxInRegion then indicates that all or some part of the region is contained in this
              region.

       contains(This, X, Y) -> wx:wx_enum()

              Types:

                 This = wxRegion()
                 X = Y = integer()

              Returns a value indicating whether the given point is contained within the region.

              This method always returns wxOutRegion for an invalid region but may, nevertheless,
              be safely called in this case.

              Return: The return value is one of wxOutRegion and wxInRegion.

       contains(This, X, Y, Width, Height) -> wx:wx_enum()

              Types:

                 This = wxRegion()
                 X = Y = Width = Height = integer()

              Returns  a  value  indicating  whether  the given rectangle is contained within the
              region.

              This method always returns wxOutRegion for an invalid region but may, nevertheless,
              be safely called in this case.

              Return: One of ?wxOutRegion, ?wxPartRegion or ?wxInRegion.

              Note:  On  Windows,  only  ?wxOutRegion  and  ?wxInRegion  are  returned;  a  value
              ?wxInRegion then indicates that all or some part of the region is contained in this
              region.

       convertToBitmap(This) -> wxBitmap:wxBitmap()

              Types:

                 This = wxRegion()

              Convert  the  region to a black and white bitmap with the white pixels being inside
              the region.

              This method can't be used for invalid region.

       getBox(This) ->
                 {X :: integer(),
                  Y :: integer(),
                  W :: integer(),
                  H :: integer()}

              Types:

                 This = wxRegion()

       intersect(This, Rect) -> boolean()

       intersect(This, Region) -> boolean()

              Types:

                 This = Region = wxRegion()

              Finds the intersection of this region and another region.

              This method always fails, i.e. returns false, if this region  is  invalid  but  may
              nevertheless be safely used even in this case.

              Return: true if successful, false otherwise.

              Remark:  Creates  the intersection of the two regions, that is, the parts which are
              in both regions. The result is stored in this region.

       intersect(This, X, Y, Width, Height) -> boolean()

              Types:

                 This = wxRegion()
                 X = Y = Width = Height = integer()

              Finds the intersection of this region and another,  rectangular  region,  specified
              using position and size.

              This  method  always  fails,  i.e. returns false, if this region is invalid but may
              nevertheless be safely used even in this case.

              Return: true if successful, false otherwise.

              Remark: Creates the intersection of the two regions, that is, the parts  which  are
              in both regions. The result is stored in this region.

       isEmpty(This) -> boolean()

              Types:

                 This = wxRegion()

              Returns true if the region is empty, false otherwise.

              Always returns true if the region is invalid.

       subtract(This, Rect) -> boolean()

       subtract(This, Region) -> boolean()

              Types:

                 This = Region = wxRegion()

              Subtracts a region from this region.

              This  method  always  fails,  i.e. returns false, if this region is invalid but may
              nevertheless be safely used even in this case.

              Return: true if successful, false otherwise.

              Remark: This operation combines the parts of 'this' region that are not part of the
              second region. The result is stored in this region.

       offset(This, Pt) -> boolean()

              Types:

                 This = wxRegion()
                 Pt = {X :: integer(), Y :: integer()}

       offset(This, X, Y) -> boolean()

              Types:

                 This = wxRegion()
                 X = Y = integer()

              Moves the region by the specified offsets in horizontal and vertical directions.

              This  method  can't  be called if the region is invalid as it doesn't make sense to
              offset it then. Attempts to do it will result in assert failure.

              Return: true if successful, false otherwise (the region is unchanged then).

       union(This, Region) -> boolean()

       union(This, Rect) -> boolean()

              Types:

                 This = wxRegion()
                 Rect =
                     {X :: integer(),
                      Y :: integer(),
                      W :: integer(),
                      H :: integer()}

              Finds the union of this region and another, rectangular region.

              This method can be used even  if  this  region  is  invalid  and  has  the  natural
              behaviour in this case, i.e. makes this region equal to the given rectangle.

              Return: true if successful, false otherwise.

              Remark:  This  operation  creates a region that combines all of this region and the
              second region. The result is stored in this region.

       union(This, Bmp, TransColour) -> boolean()

              Types:

                 This = wxRegion()
                 Bmp = wxBitmap:wxBitmap()
                 TransColour = wx:wx_colour()

       union(This, Bmp, TransColour, Options :: [Option]) -> boolean()

              Types:

                 This = wxRegion()
                 Bmp = wxBitmap:wxBitmap()
                 TransColour = wx:wx_colour()
                 Option = {tolerance, integer()}

              Finds the union of this region and the non-transparent pixels of a bitmap.

              Colour to be treated as transparent is specified in the transColour argument, along
              with an optional colour tolerance value.

              Return: true if successful, false otherwise.

              Remark:  This  operation  creates a region that combines all of this region and the
              second region. The result is stored in this region.

       union(This, X, Y, Width, Height) -> boolean()

              Types:

                 This = wxRegion()
                 X = Y = Width = Height = integer()

              Finds the union of this region and another,  rectangular  region,  specified  using
              position and size.

              This  method  can  be  used  even  if  this  region  is invalid and has the natural
              behaviour in this case, i.e. makes this region equal to the given rectangle.

              Return: true if successful, false otherwise.

              Remark: This operation creates a region that combines all of this  region  and  the
              second region. The result is stored in this region.

       'Xor'(This, Rect) -> boolean()

       'Xor'(This, Region) -> boolean()

              Types:

                 This = Region = wxRegion()

              Finds the Xor of this region and another region.

              This  method  can  be  used  even  if  this  region  is invalid and has the natural
              behaviour in this case, i.e. makes this region equal to the given region.

              Return: true if successful, false otherwise.

              Remark: This operation creates a region that combines all of this  region  and  the
              second  region,  except  for  any  overlapping  areas. The result is stored in this
              region.

       'Xor'(This, X, Y, Width, Height) -> boolean()

              Types:

                 This = wxRegion()
                 X = Y = Width = Height = integer()

              Finds the Xor of this region  and  another,  rectangular  region,  specified  using
              position and size.

              This  method  can  be  used  even  if  this  region  is invalid and has the natural
              behaviour in this case, i.e. makes this region equal to the given rectangle.

              Return: true if successful, false otherwise.

              Remark: This operation creates a region that combines all of this  region  and  the
              second  region,  except  for  any  overlapping  areas. The result is stored in this
              region.