Go to main content

man pages section 3: Extended Library Functions, Volume 1

Exit Print View

Updated: Wednesday, July 27, 2022
 
 

wxRegion (3erl)

Name

wxRegion - Functions for wxRegion class

Synopsis

Please see following description for synopsis

Description

wxRegion(3)                Erlang Module Definition                wxRegion(3)



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. call-
              ing 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  con-
              tained 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  con-
              tained 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 ver-
              tical 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  trans-
              Colour 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.



wxWidgets team.                    wx 2.1.1                        wxRegion(3)