Provided by: erlang-manpages_25.3.2.8+dfsg-1ubuntu4_all bug

NAME

       wxWindow - Functions for wxWindow class

DESCRIPTION

       wxWindow  is  the  base class for all windows and represents any visible object on screen.
       All controls, top level windows and so on are windows. Sizers and device contexts are not,
       however, as they don't appear on screen themselves.

       Please  note  that  all  children  of  the  window  will  be  deleted automatically by the
       destructor before the window itself is deleted which means that you don't  have  to  worry
       about   deleting  them  manually.  Please  see  the  window  deletion  overview  for  more
       information.

       Also note that in this, and many others, wxWidgets classes some GetXXX()  methods  may  be
       overloaded  (as,  for  example, getSize/1 or getClientSize/1). In this case, the overloads
       are non-virtual because having multiple virtual functions with the same name results in  a
       virtual  function  name hiding at the derived class level (in English, this means that the
       derived class has to override all overloaded variants if it overrides  any  of  them).  To
       allow  overriding  them  in  the  derived class, wxWidgets uses a unique protected virtual
       DoGetXXX() method and all GetXXX() ones are forwarded to  it,  so  overriding  the  former
       changes the behaviour of the latter.

       Styles

       This class supports the following styles:

       Extra Styles

       This class supports the following extra styles:

       See: Overview events, Overview windowsizing

       This class is derived (and can use functions) from: wxEvtHandler

       wxWidgets docs: wxWindow

EVENTS

       Event   types   emitted  from  this  class:  activate,  child_focus,  context_menu,  help,
       drop_files, erase_background, set_focus, kill_focus, idle, joy_button_down, joy_button_up,
       joy_move,    joy_zmove,    key_down,    key_up,   char,   char_hook,   mouse_capture_lost,
       mouse_capture_changed, left_down, left_up, middle_down, middle_up,  right_down,  right_up,
       motion,  enter_window, leave_window, left_dclick, middle_dclick, right_dclick, mousewheel,
       aux1_down, aux1_up, aux1_dclick, aux2_down, aux2_up,  aux2_dclick,  paint,  scrollwin_top,
       scrollwin_bottom,       scrollwin_lineup,       scrollwin_linedown,      scrollwin_pageup,
       scrollwin_pagedown,  scrollwin_thumbtrack,   scrollwin_thumbrelease,   set_cursor,   size,
       sys_colour_changed

DATA TYPES

       wxWindow() = wx:wx_object()

EXPORTS

       new() -> wxWindow()

              Default constructor.

       new(Parent, Id) -> wxWindow()

              Types:

                 Parent = wxWindow()
                 Id = integer()

       new(Parent, Id, Options :: [Option]) -> wxWindow()

              Types:

                 Parent = wxWindow()
                 Id = integer()
                 Option =
                     {pos, {X :: integer(), Y :: integer()}} |
                     {size, {W :: integer(), H :: integer()}} |
                     {style, integer()}

              Constructs  a  window,  which  can  be a child of a frame, dialog or any other non-
              control window.

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

              Destructor.

              Deletes all sub-windows, then deletes itself. Instead of using the delete  operator
              explicitly,  you  should  normally  use  'Destroy'/1 so that wxWidgets can delete a
              window only when it is safe to do so, in idle time.

              See: Window Deletion Overview, 'Destroy'/1, wxCloseEvent

       create(This, Parent, Id) -> boolean()

              Types:

                 This = Parent = wxWindow()
                 Id = integer()

       create(This, Parent, Id, Options :: [Option]) -> boolean()

              Types:

                 This = Parent = wxWindow()
                 Id = integer()
                 Option =
                     {pos, {X :: integer(), Y :: integer()}} |
                     {size, {W :: integer(), H :: integer()}} |
                     {style, integer()}

              Construct the actual window object after creating the C++ object.

              The non-default constructor of wxWindow class does two things: it  initializes  the
              C++  object  and  it  also  creates  the  window object in the underlying graphical
              toolkit. The create/4 method can be used to perform the second  part  later,  while
              the default constructor can be used to perform the first part only.

              Please  note  that  the underlying window must be created exactly once, i.e. if you
              use the default constructor, which doesn't do this, you must call  create/4  before
              using  the  window  and  if  you  use the non-default constructor, you can not call
              create/4, as the underlying window is already created.

              Note that it is possible and, in fact, useful, to call some methods on  the  object
              between  creating  the  C++ object itself and calling create/4 on it, e.g. a common
              pattern to avoid showing the contents of a window before it  is  fully  initialized
              is:

              Also  note  that it is possible to create an object of a derived type and then call
              create/4 on it: This is notably used by overview_xrc.

              The parameters of this method have exactly the  same  meaning  as  the  non-default
              constructor parameters, please refer to them for their description.

              Return: true if window creation succeeded or false if it failed

       cacheBestSize(This, Size) -> ok

              Types:

                 This = wxWindow()
                 Size = {W :: integer(), H :: integer()}

              Sets the cached best size value.

              See: getBestSize/1

       captureMouse(This) -> ok

              Types:

                 This = wxWindow()

              Directs all mouse input to this window.

              Call releaseMouse/1 to release the capture.

              Note  that  wxWidgets  maintains the stack of windows having captured the mouse and
              when the mouse is released the capture returns to the window which had had captured
              it  previously  and it is only really released if there were no previous window. In
              particular, this means that you must release the mouse as many times as you capture
              it, unless the window receives the wxMouseCaptureLostEvent event.

              Any  application  which  captures the mouse in the beginning of some operation must
              handle wxMouseCaptureLostEvent and cancel  this  operation  when  it  receives  the
              event. The event handler must not recapture mouse.

              See: releaseMouse/1, wxMouseCaptureLostEvent

       center(This) -> ok

              Types:

                 This = wxWindow()

       centre(This) -> ok

              Types:

                 This = wxWindow()

       center(This, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Option = {dir, integer()}

              See: centre/2.

       centre(This, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Option = {dir, integer()}

              Centres the window.

              Remark:  If  the window is a top level one (i.e. doesn't have a parent), it will be
              centred relative to the screen anyhow.

              See: center/2

       centerOnParent(This) -> ok

              Types:

                 This = wxWindow()

       centreOnParent(This) -> ok

              Types:

                 This = wxWindow()

       centerOnParent(This, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Option = {dir, integer()}

              See: centreOnParent/2.

       centreOnParent(This, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Option = {dir, integer()}

              Centres the window on its parent.

              This is a more readable synonym for centre/2.

              Remark: This methods provides for a way to centre  top  level  windows  over  their
              parents instead of the entire screen. If there is no parent or if the window is not
              a top level window, then behaviour is the same as centre/2.

              See: wxTopLevelWindow:centreOnScreen/2

       clearBackground(This) -> ok

              Types:

                 This = wxWindow()

              Clears the window by filling it with the current background colour.

              Does not cause an erase background event to be generated.

              Notice that this uses wxClientDC to draw on the window and the results of doing  it
              while  also  drawing  on wxPaintDC for this window are undefined. Hence this method
              shouldn't be used from EVT_PAINT handlers, just use wxDC:clear/1 on  the  wxPaintDC
              you already use there instead.

       clientToScreen(This, Pt) -> {X :: integer(), Y :: integer()}

              Types:

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

              Converts to screen coordinates from coordinates relative to this window.

       clientToScreen(This, X, Y) -> {X :: integer(), Y :: integer()}

              Types:

                 This = wxWindow()
                 X = Y = integer()

              Converts to screen coordinates from coordinates relative to this window.

       close(This) -> boolean()

              Types:

                 This = wxWindow()

       close(This, Options :: [Option]) -> boolean()

              Types:

                 This = wxWindow()
                 Option = {force, boolean()}

              This  function simply generates a wxCloseEvent whose handler usually tries to close
              the window.

              It doesn't close the window itself, however.

              Return: true if the event was handled and not vetoed, false otherwise.

              Remark: Close calls the close handler for the window, providing an opportunity  for
              the  window  to  choose whether to destroy the window. Usually it is only used with
              the top level windows (wxFrame and wxDialog classes) as the others are not supposed
              to  have  any  special  OnClose() logic. The close handler should check whether the
              window is being deleted forcibly, using wxCloseEvent:canVeto/1, in  which  case  it
              should  destroy  the  window  using  'Destroy'/1.  Note that calling Close does not
              guarantee that the window will be destroyed; but it provides a way  to  simulate  a
              manual  close  of  a  window, which may or may not be implemented by destroying the
              window. The default implementation of wxDialog::OnCloseWindow does not  necessarily
              delete  the  dialog,  since  it  will simply simulate an wxID_CANCEL event which is
              handled by the appropriate button event handler and may  do  anything  at  all.  To
              guarantee that the window will be destroyed, call 'Destroy'/1 instead

              See: Window Deletion Overview, 'Destroy'/1, wxCloseEvent

       convertDialogToPixels(This, Sz) ->
                                {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()
                 Sz = {W :: integer(), H :: integer()}

              This  is  an  overloaded member function, provided for convenience. It differs from
              the above function only in what argument(s) it accepts.

       convertPixelsToDialog(This, Sz) ->
                                {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()
                 Sz = {W :: integer(), H :: integer()}

              This is an overloaded member function, provided for convenience.  It  differs  from
              the above function only in what argument(s) it accepts.

       'Destroy'(This) -> boolean()

              Types:

                 This = wxWindow()

              Destroys the window safely.

              Use  this  function  instead of the delete operator, since different window classes
              can be destroyed differently. Frames and dialogs are not destroyed immediately when
              this function is called - they are added to a list of windows to be deleted on idle
              time, when all the window's events have been processed. This prevents problems with
              events being sent to non-existent windows.

              Return:  true  if  the  window has either been successfully deleted, or it has been
              added to the list of windows pending real deletion.

       destroyChildren(This) -> boolean()

              Types:

                 This = wxWindow()

              Destroys all children of a window.

              Called automatically by the destructor.

       disable(This) -> boolean()

              Types:

                 This = wxWindow()

              Disables the window.

              Same as enable/2 Enable(false).

              Return: Returns true if the window has been disabled, false if it had been  already
              disabled before the call to this function.

       dragAcceptFiles(This, Accept) -> ok

              Types:

                 This = wxWindow()
                 Accept = boolean()

              Enables or disables eligibility for drop file events (OnDropFiles).

              Remark:  Windows only until version 2.8.9, available on all platforms since 2.8.10.
              Cannot be used together with setDropTarget/2 on non-Windows platforms.

              See: setDropTarget/2

       enable(This) -> boolean()

              Types:

                 This = wxWindow()

       enable(This, Options :: [Option]) -> boolean()

              Types:

                 This = wxWindow()
                 Option = {enable, boolean()}

              Enable or disable the window for user input.

              Note that when a parent window is disabled, all of its  children  are  disabled  as
              well and they are re-enabled again when the parent is.

              A  window  can  be  created  initially disabled by calling this method on it before
              calling create/4 to create the actual underlying window, e.g.

              Return: Returns true if the window has been enabled or disabled, false  if  nothing
              was done, i.e. if the window had already been in the specified state.

              See: isEnabled/1, disable/1, wxRadioBox:enable/3

       findFocus() -> wxWindow()

              Finds the window or control which currently has the keyboard focus.

              Remark:  Note that this is a static function, so it can be called without needing a
              wxWindow pointer.

              See: setFocus/1, HasFocus() (not implemented in wx)

       findWindow(This, Id) -> wxWindow()

       findWindow(This, Name) -> wxWindow()

              Types:

                 This = wxWindow()
                 Name = unicode:chardata()

              Find a child of this window, by name.

              May return this if it matches itself.

              Notice that only real children, not top level windows using this window as  parent,
              are searched by this function.

       findWindowById(Id) -> wxWindow()

              Types:

                 Id = integer()

       findWindowById(Id, Options :: [Option]) -> wxWindow()

              Types:

                 Id = integer()
                 Option = {parent, wxWindow()}

              Find the first window with the given id.

              If  parent  is  NULL,  the  search  will start from all top-level frames and dialog
              boxes; if non-NULL, the search will be limited to the given window  hierarchy.  The
              search is recursive in both cases.

              See: findWindow/2

              Return: Window with the given id or NULL if not found.

       findWindowByName(Name) -> wxWindow()

              Types:

                 Name = unicode:chardata()

       findWindowByName(Name, Options :: [Option]) -> wxWindow()

              Types:

                 Name = unicode:chardata()
                 Option = {parent, wxWindow()}

              Find  a  window  by its name (as given in a window constructor or create/4 function
              call).

              If parent is NULL, the search will start  from  all  top-level  frames  and  dialog
              boxes; if non-NULL, the search will be limited to the given window hierarchy.

              The  search  is recursive in both cases and, unlike findWindow/2, recurses into top
              level child windows too.

              If no window with such name is found, findWindowByLabel/2 is called, i.e. the  name
              is  interpreted as (internal) name first but if this fails, it's internal as (user-
              visible) label. As this behaviour may be confusing, it is  usually  better  to  use
              either the findWindow/2 overload taking the name or findWindowByLabel/2 directly.

              Return: Window with the given name or NULL if not found.

       findWindowByLabel(Label) -> wxWindow()

              Types:

                 Label = unicode:chardata()

       findWindowByLabel(Label, Options :: [Option]) -> wxWindow()

              Types:

                 Label = unicode:chardata()
                 Option = {parent, wxWindow()}

              Find a window by its label.

              Depending  on  the  type  of  window, the label may be a window title or panel item
              label. If parent is NULL, the search will  start  from  all  top-level  frames  and
              dialog  boxes;  if  non-NULL,  the  search  will  be  limited  to  the given window
              hierarchy.

              The search is recursive in both cases and, unlike with findWindow/2, recurses  into
              top level child windows too.

              See: findWindow/2

              Return: Window with the given label or NULL if not found.

       fit(This) -> ok

              Types:

                 This = wxWindow()

              Sizes the window to fit its best size.

              Using  this  function  is  equivalent to setting window size to the return value of
              getBestSize/1.

              Note that, unlike setSizerAndFit/3, this function only changes the  current  window
              size and doesn't change its minimal size.

              See: Overview windowsizing

       fitInside(This) -> ok

              Types:

                 This = wxWindow()

              Similar to fit/1, but sizes the interior (virtual) size of a window.

              Mainly  useful  with scrolled windows to reset scrollbars after sizing changes that
              do not trigger a size event, and/or scrolled windows  without  an  interior  sizer.
              This function similarly won't do anything if there are no subwindows.

       freeze(This) -> ok

              Types:

                 This = wxWindow()

              Freezes  the  window  or, in other words, prevents any updates from taking place on
              screen, the window is not redrawn at all.

              thaw/1 must be called to re-enable window redrawing. Calls to these  two  functions
              may  be  nested but to ensure that the window is properly repainted again, you must
              thaw it exactly as many times as you froze it.

              If the window has any children, they are recursively frozen too.

              This method is useful for visual appearance optimization (for example, it is a good
              idea  to  use it before doing many large text insertions in a row into a wxTextCtrl
              under wxGTK) but is not implemented on all platforms nor for all controls so it  is
              mostly just a hint to wxWidgets and not a mandatory directive.

              See: wxWindowUpdateLocker (not implemented in wx), thaw/1, isFrozen/1

       getAcceleratorTable(This) ->
                              wxAcceleratorTable:wxAcceleratorTable()

              Types:

                 This = wxWindow()

              Gets the accelerator table for this window.

              See wxAcceleratorTable.

       getBackgroundColour(This) -> wx:wx_colour4()

              Types:

                 This = wxWindow()

              Returns the background colour of the window.

              See: setBackgroundColour/2, setForegroundColour/2, getForegroundColour/1

       getBackgroundStyle(This) -> wx:wx_enum()

              Types:

                 This = wxWindow()

              Returns the background style of the window.

              See:     setBackgroundColour/2,     getForegroundColour/1,    setBackgroundStyle/2,
              setTransparent/2

       getBestSize(This) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()

              This functions returns the best acceptable minimal size for the window.

              For example, for a static control, it will  be  the  minimal  size  such  that  the
              control  label  is  not  truncated.  For  windows  containing subwindows (typically
              wxPanel), the size returned by this function will be  the  same  as  the  size  the
              window would have had after calling fit/1.

              Override  virtual  DoGetBestSize() (not implemented in wx) or, better, because it's
              usually more convenient, DoGetBestClientSize() (not implemented in wx) when writing
              your  own  custom  window  class  to  change the value returned by this public non-
              virtual method.

              Notice that the best size respects the minimal and maximal size explicitly set  for
              the  window,  if  any.  So  even  if  some window believes that it needs 200 pixels
              horizontally,  calling  setMaxSize/2  with  a  width  of  100  would  ensure   that
              getBestSize/1 returns the width of at most 100 pixels.

              See: cacheBestSize/2, Overview windowsizing

       getCaret(This) -> wxCaret:wxCaret()

              Types:

                 This = wxWindow()

              Returns the caret() associated with the window.

       getCapture() -> wxWindow()

              Returns the currently captured window.

              See:   hasCapture/1,   captureMouse/1,   releaseMouse/1,   wxMouseCaptureLostEvent,
              wxMouseCaptureChangedEvent

       getCharHeight(This) -> integer()

              Types:

                 This = wxWindow()

              Returns the character height for this window.

       getCharWidth(This) -> integer()

              Types:

                 This = wxWindow()

              Returns the average character width for this window.

       getChildren(This) -> [wxWindow()]

              Types:

                 This = wxWindow()

              Returns a const reference to the list of the window's children.

              wxWindowList is a type-safe wxList-like class whose elements are of type wxWindow*.

       getClientSize(This) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()

              This is an overloaded member function, provided for convenience.  It  differs  from
              the above function only in what argument(s) it accepts.

       getContainingSizer(This) -> wxSizer:wxSizer()

              Types:

                 This = wxWindow()

              Returns the sizer of which this window is a member, if any, otherwise NULL.

       getCursor(This) -> wxCursor:wxCursor()

              Types:

                 This = wxWindow()

              Return the cursor associated with this window.

              See: setCursor/2

       getDropTarget(This) -> wx:wx_object()

              Types:

                 This = wxWindow()

              Returns the associated drop target, which may be NULL.

              See: setDropTarget/2, Overview dnd

       getDPIScaleFactor(This) -> number()

              Types:

                 This = wxWindow()

              Returns the ratio of the DPI used by this window to the standard DPI.

              The  returned  value  is  1  for  standard DPI screens or 2 for "200% scaling" and,
              unlike for getContentScaleFactor/1, is the same under all platforms.

              This factor should be used to increase the size of icons and similar windows  whose
              best size is not based on text metrics when using DPI scaling.

              E.g.  the program may load a 32px bitmap if the content scale factor is 1.0 or 64px
              version of the same bitmap if it is 2.0 or bigger.

              Notice that this method should not be used for window sizes expressed in pixels, as
              they  are  already  scaled  by  this  factor  by  the underlying toolkit under some
              platforms. Use fromDIP/2 for anything window-related instead.

              Since: 3.1.4

       getExtraStyle(This) -> integer()

              Types:

                 This = wxWindow()

              Returns the extra style bits for the window.

       getFont(This) -> wxFont:wxFont()

              Types:

                 This = wxWindow()

              Returns the font for this window.

              See: setFont/2

       getForegroundColour(This) -> wx:wx_colour4()

              Types:

                 This = wxWindow()

              Returns the foreground colour of the window.

              Remark: The meaning of foreground colour varies according to the window  class;  it
              may be the text colour or other colour, or it may not be used at all.

              See: setForegroundColour/2, setBackgroundColour/2, getBackgroundColour/1

       getGrandParent(This) -> wxWindow()

              Types:

                 This = wxWindow()

              Returns the grandparent of a window, or NULL if there isn't one.

       getHandle(This) -> integer()

              Types:

                 This = wxWindow()

              Returns the platform-specific handle of the physical window.

              Cast  it  to  an  appropriate handle, such as HWND for Windows, Widget for Motif or
              GtkWidget for GTK.

       getHelpText(This) -> unicode:charlist()

              Types:

                 This = wxWindow()

              Gets the help text to be used as context-sensitive help for this window.

              Note  that  the  text  is  actually  stored  by  the  current  wxHelpProvider  (not
              implemented in wx) implementation, and not in the window object itself.

              See:  setHelpText/2,  GetHelpTextAtPoint()  (not implemented in wx), wxHelpProvider
              (not implemented in wx)

       getId(This) -> integer()

              Types:

                 This = wxWindow()

              Returns the identifier of the window.

              Remark: Each window has an integer identifier. If the application has not  provided
              one  (or  the  default  wxID_ANY) a unique identifier with a negative value will be
              generated.

              See: setId/2, Overview windowids

       getLabel(This) -> unicode:charlist()

              Types:

                 This = wxWindow()

              Generic way of getting a label from any window, for identification purposes.

              Remark: The interpretation of this function differs from class to class. For frames
              and  dialogs, the value returned is the title. For buttons or static text controls,
              it is the button text. This function can  be  useful  for  meta-programs  (such  as
              testing  tools  or special-needs access programs) which need to identify windows by
              name.

       getMaxSize(This) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()

              Returns the maximum size of the window.

              This is an indication to the sizer  layout  mechanism  that  this  is  the  maximum
              possible size as well as the upper bound on window's size settable using setSize/6.

              See: GetMaxClientSize() (not implemented in wx), Overview windowsizing

       getMinSize(This) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()

              Returns the minimum size of the window, an indication to the sizer layout mechanism
              that this is the minimum required size.

              This method normally just returns the value set by  setMinSize/2,  but  it  can  be
              overridden to do the calculation on demand.

              See: GetMinClientSize() (not implemented in wx), Overview windowsizing

       getName(This) -> unicode:charlist()

              Types:

                 This = wxWindow()

              Returns the window's name.

              Remark:  This  name  is  not guaranteed to be unique; it is up to the programmer to
              supply an appropriate name in the window constructor or via setName/2.

              See: setName/2

       getParent(This) -> wxWindow()

              Types:

                 This = wxWindow()

              Returns the parent of the window, or NULL if there is no parent.

       getPosition(This) -> {X :: integer(), Y :: integer()}

              Types:

                 This = wxWindow()

              This gets the position of the window in pixels, relative to the parent  window  for
              the child windows or relative to the display origin for the top level windows.

              See: getScreenPosition/1

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

              Types:

                 This = wxWindow()

              Returns the position and size of the window as a {X,Y,W,H} object.

              See: getScreenRect/1

       getScreenPosition(This) -> {X :: integer(), Y :: integer()}

              Types:

                 This = wxWindow()

              Returns  the  window  position in screen coordinates, whether the window is a child
              window or a top level one.

              See: getPosition/1

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

              Types:

                 This = wxWindow()

              Returns the position and size of the window on the screen as a {X,Y,W,H} object.

              See: getRect/1

       getScrollPos(This, Orientation) -> integer()

              Types:

                 This = wxWindow()
                 Orientation = integer()

              Returns the built-in scrollbar position.

              See: setScrollbar/6

       getScrollRange(This, Orientation) -> integer()

              Types:

                 This = wxWindow()
                 Orientation = integer()

              Returns the built-in scrollbar range.

              See: setScrollbar/6

       getScrollThumb(This, Orientation) -> integer()

              Types:

                 This = wxWindow()
                 Orientation = integer()

              Returns the built-in scrollbar thumb size.

              See: setScrollbar/6

       getSize(This) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()

              See the GetSize(int*,int*) overload for more info.

       getSizer(This) -> wxSizer:wxSizer()

              Types:

                 This = wxWindow()

              Returns the sizer associated with the window by a previous call to  setSizer/3,  or
              NULL.

       getTextExtent(This, String) -> Result

              Types:

                 Result =
                     {W :: integer(),
                      H :: integer(),
                      Descent :: integer(),
                      ExternalLeading :: integer()}
                 This = wxWindow()
                 String = unicode:chardata()

       getTextExtent(This, String, Options :: [Option]) -> Result

              Types:

                 Result =
                     {W :: integer(),
                      H :: integer(),
                      Descent :: integer(),
                      ExternalLeading :: integer()}
                 This = wxWindow()
                 String = unicode:chardata()
                 Option = {theFont, wxFont:wxFont()}

              Gets  the  dimensions  of  the  string  as it would be drawn on the window with the
              currently selected font.

              The text extent is returned in the w and h pointers.

       getThemeEnabled(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns true if the window uses the system theme for drawing its background.

              See: setThemeEnabled/2

       getToolTip(This) -> wxToolTip:wxToolTip()

              Types:

                 This = wxWindow()

              Get the associated tooltip or NULL if none.

       getUpdateRegion(This) -> wxRegion:wxRegion()

              Types:

                 This = wxWindow()

              Gets the dimensions of the string as it would be  drawn  on  the  window  with  the
              currently selected font.

              Returns  the  region specifying which parts of the window have been damaged. Should
              only be called within an wxPaintEvent handler.

              See: wxRegion, wxRegionIterator (not implemented in wx)

       getVirtualSize(This) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()

              This gets the virtual size of the window in pixels.

              By default it returns  the  client  size  of  the  window,  but  after  a  call  to
              setVirtualSize/3 it will return the size set with that method.

              See: Overview windowsizing

       getWindowStyleFlag(This) -> integer()

              Types:

                 This = wxWindow()

              Gets the window style that was passed to the constructor or create/4 method.

              GetWindowStyle() (not implemented in wx) is another name for the same function.

       getWindowVariant(This) -> wx:wx_enum()

              Types:

                 This = wxWindow()

              Returns the value previously passed to setWindowVariant/2.

       hasCapture(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns true if this window has the current mouse capture.

              See:         captureMouse/1,        releaseMouse/1,        wxMouseCaptureLostEvent,
              wxMouseCaptureChangedEvent

       hasScrollbar(This, Orient) -> boolean()

              Types:

                 This = wxWindow()
                 Orient = integer()

              Returns true if this window currently has a scroll bar for this orientation.

              This method may return false even when CanScroll() (not implemented in wx) for  the
              same  orientation  returns true, but if CanScroll() (not implemented in wx) returns
              false, i.e. scrolling in this direction  is  not  enabled  at  all,  hasScrollbar/2
              always returns false as well.

       hasTransparentBackground(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns  true  if  this  window  background  is  transparent  (as, for example, for
              wxStaticText) and should show the parent window background.

              This method is mostly used internally  by  the  library  itself  and  you  normally
              shouldn't  have to call it. You may, however, have to override it in your wxWindow-
              derived class to ensure that background is painted correctly.

       hide(This) -> boolean()

              Types:

                 This = wxWindow()

              Equivalent to calling show/2(false).

       inheritAttributes(This) -> ok

              Types:

                 This = wxWindow()

              This function is (or should be, in case of custom controls)  called  during  window
              creation to intelligently set up the window visual attributes, that is the font and
              the foreground and background colours.

              By "intelligently" the following is meant: by default, all windows  use  their  own
              GetClassDefaultAttributes()  (not implemented in wx) default attributes. However if
              some of the parents attributes are explicitly (that is,  using  setFont/2  and  not
              setOwnFont/2) changed and if the corresponding attribute hadn't been explicitly set
              for this window itself, then this window takes  the  same  value  as  used  by  the
              parent.  In  addition,  if  the  window  overrides shouldInheritColours/1 to return
              false, the colours will not be changed no matter what and only the font might.

              This rather complicated logic is necessary in order to  accommodate  the  different
              usage scenarios. The most common one is when all default attributes are used and in
              this case, nothing should be inherited as in modern  GUIs  different  controls  use
              different  fonts  (and  colours) than their siblings so they can't inherit the same
              value from the parent. However it was also deemed  desirable  to  allow  to  simply
              change  the  attributes of all children at once by just changing the font or colour
              of their common parent, hence in this case we do inherit the parents attributes.

       initDialog(This) -> ok

              Types:

                 This = wxWindow()

              Sends an wxEVT_INIT_DIALOG event, whose  handler  usually  transfers  data  to  the
              dialog via validators.

       invalidateBestSize(This) -> ok

              Types:

                 This = wxWindow()

              Resets  the  cached  best size value so it will be recalculated the next time it is
              needed.

              See: cacheBestSize/2

       isFrozen(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns true if the window is currently frozen by a call to freeze/1.

              See: freeze/1, thaw/1

       isEnabled(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns true if the window is  enabled,  i.e.  if  it  accepts  user  input,  false
              otherwise.

              Notice  that  this  method  can return false even if this window itself hadn't been
              explicitly disabled when one  of  its  parent  windows  is  disabled.  To  get  the
              intrinsic status of this window, use IsThisEnabled() (not implemented in wx)

              See: enable/2

       isExposed(This, Pt) -> boolean()

       isExposed(This, Rect) -> boolean()

              Types:

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

              This  is  an  overloaded member function, provided for convenience. It differs from
              the above function only in what argument(s) it accepts.

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

              Types:

                 This = wxWindow()
                 X = Y = integer()

              Returns true if the given point or rectangle area has been exposed since  the  last
              repaint.

              Call  this  in an paint event handler to optimize redrawing by only redrawing those
              areas, which have been exposed.

       isExposed(This, X, Y, W, H) -> boolean()

              Types:

                 This = wxWindow()
                 X = Y = W = H = integer()

              This is an overloaded member function, provided for convenience.  It  differs  from
              the above function only in what argument(s) it accepts.

       isRetained(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns true if the window is retained, false otherwise.

              Remark: Retained windows are only available on X platforms.

       isShown(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns true if the window is shown, false if it has been hidden.

              See: isShownOnScreen/1

       isTopLevel(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns true if the given window is a top-level one.

              Currently  all  frames  and dialogs are considered to be top-level windows (even if
              they have a parent window).

       isShownOnScreen(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns true if the window is physically visible on the screen, i.e.  it  is  shown
              and all its parents up to the toplevel window are shown as well.

              See: isShown/1

       layout(This) -> boolean()

              Types:

                 This = wxWindow()

              Lays out the children of this window using the associated sizer.

              If  a sizer hadn't been associated with this window (see setSizer/3), this function
              doesn't do anything, unless this is a top level window (see layout/1).

              Note that this method is called automatically when the window size  changes  if  it
              has  the  associated  sizer  (or  if  setAutoLayout/2  with  true argument had been
              explicitly called), ensuring that it is always laid out correctly.

              See: Overview windowsizing

              Return: Always returns true, the return value is not useful.

       lineDown(This) -> boolean()

              Types:

                 This = wxWindow()

              Same as scrollLines/2 (1).

       lineUp(This) -> boolean()

              Types:

                 This = wxWindow()

              Same as scrollLines/2 (-1).

       lower(This) -> ok

              Types:

                 This = wxWindow()

              Lowers the window to the bottom of the window hierarchy (Z-order).

              Remark: This function only works for wxTopLevelWindow-derived classes.

              See: raise/1

       move(This, Pt) -> ok

              Types:

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

       move(This, X, Y) -> ok

       move(This, Pt, Y :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Pt = {X :: integer(), Y :: integer()}
                 Option = {flags, integer()}

              Moves the window to the given position.

              Remark: Implementations of setSize/6  can  also  implicitly  implement  the  move/4
              function, which is defined in the base wxWindow class as the call:

              See: setSize/6

       move(This, X, Y, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 X = Y = integer()
                 Option = {flags, integer()}

              Moves the window to the given position.

              Remark:  Implementations  of  SetSize  can  also  implicitly  implement  the move/4
              function, which is defined in the base wxWindow class as the call:

              See: setSize/6

       moveAfterInTabOrder(This, Win) -> ok

              Types:

                 This = Win = wxWindow()

              Moves this window in the tab navigation order after the specified win.

              This means that when the user presses TAB key  on  that  other  window,  the  focus
              switches to this window.

              Default   tab   order   is   the   same   as  creation  order,  this  function  and
              moveBeforeInTabOrder/2 allow to change it after creating all the windows.

       moveBeforeInTabOrder(This, Win) -> ok

              Types:

                 This = Win = wxWindow()

              Same as moveAfterInTabOrder/2 except that it inserts this window  just  before  win
              instead of putting it right after it.

       navigate(This) -> boolean()

              Types:

                 This = wxWindow()

       navigate(This, Options :: [Option]) -> boolean()

              Types:

                 This = wxWindow()
                 Option = {flags, integer()}

              Performs a keyboard navigation action starting from this window.

              This method is equivalent to calling NavigateIn() (not implemented in wx) method on
              the parent window.

              Return: Returns true if the focus was moved to another window or false  if  nothing
              changed.

              Remark: You may wish to call this from a text control custom keypress handler to do
              the default navigation behaviour for  the  tab  key,  since  the  standard  default
              behaviour for a multiline text control with the wxTE_PROCESS_TAB style is to insert
              a tab and not navigate to the  next  control.  See  also  wxNavigationKeyEvent  and
              HandleAsNavigationKey.

       pageDown(This) -> boolean()

              Types:

                 This = wxWindow()

              Same as scrollPages/2 (1).

       pageUp(This) -> boolean()

              Types:

                 This = wxWindow()

              Same as scrollPages/2 (-1).

       popupMenu(This, Menu) -> boolean()

              Types:

                 This = wxWindow()
                 Menu = wxMenu:wxMenu()

       popupMenu(This, Menu, Options :: [Option]) -> boolean()

              Types:

                 This = wxWindow()
                 Menu = wxMenu:wxMenu()
                 Option = {pos, {X :: integer(), Y :: integer()}}

              Pops  up  the given menu at the specified coordinates, relative to this window, and
              returns control when the user has dismissed the menu.

              If a menu item is selected, the corresponding menu event is generated and  will  be
              processed  as  usual.  If  coordinates  are not specified, the current mouse cursor
              position is used.

              menu is the menu to pop up.

              The position where the menu will appear can be specified either as a {X,Y}  pos  or
              by two integers (x and y).

              Note that this function switches focus to this window before showing the menu.

              Remark: Just before the menu is popped up, wxMenu::UpdateUI (not implemented in wx)
              is called to ensure that the menu items are in the correct state. The menu does not
              get  deleted by the window. It is recommended to not explicitly specify coordinates
              when calling PopupMenu in response to  mouse  click,  because  some  of  the  ports
              (namely, wxGTK) can do a better job of positioning the menu in that case.

              See: wxMenu

       popupMenu(This, Menu, X, Y) -> boolean()

              Types:

                 This = wxWindow()
                 Menu = wxMenu:wxMenu()
                 X = Y = integer()

              This  is  an  overloaded member function, provided for convenience. It differs from
              the above function only in what argument(s) it accepts.

       raise(This) -> ok

              Types:

                 This = wxWindow()

              Raises the window to the top of the window hierarchy (Z-order).

              Notice that this function only requests the window manager to raise this window  to
              the  top  of  Z-order. Depending on its configuration, the window manager may raise
              the window, not do it at all or indicate that a window requested to  be  raised  in
              some other way, e.g. by flashing its icon if it is minimized.

              Remark: This function only works for wxTopLevelWindow-derived classes.

              See: lower/1

       refresh(This) -> ok

              Types:

                 This = wxWindow()

       refresh(This, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Option =
                     {eraseBackground, boolean()} |
                     {rect,
                      {X :: integer(),
                       Y :: integer(),
                       W :: integer(),
                       H :: integer()}}

              Causes  this window, and all of its children recursively (except under wxGTK1 where
              this is not implemented), to be repainted.

              Note that repainting doesn't happen immediately but only during the next event loop
              iteration,  if  you  need  to update the window immediately you should use update/1
              instead.

              See: refreshRect/3

       refreshRect(This, Rect) -> ok

              Types:

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

       refreshRect(This, Rect, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Rect =
                     {X :: integer(),
                      Y :: integer(),
                      W :: integer(),
                      H :: integer()}
                 Option = {eraseBackground, boolean()}

              Redraws the contents of the given rectangle:  only  the  area  inside  it  will  be
              repainted.

              This  is  the  same  as refresh/2 but has a nicer syntax as it can be called with a
              temporary {X,Y,W,H} object as argument like this RefreshRect(wxRect(x, y, w, h)).

       releaseMouse(This) -> ok

              Types:

                 This = wxWindow()

              Releases mouse input captured with captureMouse/1.

              See:   captureMouse/1,   hasCapture/1,   releaseMouse/1,   wxMouseCaptureLostEvent,
              wxMouseCaptureChangedEvent

       removeChild(This, Child) -> ok

              Types:

                 This = Child = wxWindow()

              Removes a child window.

              This is called automatically by window deletion functions so should not be required
              by the application programmer. Notice that this  function  is  mostly  internal  to
              wxWidgets and shouldn't be called by the user code.

       reparent(This, NewParent) -> boolean()

              Types:

                 This = NewParent = wxWindow()

              Reparents  the  window,  i.e.  the  window  will be removed from its current parent
              window (e.g.

              a non-standard toolbar in a wxFrame) and then re-inserted into another.

              Notice that currently  you  need  to  explicitly  call  wxBookCtrlBase:removePage/2
              before reparenting a notebook page.

       screenToClient(This) -> {X :: integer(), Y :: integer()}

              Types:

                 This = wxWindow()

              Converts from screen to client window coordinates.

       screenToClient(This, Pt) -> {X :: integer(), Y :: integer()}

              Types:

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

              Converts from screen to client window coordinates.

       scrollLines(This, Lines) -> boolean()

              Types:

                 This = wxWindow()
                 Lines = integer()

              Scrolls the window by the given number of lines down (if lines is positive) or up.

              Return:  Returns  true  if  the  window  was  scrolled,  false if it was already on
              top/bottom and nothing was done.

              Remark: This function is currently only implemented under MSW and wxTextCtrl  under
              wxGTK  (it  also  works  for  wxScrolled  (not implemented in wx) classes under all
              platforms).

              See: scrollPages/2

       scrollPages(This, Pages) -> boolean()

              Types:

                 This = wxWindow()
                 Pages = integer()

              Scrolls the window by the given number of pages down (if pages is positive) or up.

              Return: Returns true if the window  was  scrolled,  false  if  it  was  already  on
              top/bottom and nothing was done.

              Remark: This function is currently only implemented under MSW and wxGTK.

              See: scrollLines/2

       scrollWindow(This, Dx, Dy) -> ok

              Types:

                 This = wxWindow()
                 Dx = Dy = integer()

       scrollWindow(This, Dx, Dy, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Dx = Dy = integer()
                 Option =
                     {rect,
                      {X :: integer(),
                       Y :: integer(),
                       W :: integer(),
                       H :: integer()}}

              Physically scrolls the pixels in the window and move child windows accordingly.

              Remark:  Note  that you can often use wxScrolled (not implemented in wx) instead of
              using this function directly.

       setAcceleratorTable(This, Accel) -> ok

              Types:

                 This = wxWindow()
                 Accel = wxAcceleratorTable:wxAcceleratorTable()

              Sets the accelerator table for this window.

              See wxAcceleratorTable.

       setAutoLayout(This, AutoLayout) -> ok

              Types:

                 This = wxWindow()
                 AutoLayout = boolean()

              Determines whether the layout/1 function will  be  called  automatically  when  the
              window is resized.

              This method is called implicitly by setSizer/3 but if you use SetConstraints() (not
              implemented in wx) you should call it manually or otherwise the window layout won't
              be correctly updated when its size changes.

              See: setSizer/3, SetConstraints() (not implemented in wx)

       setBackgroundColour(This, Colour) -> boolean()

              Types:

                 This = wxWindow()
                 Colour = wx:wx_colour()

              Sets the background colour of the window.

              Notice  that  as  with  setForegroundColour/2,  setting  the background colour of a
              native control may not affect the entire control and could be not supported at  all
              depending on the control and platform.

              Please  see  inheritAttributes/1  for  explanation  of  the difference between this
              method and setOwnBackgroundColour/2.

              Remark: The background colour is usually painted by the default wxEraseEvent  event
              handler  function  under Windows and automatically under GTK. Note that setting the
              background colour does not cause an immediate refresh, so  you  may  wish  to  call
              clearBackground/1  or  refresh/2  after  calling this function. Using this function
              will disable attempts to use themes for this window, if the system  supports  them.
              Use  with care since usually the themes represent the appearance chosen by the user
              to be used for all applications on the system.

              Return: true if the colour was really changed, false if it was already set to  this
              colour and nothing was done.

              See:     getBackgroundColour/1,    setForegroundColour/2,    getForegroundColour/1,
              clearBackground/1, refresh/2, wxEraseEvent, wxSystemSettings

       setBackgroundStyle(This, Style) -> boolean()

              Types:

                 This = wxWindow()
                 Style = wx:wx_enum()

              Sets the background style of the window.

              The default background style is wxBG_STYLE_ERASE which indicates  that  the  window
              background  may  be  erased  in  EVT_ERASE_BACKGROUND  handler.  This  is  a  safe,
              compatibility default; however you may want to change it  to  wxBG_STYLE_SYSTEM  if
              you  don't  define any erase background event handlers at all, to avoid unnecessary
              generation of erase background events and always let system erase  the  background.
              And  you  should  change  the background style to wxBG_STYLE_PAINT if you define an
              EVT_PAINT handler which completely overwrites the window background as in this case
              erasing  it  previously,  either  in  EVT_ERASE_BACKGROUND handler or in the system
              default handler, would result in flicker as the background pixels will be repainted
              twice  every  time the window is redrawn. Do ensure that the background is entirely
              erased by your EVT_PAINT handler in this case however as otherwise garbage  may  be
              left on screen.

              Notice that in previous versions of wxWidgets a common way to work around the above
              mentioned flickering problem was to define an empty  EVT_ERASE_BACKGROUND  handler.
              Setting  background  style  to  wxBG_STYLE_PAINT  is  a  simpler and more efficient
              solution to the same problem.

              Under  wxGTK  and  wxOSX,  you  can  use  ?wxBG_STYLE_TRANSPARENT  to  obtain  full
              transparency of the window background. Note that wxGTK supports this only since GTK
              2.12 with a compositing manager  enabled,  call  IsTransparentBackgroundSupported()
              (not implemented in wx) to check whether this is the case.

              Also,  in  order for SetBackgroundStyle(wxBG_STYLE_TRANSPARENT) to work, it must be
              called before create/4. If you're using your own wxWindow-derived class you  should
              write your code in the following way:

              See:      setBackgroundColour/2,      getForegroundColour/1,      setTransparent/2,
              IsTransparentBackgroundSupported() (not implemented in wx)

       setCaret(This, Caret) -> ok

              Types:

                 This = wxWindow()
                 Caret = wxCaret:wxCaret()

              Sets the caret() associated with the window.

       setClientSize(This, Size) -> ok

       setClientSize(This, Rect) -> ok

              Types:

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

              This is an overloaded member function, provided for convenience.  It  differs  from
              the above function only in what argument(s) it accepts.

       setClientSize(This, Width, Height) -> ok

              Types:

                 This = wxWindow()
                 Width = Height = integer()

              This sets the size of the window client area in pixels.

              Using  this  function  to  size  a  window tends to be more device-independent than
              setSize/6, since the application need not worry about what dimensions the border or
              title bar have when trying to fit the window around panel items, for example.

              See: Overview windowsizing

       setContainingSizer(This, Sizer) -> ok

              Types:

                 This = wxWindow()
                 Sizer = wxSizer:wxSizer()

              Used  by  wxSizer  internally to notify the window about being managed by the given
              sizer.

              This  method  should  not  be  called  from  outside  the  library,  unless  you're
              implementing  a  custom  sizer  class  -  and in the latter case you must call this
              method with the pointer to the sizer itself whenever a window is added  to  it  and
              with NULL argument when the window is removed from it.

       setCursor(This, Cursor) -> boolean()

              Types:

                 This = wxWindow()
                 Cursor = wxCursor:wxCursor()

              Sets the window's cursor.

              Notice  that  the  window  cursor  also  sets  it  for  the  children of the window
              implicitly.

              The cursor may be wxNullCursor in which case the window cursor will be  reset  back
              to default.

              See: wx_misc:setCursor/1, wxCursor

       setMaxSize(This, Size) -> ok

              Types:

                 This = wxWindow()
                 Size = {W :: integer(), H :: integer()}

              Sets the maximum size of the window, to indicate to the sizer layout mechanism that
              this is the maximum possible size.

              See: SetMaxClientSize() (not implemented in wx), Overview windowsizing

       setMinSize(This, Size) -> ok

              Types:

                 This = wxWindow()
                 Size = {W :: integer(), H :: integer()}

              Sets the minimum size of the window, to indicate to the sizer layout mechanism that
              this is the minimum required size.

              You  may  need  to  call  this if you change the window size after construction and
              before adding to its parent sizer.

              Notice that calling this method doesn't prevent the program from making the  window
              explicitly  smaller  than  the specified size by calling setSize/6, it just ensures
              that it won't become smaller than this size during the automatic layout.

              See: SetMinClientSize() (not implemented in wx), Overview windowsizing

       setOwnBackgroundColour(This, Colour) -> ok

              Types:

                 This = wxWindow()
                 Colour = wx:wx_colour()

              Sets the background colour of the window but prevents it from  being  inherited  by
              the children of this window.

              See: setBackgroundColour/2, inheritAttributes/1

       setOwnFont(This, Font) -> ok

              Types:

                 This = wxWindow()
                 Font = wxFont:wxFont()

              Sets the font of the window but prevents it from being inherited by the children of
              this window.

              See: setFont/2, inheritAttributes/1

       setOwnForegroundColour(This, Colour) -> ok

              Types:

                 This = wxWindow()
                 Colour = wx:wx_colour()

              Sets the foreground colour of the window but prevents it from  being  inherited  by
              the children of this window.

              See: setForegroundColour/2, inheritAttributes/1

       setDropTarget(This, Target) -> ok

              Types:

                 This = wxWindow()
                 Target = wx:wx_object()

              Associates a drop target with this window.

              If the window already has a drop target, it is deleted.

              See: getDropTarget/1, Overview dnd

       setExtraStyle(This, ExStyle) -> ok

              Types:

                 This = wxWindow()
                 ExStyle = integer()

              Sets the extra style bits for the window.

              The currently defined extra style bits are reported in the class description.

       setFocus(This) -> ok

              Types:

                 This = wxWindow()

              This sets the window to receive keyboard input.

              See:    HasFocus()    (not    implemented   in   wx),   wxFocusEvent,   setFocus/1,
              wxPanel:setFocusIgnoringChildren/1

       setFocusFromKbd(This) -> ok

              Types:

                 This = wxWindow()

              This function is called by wxWidgets keyboard navigation code when the  user  gives
              the focus to this window from keyboard (e.g. using TAB key).

              By  default  this  method  simply  calls  setFocus/1  but  can  be overridden to do
              something in addition to this in the derived classes.

       setFont(This, Font) -> boolean()

              Types:

                 This = wxWindow()
                 Font = wxFont:wxFont()

              Sets the font for this window.

              This function should not be called for the parent window if you don't want its font
              to  be  inherited  by  its  children, use setOwnFont/2 instead in this case and see
              inheritAttributes/1 for more explanations.

              Please notice that the given font is not automatically used for  wxPaintDC  objects
              associated with this window, you need to call wxDC:setFont/2 too. However this font
              is  used  by  any  standard  controls  for  drawing  their  text  as  well  as   by
              getTextExtent/3.

              Return:  true  if  the font was really changed, false if it was already set to this
              font and nothing was done.

              See: getFont/1, inheritAttributes/1

       setForegroundColour(This, Colour) -> boolean()

              Types:

                 This = wxWindow()
                 Colour = wx:wx_colour()

              Sets the foreground colour of the window.

              The meaning of foreground colour varies according to the window class;  it  may  be
              the  text  colour  or other colour, or it may not be used at all. Additionally, not
              all native controls support changing their foreground colour  so  this  method  may
              change their colour only partially or even not at all.

              Please  see  inheritAttributes/1  for  explanation  of  the difference between this
              method and setOwnForegroundColour/2.

              Return: true if the colour was really changed, false if it was already set to  this
              colour and nothing was done.

              See:     getForegroundColour/1,    setBackgroundColour/2,    getBackgroundColour/1,
              shouldInheritColours/1

       setHelpText(This, HelpText) -> ok

              Types:

                 This = wxWindow()
                 HelpText = unicode:chardata()

              Sets the help text to be used as context-sensitive help for this window.

              Note  that  the  text  is  actually  stored  by  the  current  wxHelpProvider  (not
              implemented in wx) implementation, and not in the window object itself.

              See: getHelpText/1, wxHelpProvider::AddHelp() (not implemented in wx)

       setId(This, Winid) -> ok

              Types:

                 This = wxWindow()
                 Winid = integer()

              Sets the identifier of the window.

              Remark:  Each window has an integer identifier. If the application has not provided
              one, an identifier will be generated. Normally, the identifier should  be  provided
              on creation and should not be modified subsequently.

              See: getId/1, Overview windowids

       setLabel(This, Label) -> ok

              Types:

                 This = wxWindow()
                 Label = unicode:chardata()

              Sets the window's label.

              See: getLabel/1

       setName(This, Name) -> ok

              Types:

                 This = wxWindow()
                 Name = unicode:chardata()

              Sets the window's name.

              See: getName/1

       setPalette(This, Pal) -> ok

              Types:

                 This = wxWindow()
                 Pal = wxPalette:wxPalette()

              Deprecated: use wxDC:setPalette/2 instead.

       setScrollbar(This, Orientation, Position, ThumbSize, Range) -> ok

              Types:

                 This = wxWindow()
                 Orientation = Position = ThumbSize = Range = integer()

       setScrollbar(This, Orientation, Position, ThumbSize, Range,
                    Options :: [Option]) ->
                       ok

              Types:

                 This = wxWindow()
                 Orientation = Position = ThumbSize = Range = integer()
                 Option = {refresh, boolean()}

              Sets the scrollbar properties of a built-in scrollbar.

              Remark:  Let's  say  you wish to display 50 lines of text, using the same font. The
              window is sized so that you can only see 16 lines at a time. You  would  use:  Note
              that  with  the window at this size, the thumb position can never go above 50 minus
              16, or 34. You can determine how many lines are currently visible by  dividing  the
              current  view  size  by  the  character  height  in  pixels. When defining your own
              scrollbar behaviour, you will always need to  recalculate  the  scrollbar  settings
              when  the  window size changes. You could therefore put your scrollbar calculations
              and SetScrollbar call into a function named AdjustScrollbars, which can  be  called
              initially and also from your wxSizeEvent handler function.

              See:   Overview   scrolling,  wxScrollBar,  wxScrolled  (not  implemented  in  wx),
              wxScrollWinEvent

       setScrollPos(This, Orientation, Pos) -> ok

              Types:

                 This = wxWindow()
                 Orientation = Pos = integer()

       setScrollPos(This, Orientation, Pos, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Orientation = Pos = integer()
                 Option = {refresh, boolean()}

              Sets the position of one of the built-in scrollbars.

              Remark: This function does not directly affect the contents of the window: it is up
              to  the  application  to  take  note  of  scrollbar  attributes and redraw contents
              accordingly.

              See: setScrollbar/6, getScrollPos/2, getScrollThumb/2, wxScrollBar, wxScrolled (not
              implemented in wx)

       setSize(This, Rect) -> ok

       setSize(This, Size) -> ok

              Types:

                 This = wxWindow()
                 Size = {W :: integer(), H :: integer()}

              This  is  an  overloaded member function, provided for convenience. It differs from
              the above function only in what argument(s) it accepts.

       setSize(This, Width, Height) -> ok

       setSize(This, Rect, Height :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Rect =
                     {X :: integer(),
                      Y :: integer(),
                      W :: integer(),
                      H :: integer()}
                 Option = {sizeFlags, integer()}

              Sets the size of the window in pixels.

              The size is specified using a {X,Y,W,H}, {Width,Height}  or  by  a  couple  of  int
              objects.

              Remark: This form must be used with non-default width and height values.

              See: move/4, Overview windowsizing

       setSize(This, X, Y, Width, Height) -> ok

              Types:

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

       setSize(This, X, Y, Width, Height, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 X = Y = Width = Height = integer()
                 Option = {sizeFlags, integer()}

              Sets the size of the window in pixels.

              Remark:  This  overload  sets  the  position  and  optionally  size, of the window.
              Parameters may be wxDefaultCoord to  indicate  either  that  a  default  should  be
              supplied by wxWidgets, or that the current value of the dimension should be used.

              See: move/4, Overview windowsizing

       setSizeHints(This, MinSize) -> ok

              Types:

                 This = wxWindow()
                 MinSize = {W :: integer(), H :: integer()}

       setSizeHints(This, MinW, MinH) -> ok

       setSizeHints(This, MinSize, MinH :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 MinSize = {W :: integer(), H :: integer()}
                 Option =
                     {maxSize, {W :: integer(), H :: integer()}} |
                     {incSize, {W :: integer(), H :: integer()}}

              Use  of  this function for windows which are not toplevel windows (such as wxDialog
              or wxFrame) is discouraged.

              Please use setMinSize/2 and setMaxSize/2 instead.

              See: setSizeHints/4, Overview windowsizing

       setSizeHints(This, MinW, MinH, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 MinW = MinH = integer()
                 Option =
                     {maxW, integer()} |
                     {maxH, integer()} |
                     {incW, integer()} |
                     {incH, integer()}

              This is an overloaded member function, provided for convenience.  It  differs  from
              the above function only in what argument(s) it accepts.

       setSizer(This, Sizer) -> ok

              Types:

                 This = wxWindow()
                 Sizer = wxSizer:wxSizer()

       setSizer(This, Sizer, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Sizer = wxSizer:wxSizer()
                 Option = {deleteOld, boolean()}

              Sets the window to have the given layout sizer.

              The  window  will  then  own  the object, and will take care of its deletion. If an
              existing layout constraints object is already owned  by  the  window,  it  will  be
              deleted if the deleteOld parameter is true.

              Note  that  this  function  will  also  call  setAutoLayout/2  implicitly with true
              parameter if the sizer is non-NULL and false otherwise so that the  sizer  will  be
              effectively used to layout the window children whenever it is resized.

              Remark: SetSizer enables and disables Layout automatically.

       setSizerAndFit(This, Sizer) -> ok

              Types:

                 This = wxWindow()
                 Sizer = wxSizer:wxSizer()

       setSizerAndFit(This, Sizer, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Sizer = wxSizer:wxSizer()
                 Option = {deleteOld, boolean()}

              Associate  the  sizer  with  the  window  and  set the window size and minimal size
              accordingly.

              This method calls setSizer/3 and then wxSizer:setSizeHints/2 which sets the initial
              window  size  to  the  size  needed  to accommodate all sizer elements and sets the
              minimal size to the same size, this preventing the user from resizing  this  window
              to be less than this minimal size (if it's a top-level window which can be directly
              resized by the user).

       setThemeEnabled(This, Enable) -> ok

              Types:

                 This = wxWindow()
                 Enable = boolean()

              This function tells a window if it should use the system's "theme" code to draw the
              windows' background instead of its own background drawing code.

              This  does not always have any effect since the underlying platform obviously needs
              to support the notion of themes in user defined windows. One such platform is  GTK+
              where  windows  can  have (very colourful) backgrounds defined by a user's selected
              theme.

              Dialogs, notebook pages and the status bar have this flag set to true by default so
              that the default look and feel is simulated best.

              See: getThemeEnabled/1

       setToolTip(This, TipString) -> ok

       setToolTip(This, Tip) -> ok

              Types:

                 This = wxWindow()
                 Tip = wxToolTip:wxToolTip()

              This  is  an  overloaded member function, provided for convenience. It differs from
              the above function only in what argument(s) it accepts.

       setVirtualSize(This, Size) -> ok

              Types:

                 This = wxWindow()
                 Size = {W :: integer(), H :: integer()}

              This is an overloaded member function, provided for convenience.  It  differs  from
              the above function only in what argument(s) it accepts.

       setVirtualSize(This, Width, Height) -> ok

              Types:

                 This = wxWindow()
                 Width = Height = integer()

              Sets the virtual size of the window in pixels.

              See: Overview windowsizing

       setWindowStyle(This, Style) -> ok

              Types:

                 This = wxWindow()
                 Style = integer()

              See setWindowStyleFlag/2 for more info.

       setWindowStyleFlag(This, Style) -> ok

              Types:

                 This = wxWindow()
                 Style = integer()

              Sets the style of the window.

              Please  note  that some styles cannot be changed after the window creation and that
              refresh/2 might need to be called after changing the others for the change to  take
              place immediately.

              See Window styles for more information about flags.

              See: getWindowStyleFlag/1

       setWindowVariant(This, Variant) -> ok

              Types:

                 This = wxWindow()
                 Variant = wx:wx_enum()

              Chooses a different variant of the window display to use.

              Window variants currently just differ in size, as can be seen from ?wxWindowVariant
              documentation. Under all platforms but macOS, this function does nothing more  than
              change  the font used by the window. However under macOS it is implemented natively
              and selects the  appropriate  variant  of  the  native  widget,  which  has  better
              appearance  than just scaled down or up version of the normal variant, so it should
              be preferred to directly tweaking the font size.

              By default the controls naturally use the normal variant.

       shouldInheritColours(This) -> boolean()

              Types:

                 This = wxWindow()

              Return true from here to allow  the  colours  of  this  window  to  be  changed  by
              inheritAttributes/1.

              Returning false forbids inheriting them from the parent window.

              The  base  class  version returns false, but this method is overridden in wxControl
              where it returns true.

       show(This) -> boolean()

              Types:

                 This = wxWindow()

       show(This, Options :: [Option]) -> boolean()

              Types:

                 This = wxWindow()
                 Option = {show, boolean()}

              Shows or hides the window.

              You may need to call raise/1 for a top level window if you want to bring it to top,
              although  this  is  not  needed  if  show/2  is  called immediately after the frame
              creation.

              Notice that the default state of newly created top  level  windows  is  hidden  (to
              allow  you  to create their contents without flicker) unlike for all the other, not
              derived from wxTopLevelWindow, windows that are by default  created  in  the  shown
              state.

              Return:  true  if  the window has been shown or hidden or false if nothing was done
              because it already was in the requested state.

              See: isShown/1, hide/1, wxRadioBox:show/3, wxShowEvent

       thaw(This) -> ok

              Types:

                 This = wxWindow()

              Re-enables window updating after a previous call to freeze/1.

              To really thaw the control, it must be called exactly the same number of  times  as
              freeze/1.

              If the window has any children, they are recursively thawed too.

              See: wxWindowUpdateLocker (not implemented in wx), freeze/1, isFrozen/1

       transferDataFromWindow(This) -> boolean()

              Types:

                 This = wxWindow()

              Transfers values from child controls to data areas specified by their validators.

              Returns false if a transfer failed.

              Notice that this also calls transferDataFromWindow/1 for all children recursively.

              See: transferDataToWindow/1, wxValidator (not implemented in wx), validate/1

       transferDataToWindow(This) -> boolean()

              Types:

                 This = wxWindow()

              Transfers values to child controls from data areas specified by their validators.

              Notice that this also calls transferDataToWindow/1 for all children recursively.

              Return: Returns false if a transfer failed.

              See: transferDataFromWindow/1, wxValidator (not implemented in wx), validate/1

       update(This) -> ok

              Types:

                 This = wxWindow()

              Calling this method immediately repaints the invalidated area of the window and all
              of its children recursively (this normally only happens when the  flow  of  control
              returns to the event loop).

              Notice  that  this  function  doesn't  invalidate any area of the window so nothing
              happens if nothing has been invalidated (i.e. marked as requiring  a  redraw).  Use
              refresh/2 first if you want to immediately redraw the window unconditionally.

       updateWindowUI(This) -> ok

              Types:

                 This = wxWindow()

       updateWindowUI(This, Options :: [Option]) -> ok

              Types:

                 This = wxWindow()
                 Option = {flags, integer()}

              This function sends one or more wxUpdateUIEvent to the window.

              The  particular  implementation depends on the window; for example a wxToolBar will
              send an update UI event for each toolbar button, and a wxFrame will send an  update
              UI event for each menubar menu item.

              You  can  call this function from your application to ensure that your UI is up-to-
              date at this point (as far as your wxUpdateUIEvent handlers  are  concerned).  This
              may    be    necessary    if   you   have   called   wxUpdateUIEvent:setMode/1   or
              wxUpdateUIEvent:setUpdateInterval/1 to limit the overhead that wxWidgets incurs  by
              sending  update UI events in idle time. flags should be a bitlist of one or more of
              the ?wxUpdateUI enumeration.

              If you are calling this function from an OnInternalIdle or  OnIdle  function,  make
              sure  you  pass  the wxUPDATE_UI_FROMIDLE flag, since this tells the window to only
              update the UI elements that need to be updated in idle time.  Some  windows  update
              their  elements  only when necessary, for example when a menu is about to be shown.
              The following is an example of how to call UpdateWindowUI from an idle function.

              See: wxUpdateUIEvent, DoUpdateWindowUI() (not implemented in wx),  OnInternalIdle()
              (not implemented in wx)

       validate(This) -> boolean()

              Types:

                 This = wxWindow()

              Validates the current values of the child controls using their validators.

              Notice that this also calls validate/1 for all children recursively.

              Return: Returns false if any of the validations failed.

              See: transferDataFromWindow/1, transferDataToWindow/1, wxValidator (not implemented
              in wx)

       warpPointer(This, X, Y) -> ok

              Types:

                 This = wxWindow()
                 X = Y = integer()

              Moves the pointer to the given position on the window.

              Note:  Apple  Human  Interface  Guidelines   forbid   moving   the   mouse   cursor
              programmatically  so  you should avoid using this function in Mac applications (and
              probably avoid using it under the other platforms without good reason as well).

       setTransparent(This, Alpha) -> boolean()

              Types:

                 This = wxWindow()
                 Alpha = integer()

              Set the transparency of the window.

              If the system supports transparent windows, returns true, otherwise  returns  false
              and the window remains fully opaque. See also canSetTransparent/1.

              The  parameter  alpha  is  in  the  range  0..255  where  0  corresponds to a fully
              transparent  window  and   255   to   the   fully   opaque   one.   The   constants
              wxIMAGE_ALPHA_TRANSPARENT and wxIMAGE_ALPHA_OPAQUE can be used.

       canSetTransparent(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns   true   if   the   system   supports   transparent   windows  and  calling
              setTransparent/2 may succeed.

              If this function returns false, transparent windows are definitely not supported by
              the current system.

       isDoubleBuffered(This) -> boolean()

              Types:

                 This = wxWindow()

              Returns  true  if the window contents is double-buffered by the system, i.e. if any
              drawing done on the window is really  done  on  a  temporary  backing  surface  and
              transferred to the screen all at once later.

              See: wxBufferedDC

       setDoubleBuffered(This, On) -> ok

              Types:

                 This = wxWindow()
                 On = boolean()

              Turn on or off double buffering of the window if the system supports it.

       getContentScaleFactor(This) -> number()

              Types:

                 This = wxWindow()

              Returns the factor mapping logical pixels of this window to physical pixels.

              This  function can be used to portably determine the number of physical pixels in a
              window of the given size, by multiplying the window size by the value returned from
              it.  I.e.  it  returns  the  factor converting window coordinates to "content view"
              coordinates, where the view can be just a simple window displaying  a  wxBitmap  or
              wxGLCanvas or any other kind of window rendering arbitrary "content" on screen.

              For  the  platforms  not  doing  any pixel mapping, i.e. where logical and physical
              pixels are one and the same, this function always returns 1.0 and so using  it  is,
              in  principle,  unnecessary  and  could  be avoided by using preprocessor check for
              wxHAVE_DPI_INDEPENDENT_PIXELS  not  being  defined,  however  using  this  function
              unconditionally under all platforms is usually simpler and so preferable.

              Note:  Current  behaviour  of  this  function is compatible with wxWidgets 3.0, but
              different from its behaviour in versions 3.1.0 to 3.1.3, where it returned the same
              value  as  getDPIScaleFactor/1.  Please use the other function if you need to use a
              scaling   factor   greater   than   1.0   even   for    the    platforms    without
              wxHAVE_DPI_INDEPENDENT_PIXELS, such as wxMSW.

              Since: 2.9.5

       getDPI(This) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()

              Return the DPI of the display used by this window.

              The  returned  value can be different for different windows on systems with support
              for per-monitor DPI values, such as Microsoft Windows 10.

              If the DPI is not available, returns {Width,Height} object.

              See: wxDisplay:getPPI/1, wxDPIChangedEvent (not implemented in wx)

              Since: 3.1.3

       fromDIP(D, W) -> integer()

       fromDIP(Sz, W) -> {W :: integer(), H :: integer()}

       fromDIP(This, D) -> integer()

       fromDIP(This, Sz) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()
                 Sz = {W :: integer(), H :: integer()}

              Convert DPI-independent pixel values to the value in  pixels  appropriate  for  the
              current toolkit.

              A  DPI-independent pixel is just a pixel at the standard 96 DPI resolution. To keep
              the same physical size at higher resolution,  the  physical  pixel  value  must  be
              scaled  by  getDPIScaleFactor/1  but  this  scaling  may  be  already  done  by the
              underlying toolkit (GTK+, Cocoa,  ...)  automatically.  This  method  performs  the
              conversion  only  if  it  is  not already done by the lower level toolkit and so by
              using it with pixel values  you  can  guarantee  that  the  physical  size  of  the
              corresponding elements will remain the same in all resolutions under all platforms.
              For example, instead of creating a bitmap of the hard coded size of 32  pixels  you
              should use to avoid using tiny bitmaps on high DPI screens.

              Notice  that this function is only needed when using hard coded pixel values. It is
              not necessary if the sizes are already based on the DPI-independent units  such  as
              dialog   units  or  if  you  are  relying  on  the  controls  automatic  best  size
              determination and using sizers to lay out them.

              Also note that if either component of sz  has  the  special  value  of  -1,  it  is
              returned  unchanged independently of the current DPI, to preserve the special value
              of -1 in wxWidgets API (it is often used to mean "unspecified").

              Since: 3.1.0

       toDIP(D, W) -> integer()

       toDIP(Sz, W) -> {W :: integer(), H :: integer()}

       toDIP(This, D) -> integer()

       toDIP(This, Sz) -> {W :: integer(), H :: integer()}

              Types:

                 This = wxWindow()
                 Sz = {W :: integer(), H :: integer()}

              Convert pixel values of the current toolkit to DPI-independent pixel values.

              A DPI-independent pixel is just a pixel at the standard 96 DPI resolution. To  keep
              the  same  physical  size  at  higher  resolution, the physical pixel value must be
              scaled by  getDPIScaleFactor/1  but  this  scaling  may  be  already  done  by  the
              underlying  toolkit  (GTK+,  Cocoa,  ...)  automatically.  This method performs the
              conversion only if it is not already done by the lower level toolkit, For  example,
              you  may  want  to use this to store window sizes and positions so that they can be
              re-used regardless of the display DPI:

              Also note that if either component of sz  has  the  special  value  of  -1,  it  is
              returned  unchanged independently of the current DPI, to preserve the special value
              of -1 in wxWidgets API (it is often used to mean "unspecified").

              Since: 3.1.0