%%
%%       \  /  | |\ | |¯\ /¯\ \  /                 
%%   W X  VV   | | \| |_/ \_/  VV  . E  R  L   
%%——————————————————————————————————————————
%%
%%   Copyright Ericsson AB 2008-2013. All Rights Reserved.
%%
%%——————————————————————————————————————————————
%% Whitespace Beautified by ScriptCulture © 2018
%% Sit Back · Feet Up · Learn wxErlang
%% For use as a reference only
%% www.scriptculture.com
%% Not check-summed 
%% wx 1.8 —————————————————————————————————————— 
%%
%% Licensed under the Apache License, 
%% Version 2.0 (the "License"); you may 
%% not use this file except in compliance 
%% with the License. You may obtain a copy 
%% of the License at:
%%
%%     http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by 
%% applicable law or agreed to in writing, software
%% distributed under the License is distributed 
%% on an "AS IS" BASIS, WITHOUT WARRANTIES 
%% OR CONDITIONS OF ANY KIND, either 
%% express or implied. See the 
%% License for the specific 
%% language governing 
%% permissions and
%% limitations 
%% under the 
%% License.
%%%%%%%
%%%%
%%%
%%%%
%% @doc See external documentation: <a href="http://www.wxwidgets.org/manuals/2.8.12/wx_wxwindow.html">wxWindow</a>.
%% <p>This class is derived (and can use functions) from:
%% <br />{@link wxEvtHandler}
%% </p>
%% @type wxWindow().  
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%   
%%   OVERVIEW
%%   ––––––––
%%   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 or GetClientSize). 
%%
%%
%%         ———— NOTES FROM LIAM ———
%%      Worth reading: "http://www-h.eng.cam.ac.uk/help/tpl/languages/C++/virtualsandoverloading.html"
%%      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.
%%   
%%
%%   WINDOW STYLES
%%   —————————————
%%   The following styles can apply to all windows, although they will not always
%%   make sense for a particular window class or on all platforms.
%%   
%%               wxBORDER_SIMPLE   Displays a thin border around the window. 
%%                                 wxSIMPLE_BORDER is the old name for this style.
%%               wxBORDER_DOUBLE   Displays a double border. 
%%                                 wxDOUBLE_BORDER is the old name for this style. 
%%                                 Windows and Mac only.
%%               wxBORDER_SUNKEN   Displays a sunken border. 
%%                                 wxSUNKEN_BORDER is the old name for this style.
%%               wxBORDER_RAISED   Displays a raised border. 
%%                                 wxRAISED_BORDER is the old name for this style.
%%               wxBORDER_STATIC   Displays a border suitable for a static control. 
%%                                 wxSTATIC_BORDER is the old name for this style. Windows only.
%%                wxBORDER_THEME   Displays a themed border where possible. 
%%                                 Currently this has an effect on Windows XP and above only. 
%%                                 For more information on themed borders, 
%%                                 please see Themed borders on Windows.
%%                 wxBORDER_NONE   Displays no border, overriding the default border style for the window. 
%%                                 wxNO_BORDER is the old name for this style.
%%
%%          wxTRANSPARENT_WINDOW   The window is transparent, that is, 
%%                                 it will not receive paint events. Windows only.
%%               wxTAB_TRAVERSAL   Use this to enable tab traversal for non-dialog windows.
%%                 wxWANTS_CHARS   Use this to indicate that the window wants to get all 
%%                                 char/key events for all keys - even for keys like TAB
%%                                 or ENTER which are usually used for dialog navigation 
%%                                 and which wouldn't be generated without this style. 
%%                                 If you need to use this style in order to get the arrows or etc., 
%%                                 but would still like to have normal keyboard navigation take place, 
%%                                 you should create and send a wxNavigationKeyEvent in response 
%%                                 to the key events for Tab and Shift-Tab.
%%   wxNO_FULL_REPAINT_ON_RESIZE   On Windows, this style used to disable repainting the window 
%%                                 completely when its size is changed. Since this behaviour 
%%                                 is now the default, the style is now obsolete and no longer 
%%                                 has an effect.
%%                     wxVSCROLL   Use this style to enable a vertical scrollbar.
%%                     wxHSCROLL   Use this style to enable a horizontal scrollbar.
%%              wxALWAYS_SHOW_SB   If a window has scrollbars, disable them instead of hiding 
%%                                 them when they are not needed (i.e. when the size of the 
%%                                 window is big enough to not require the scrollbars to navigate it). 
%%                                 This style is currently implemented for wxMSW, wxGTK and 
%%                                 wxUniversal and does nothing on the other platforms.
%%               wxCLIP_CHILDREN   Use this style to eliminate flicker caused by the background being 
%%                                 repainted, then children being painted over them. Windows only.
%%      wxFULL_REPAINT_ON_RESIZE   Use this style to force a complete redraw of the window whenever 
%%                                 it is resized instead of redrawing just the part of the 
%%                                 window affected by resizing. Note that this was the behaviour 
%%                                 by default before 2.5.1 release and that if you experience 
%%                                 redraw problems with code which previously used to work you 
%%                                 may want to try this. Currently this style applies on GTK+ 2 
%%                                 and Windows only, and full repainting is 
%%                                 always done on other platforms.
%%                                 
%%   See also window styles overview.
%%               
%%           
%%      
%%   EXTRA WINDOW STYLES
%%   ———————————————————          
%%                                 
%%   The following are extra styles, set using wxWindow:setExtraStyle
%%                                 
%%   wxWS_EX_VALIDATE_RECURSIVELY  By default, Validate/TransferDataTo/FromWindow() only work    
%%                                 on direct children of the window (compatible behaviour). 
%%                                 Set this flag to make them recursively descend into all subwindows.
%%                                 
%%           wxWS_EX_BLOCK_EVENTS  wxCommandEvents and the objects of the derived classes are 
%%                                 forwarded to the parent window and so on recursively by default. 
%%                                 Using this flag for the given window allows to block this
%%                                 propagation at this window, i.e. prevent the events from being 
%%                                 propagated further upwards. Dialogs have this flag on by default.
%%                                 
%%              wxWS_EX_TRANSIENT  Don't use this window as an implicit parent for the other windows: 
%%                                 this must be used with transient windows as otherwise there 
%%                                 is the risk of creating a dialog/frame with this window as a 
%%                                 parent which would lead to a crash if the parent is destroyed 
%%                                 before the child.
%%                                 
%%           wxWS_EX_PROCESS_IDLE  This window should always process idle events, even if the mode 
%%                                 set by wxIdleEvent::SetMode is wxIDLE_PROCESS_SPECIFIED.
%%                                 
%%     wxWS_EX_PROCESS_UI_UPDATES  This window should always process UI update events, even if the 
%%                                 mode set by wxUpdateUIEvent::SetMode is wxUPDATE_UI_PROCESS_SPECIFIED. 
%%   
%%    wx.hrl
%%    ——————
%%   -define(wxWS_EX_CONTEXTHELP,         128).
%%   -define(wxWS_EX_PROCESS_UI_UPDATES,   32).
%%   -define(wxWS_EX_PROCESS_IDLE,         16).
%%   -define(wxWS_EX_THEMED_BACKGROUND,     8).
%%   -define(wxWS_EX_TRANSIENT,             4).
%%   -define(wxWS_EX_BLOCK_EVENTS,          2).
%%   -define(wxWS_EX_VALIDATE_RECURSIVELY,  1).
%%

%%
%%   See Also:
%%   —————————
%%   Event handling overview, 
%%   Window sizing overview
%%   
%%   
%/


-module(wxWindow).
-include("wxe.hrl").
-export(['Destroy'/1,


    cacheBestSize/2,      captureMouse/1,              center/1,
          center/2,    centerOnParent/1,      centerOnParent/2,
         centre/1,            centre/2,      centreOnParent/1,
centreOnParent/2,   clearBackground/1,      clientToScreen/2,
                    clientToScreen/3,               close/1,                  close/2,
            convertDialogToPixels/2,             destroy/1,  convertPixelsToDialog/2,
                 destroyChildren/1,             disable/1,                 enable/1,
                         enable/2,           findFocus/0,             findWindow/2,
                findWindowById/1,      findWindowById/2,      findWindowByLabel/1,
            findWindowByLabel/2,    findWindowByName/1,       findWindowByName/2,
                         fit/1,           fitInside/1,                 freeze/1,
        getAcceleratorTable/1, getBackgroundColour/1,     getBackgroundStyle/1,
               getBestSize/1,          getCapture/0,               getCaret/1,
            getCharHeight/1,        getCharWidth/1,            getChildren/1,
           getClientSize/1,  getContainingSizer/1,              getCursor/1,
          getDropTarget/1,     getEventHandler/1,          getExtraStyle/1,
               getFont/1, getForegroundColour/1,         getGrandParent/1,
            getHandle/1,         getHelpText/1,                  getId/1,
            getLabel/1,          getMaxSize/1,             getMinSize/1,
            getName/1,           getParent/1,            getPosition/1,
           getRect/1,   getScreenPosition/1,          getScreenRect/1,
     getScrollPos/2,      getScrollRange/2,         getScrollThumb/2,
         getSize/1,            getSizer/1,          getTextExtent/2,
  getTextExtent/3,          getToolTip/1,        getUpdateRegion/1,
                       getVirtualSize/1,     getWindowStyleFlag/1,         getWindowVariant/1,
                          hasCapture/1,           hasScrollbar/2, hasTransparentBackground/1,
                               hide/1,      inheritAttributes/1,               initDialog/1,
                invalidateBestSize/1,              isEnabled/1,                isExposed/2,
                        isExposed/3,              isExposed/5,               isRetained/1,
                         isShown/1,             isTopLevel/1,                   layout/1,
                       lineDown/1,                 lineUp/1,                    lower/1,
                     makeModal/1,              makeModal/2,                     move/2,
                         move/3,                   move/4,      moveAfterInTabOrder/2,
        moveBeforeInTabOrder/2,               navigate/1,                 navigate/2,
                        new/0,                    new/2,                      new/3,
                  pageDown/1,                 pageUp/1,          popEventHandler/1,
          popEventHandler/2,              popupMenu/2,                popupMenu/3,
               popupMenu/4,                  raise/1,                  refresh/1,
                refresh/2,            refreshRect/2,              refreshRect/3,
          releaseMouse/1,            removeChild/2,                 reparent/2,
       screenToClient/1,         screenToClient/2,              scrollLines/2,
         scrollPages/2,           scrollWindow/3,             scrollWindow/4,
setAcceleratorTable/2,          setAutoLayout/2,      setBackgroundColour/2,
setBackgroundStyle/2,               setCaret/2,            setClientSize/2,
    setClientSize/3,     setContainingSizer/2,                setCursor/2,
   setDropTarget/2,          setExtraStyle/2,                 setFocus/1,
setFocusFromKbd/1,                setFont/2,      setForegroundColour/2,
   setHelpText/2,                  setId/2,                 setLabel/2,
   setMaxSize/2,             setMinSize/2,                  setName/2,
                setOwnBackgroundColour/2,               setOwnFont/2, setOwnForegroundColour/2,
                           setPalette/2,             setScrollPos/3,           setScrollPos/4,
                        setScrollbar/5,             setScrollbar/6,                setSize/2,
                            setSize/3,                  setSize/5,                setSize/6,
                      setSizeHints/2,             setSizeHints/3,           setSizeHints/4,
                         setSizer/2,                 setSizer/3,         setSizerAndFit/2,
                  setSizerAndFit/3,          setThemeEnabled/2,             setToolTip/2,
                 setVirtualSize/2,           setVirtualSize/3,    setVirtualSizeHints/2,
           setVirtualSizeHints/3,      setVirtualSizeHints/4,         setWindowStyle/2,
           setWindowStyleFlag/2,         setWindowVariant/2,   shouldInheritColours/1,
                        show/1,                     show/2,                   thaw/1,
     transferDataFromWindow/1,     transferDataToWindow/1,                 update/1,
            updateWindowUI/1,           updateWindowUI/2,               validate/1,
              warpPointer/3


                 ]).




%% inherited exports
-export([connect/2,connect/3,disconnect/1,disconnect/2,disconnect/3,parent_class/1]).

-export_type([wxWindow/0]).


%% @hidden
 parent_class(wxEvtHandler) -> true
;parent_class(   _Class   ) -> erlang:error({badtype, ?MODULE}).


-type wxWindow()  ::  wx:wx_object().



  




           %·%% NEW / 0 %%·%

%%   
%%   Default constructor.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec new() -> wxWindow().
new() ->
           wxe_util:construct(?wxWindow_new_0,
           <<>>).

%% @equiv new(Parent,Id, [])
          -spec new(Parent, Id)       ->   wxWindow()
           when
           Parent ::  wxWindow(),
           Id     ::   integer().

new(Parent,Id)
           when
           is_record(Parent, wx_ref),
           is_integer(Id)             ->   new(Parent,Id, []).




           %·%% NEW %%·%

%%   
%%    Constructs a window, which can be a child of a frame, dialog or any other non-control window.
%%
%%   parent    Pointer to a parent window.
%%   id        Window identifier. If wxID_ANY, will automatically create an identifier.
%%   pos       Window position. wxDefaultPosition indicates that wxWidgets should generate a default 
%%             position for the window. If using the wxWindow class directly, 
%%             supply an actual position.
%%   size      Window size. wxDefaultSize indicates that wxWidgets should 
%%             generate a default size for the window. 
%%             If no suitable size can be found, the window will be sized to 20x20 pixels so that the 
%%             window is visible but obviously not correctly sized. 
%%   style     Window style. For generic window styles, please see wxWindow.
%%   name      Window name.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec new(Parent, Id, [Option]) -> wxWindow()
           when
           Parent  ::  wxWindow(),
           Id      ::   integer(),
           Option  ::  {pos,  {X  ::  integer(), Y  ::  integer()}}
                    |  {size, {W  ::  integer(), H  ::  integer()}}
                    |  {style,                           integer()}.

new(#wx_ref{type=ParentT,ref=ParentRef},Id, Options)
           when 
           is_integer(Id),
           is_list(Options)  ->
                              ?CLASS(ParentT,wxWindow),

  MOpts  = fun({pos,  {PosX,  PosY}},   Acc) -> [<<1:32/?UI,PosX:32/?UI,PosY:32/?UI,0:32>>|Acc];
              ({size, {SizeW,SizeH}},   Acc) -> [<<2:32/?UI,SizeW:32/?UI,SizeH:32/?UI,0:32>>|Acc];
              ({style,       Style},    Acc) -> [<<3:32/?UI,Style:32/?UI>>|Acc];
             (BadOpt, _                   ) -> erlang:error({badoption, BadOpt})
           end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:construct(?wxWindow_new_3,
                       <<ParentRef:32/?UI,Id:32/?UI, BinOpt/binary>>).






           %·%% CLOSE / 1 %%·%

%%   
%% See below...
%% @equiv close(This, [])
          -spec close(This)             ->    boolean()
           when
           This  :: wxWindow().

close(This)
           when
           is_record(This, wx_ref) ->    close(This, []).




           %·%% CLOSE / 2 %%·%

%%   
%%   This function simply generates a wxCloseEvent whose handler usually tries to close the window. 
%%   It doesn't close the window itself, however.
%%   
%%   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, in which case it should destroy 
%%   the window using wxWindow::Destroy.
%%   
%%   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 wxWindow::Destroy instead
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec close(This, [Option]) -> boolean()
           when
           This   ::         wxWindow(),
           Option ::  {force, boolean()}. %% false if the window's close handler should be able to 
                                          %% veto the destruction of this window, true if it cannot.

close(#wx_ref{type=ThisT,ref=ThisRef},
                   Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
  MOpts  = fun({force, Force}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(Force)):32/?UI>>|Acc];
              (BadOpt, _          ) -> erlang:error({badoption, BadOpt})
           end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:call(?wxWindow_Close,
                       <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).








           %·%% DESTROY %%·%

%%   Destructor. Deletes all subwindows, then deletes itself. 
%%   Instead of using the delete operator explicitly, 
%%   you should normally use wxWindow::Destroy so that wxWidgets 
%%   can delete a window only when it is safe to do so, in idle time.
%%   
%% @doc Destroys this object, do not use object again
          -spec destroy( This :: wxWindow()) -> ok.

destroy(Obj=#wx_ref{type=Type}) ->
                                 ?CLASS(Type,wxWindow),
                wxe_util:destroy(?DESTROY_OBJECT,Obj),
                ok.






           %·%% 'Destroy' %%·%

%%   
%%   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 Value: true if the window has either been successfully deleted, or 
%%               it has been added to the list of windows pending real deletion.
%% See Also:
%%*%%*%%
          -spec 'Destroy'(This) -> boolean()
           when
           This :: wxWindow().

'Destroy'(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                            ?CLASS(ThisT,wxWindow),
                              wxe_util:call(?wxWindow_Destroy,
                              <<ThisRef:32/?UI>>).












           %·%% GET GRAND PARENT %%·%

%%   
%%    Returns the grandparent of a window, or NULL if there isn't one.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getGrandParent(This) -> wxWindow()
           when
           This :: wxWindow().
           
getGrandParent(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                 ?CLASS(ThisT,wxWindow),
                                   wxe_util:call(?wxWindow_GetGrandParent,
                                   <<ThisRef:32/?UI>>).




           %·%% GET PARENT %%·%

%%   
%%    Returns the parent of the window, or NULL if there is no parent.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getParent(This) -> wxWindow()
           when
           This :: wxWindow().
           
getParent(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                            ?CLASS(ThisT,wxWindow),
                              wxe_util:call(?wxWindow_GetParent,
                              <<ThisRef:32/?UI>>).



           %·%% REPARENT %%·%

%%   
%%   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.
%%   
%% Return Value:
%% See Also: New parent.
%%*%%*%%
          -spec reparent(This, NewParent) -> boolean()
           when
           This      :: wxWindow(),
           NewParent :: wxWindow().
           
reparent(#wx_ref{type=ThisT,ref=ThisRef},
         #wx_ref{type=NewParentT,ref=NewParentRef}) ->
                                                     ?CLASS(ThisT,wxWindow),
                                                     ?CLASS(NewParentT,wxWindow),
                                       wxe_util:call(?wxWindow_Reparent,
                                       <<ThisRef:32/?UI,NewParentRef:32/?UI>>).









           %·%% GET CHILDREN %%·%

%%   
%%   Returns a reference to the list of the window's children. 
%%   wxWindowList is a type-safe wxList-like class whose 
%%   elements are of type wxWindow *.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getChildren(This) -> [wxWindow()]
           when
           This :: wxWindow().
           
getChildren(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                              ?CLASS(ThisT,wxWindow),
                                wxe_util:call(?wxWindow_GetChildren,
                                <<ThisRef:32/?UI>>).









           %·%% REMOVE CHILD %%·%

%%   
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec removeChild(This, Child) -> ok
           when
           This  :: wxWindow(),
           Child :: wxWindow(). % Child window to remove.
           
removeChild(#wx_ref{type=ThisT,ref=ThisRef},
            #wx_ref{type=ChildT,ref=ChildRef}) ->
                                                ?CLASS(ThisT,wxWindow),
                                                ?CLASS(ChildT,wxWindow),
                                  wxe_util:cast(?wxWindow_RemoveChild,
                                  <<ThisRef:32/?UI,ChildRef:32/?UI>>).






           %·%% FIND WINDOW %%·%

%%   1st
%%   Find a child of this window, by identifier.
%%
%%   2nd
%%   Find a child of this window, by name.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
%% 
          -spec findWindow(This, Winid) -> wxWindow()
           when
           This  :: wxWindow(),
           Winid ::  integer();

          (This, Name) ->  wxWindow()
           when
           This ::         wxWindow(),
           Name :: unicode:chardata().

findWindow(#wx_ref{type=ThisT,ref=ThisRef},Winid)
           when
           is_integer(Winid) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:call(?wxWindow_FindWindow_1_0,
                <<ThisRef:32/?UI,Winid:32/?UI>>);

findWindow(#wx_ref{type=ThisT,ref=ThisRef},Name)
           when
           is_list(Name) ->
                          ?CLASS(ThisT,wxWindow),
   Name_UC = unicode:characters_to_binary([Name,0]),
            wxe_util:call(?wxWindow_FindWindow_1_1,
            <<ThisRef:32/?UI,(byte_size(Name_UC)):32/?UI,(Name_UC)/binary,
                  0:(((8- ((0+byte_size(Name_UC)) band 16#7)) band 16#7))/unit:8>>).







           %·%% DESTROY CHILDREN %%·%

%%   
%%    Destroys all children of a window. 
%%    
%%    Called automatically by the destructor.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec destroyChildren(This) -> boolean()
           when
           This :: wxWindow().

destroyChildren(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                  ?CLASS(ThisT,wxWindow),
                                    wxe_util:call(?wxWindow_DestroyChildren,
                                    <<ThisRef:32/?UI>>).






           %·%% INHERIT ATTRIBUTES %%·%

%%   
%%   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 default attributes. However if some of the parents attributes 
%%   are explicitly (that is, using SetFont and not SetOwnFont) 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 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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec inheritAttributes(This) -> ok
           when
           This :: wxWindow().
           
inheritAttributes(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                    ?CLASS(ThisT,wxWindow),
                                      wxe_util:cast(?wxWindow_InheritAttributes,
                                      <<ThisRef:32/?UI>>).




           %·%% SHOULD INHERIT COLOURS %%·%

%%   
%%   Return true from here to allow the colours of this window 
%%   to be changed by InheritAttributes, 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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec shouldInheritColours(This) -> boolean()
           when
           This :: wxWindow().
           
shouldInheritColours(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                       ?CLASS(ThisT,wxWindow),
                                         wxe_util:call(?wxWindow_ShouldInheritColours,
                                         <<ThisRef:32/?UI>>).
























           %·%% GET BEST SIZE %%·%

%%   
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getBestSize(This) -> {W :: integer(), H :: integer()}
           when
           This :: wxWindow().
           
getBestSize(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                              ?CLASS(ThisT,wxWindow),
                                wxe_util:call(?wxWindow_GetBestSize,
                                <<ThisRef:32/?UI>>).




           %·%% CACHE BEST SIZE %%·%

%%   
%%    Sets the cached best size value.
%%
%%     Cache the best size so it doesn't need to be calculated again, 
%%             (at least until some properties of the window change.)   
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec cacheBestSize(This, Size) -> ok
           when
           This  ::  wxWindow(),
           Size  ::  {W  ::  integer(),
                      H  ::  integer()}.

cacheBestSize(#wx_ref{type=ThisT,ref=ThisRef},{SizeW,SizeH})
           when
           is_integer(SizeW),
           is_integer(SizeH) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:cast(?wxWindow_CacheBestSize,
                <<ThisRef:32/?UI,SizeW:32/?UI,SizeH:32/?UI>>).





           %·%% INVALIDATE BEST SIZE %%·%

%%   
%%   Resets the cached best size value 
%%   so it will be recalculated the next time it is needed.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec invalidateBestSize(This) -> ok
           when
           This :: wxWindow().
           
invalidateBestSize(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                     ?CLASS(ThisT,wxWindow),
                                       wxe_util:cast(?wxWindow_InvalidateBestSize,
                                       <<ThisRef:32/?UI>>).














           %·%% CAPTURE MOUSE %%·%

%%   
%%   Directs all mouse input to this window. 
%%   Call wxWindow::ReleaseMouse 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 i`t receives the event. 
%%   
%%   - The event handler must not recapture mouse.
%%   
%% Return Value:
%% See Also: wxWindow::ReleaseMouse wxMouseCaptureLostEvent
%%*%%*%%
          -spec captureMouse(This)            -> ok
           when
           This ::  wxWindow().

captureMouse(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                               ?CLASS(ThisT,wxWindow),
                                 wxe_util:cast(?wxWindow_CaptureMouse,
                                 <<ThisRef:32/?UI>>).





           %·%% RELEASE MOUSE %%·%

%%   
%%    Releases mouse input captured with wxWindow::CaptureMouse.
%%   
%% Return Value:
%% See Also: wxWindow::CaptureMouse, wxWindow::HasCapture, 
%%           wxWindow::ReleaseMouse, wxMouseCaptureLostEvent wxMouseCaptureChangedEvent
%%*%%*%%
          -spec releaseMouse(This) -> ok
           when
           This :: wxWindow().
           
releaseMouse(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                               ?CLASS(ThisT,wxWindow),
                                 wxe_util:cast(?wxWindow_ReleaseMouse,
                                 <<ThisRef:32/?UI>>).





           %·%% GET CAPTURE %%·%

%%   
%%   Returns the currently captured window.
%%   
%% Return Value:
%% See Also: wxWindow:HasCapture,   
%%           wxWindow:CaptureMouse, 
%%           wxWindow:ReleaseMouse, 
%%           wxMouse:CaptureLostEvent, 
%%           wxMouse:CaptureChangedEvent 
%%*%%*%%
          -spec getCapture() -> wxWindow().
           
getCapture() ->
                wxe_util:call(?wxWindow_GetCapture,
                <<>>).




           %·%% HAS CAPTURE %%·%

%%   
%%    Returns true if this window has the current mouse capture.
%%   
%% Return Value:
%% See Also: wxWindow::CaptureMouse,  wxWindow::ReleaseMouse, 
%%           wxMouseCaptureLostEvent, wxMouseCaptureChangedEvent 
%%*%%*%%
           -spec hasCapture(This) -> boolean()
           when
           This :: wxWindow().
           
hasCapture(#wx_ref{type=ThisT,ref=ThisRef}) ->
                ?CLASS(ThisT,wxWindow),
  wxe_util:call(?wxWindow_HasCapture,
  <<ThisRef:32/?UI>>).













           %·%% CENTER %%·%

%%   
%% See below...
%% @equiv center(This, [])
          -spec  center(This)       ->   ok
           when
           This :: wxWindow().

center(This)
           when
           is_record(This, wx_ref)  ->   center(This, []).
%%    
%%    A synonym for Centre.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec center(This, [Option]) -> ok
           when
           This   ::      wxWindow(),
           Option :: {dir, integer()}.

center(#wx_ref{type=ThisT,ref=ThisRef},
                    Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
  MOpts =  fun({dir, Dir}, Acc) -> [<<1:32/?UI,Dir:32/?UI>>|Acc];
              (BadOpt, _      ) -> erlang:error({badoption, BadOpt})
           end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:cast(?wxWindow_Center,
                       <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).





           %·%% CENTRE %%·%

%%   
%% See below...
%% @equiv centre(This, [])
          -spec centre(This) -> ok
           when
           This   ::  wxWindow().

centre(This)
           when
           is_record(This, wx_ref) ->
                                      centre(This, []).
 
%%    
%%    Centres the window.
%%
%%   If the window is a top level one (i.e. doesn't have a parent), it will be centered relative to the screen anyhow.
%%
%%   direction       Specifies the direction for the centering. 
%%                   May be wxHORIZONTAL, wxVERTICAL or wxBOTH. 
%%                   It may also include wxCENTRE_ON_SCREEN flag if you want to 
%%                   center the window on the entire screen and not on its parent window.
%%
%%   The flag wxCENTRE_FRAME is obsolete and should not be used any longer (it has no effect).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec centre(This, [Option]) -> ok
           when
           This   ::        wxWindow(),
           Option ::   {dir, integer()}.

centre(#wx_ref{type=ThisT,ref=ThisRef}, Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
  MOpts  = fun({dir, Dir}, Acc) -> [<<1:32/?UI,Dir:32/?UI>>|Acc];
             (BadOpt, _      ) -> erlang:error({badoption, BadOpt})
           end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:cast(?wxWindow_Centre,
                       <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).










           %·%% CENTER ON PARENT %%·%

%%   
%% See below...
%% @equiv centerOnParent(This, [])
          -spec centerOnParent(This) -> ok
           when
           This  :: wxWindow().

centerOnParent(This)
           when
           is_record(This, wx_ref)   ->   centerOnParent(This, []).

%%    
%%    A synonym for CentreOnParent.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec centerOnParent(This, [Option]) -> ok
           when
           This    ::        wxWindow(),
           Option  ::   {dir, integer()}.

centerOnParent(#wx_ref{type=ThisT,ref=ThisRef}, Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
  MOpts =  fun({dir, Dir}, Acc) -> [<<1:32/?UI,Dir:32/?UI>>|Acc];
              (BadOpt, _     ) -> erlang:error({badoption, BadOpt})
           end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:cast(?wxWindow_CenterOnParent,
                       <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).




           %·%% CENTRE ON PARENT %%·%

%%   
%% See below...
%% @equiv centreOnParent(This, [])
          -spec centreOnParent(This) ->  ok
           when
           This   ::  wxWindow().

centreOnParent(This)
           when
           is_record(This, wx_ref)   ->  centreOnParent(This, []).

%%    
%%   Centres the window on its parent. This is a more readable synonym for Centre.
%%   
%%   This methods provides for a way to center 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 wxWindow::Centre.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec centreOnParent(This, [Option]) -> ok
           when
           This   ::       wxWindow() ,
           Option ::  {dir, integer()}. %% Specifies the direction for the centering. 
                                        %% May be wxHORIZONTAL, wxVERTICAL or wxBOTH.

centreOnParent(#wx_ref{type=ThisT,ref=ThisRef}, Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
  MOpts  = fun({dir, Dir}, Acc) -> [<<1:32/?UI,Dir:32/?UI>>|Acc];
              (BadOpt, _      ) -> erlang:error({badoption, BadOpt})
           end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:cast(?wxWindow_CentreOnParent,
                       <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).













           %·%% GET FOREGROUND COLOUR %%·%

%%   
%%    Returns the foreground colour of the window.
%%
%%   The interpretation of foreground colour is open to 
%%   interpretation according to the window class; 
%%   it may be the text colour or other colour, or it may not be used at all.
%%   
%% Return Value:
%% See Also: wxWindow::SetForegroundColour, wxWindow::SetBackgroundColour, wxWindow::GetBackgroundColour 
%%*%%*%%
          -spec getForegroundColour(This) -> wx:wx_colour4()
           when
           This :: wxWindow().
           
getForegroundColour(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                      ?CLASS(ThisT,wxWindow),
                                        wxe_util:call(?wxWindow_GetForegroundColour,
                                        <<ThisRef:32/?UI>>).



           %·%% SET FOREGROUND COLOUR %%·%

%%   
%%   Sets the foreground colour of the window.
%%   
%%   Please see InheritAttributes for explanation of the difference 
%%   between this method and SetOwnForegroundColour.
%%   
%%   The interpretation of foreground colour is open to interpretation 
%%   according to the window class; it may be the text colour or other colour, 
%%   or it may not be used at all.
%%
%%   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 Value:
%% See Also: wxWindow::GetForegroundColour, wxWindow::SetBackgroundColour, 
%%           wxWindow::GetBackgroundColour, wxWindow::ShouldInheritColours
%%*%%*%%
          -spec setForegroundColour(This, Colour) -> boolean()
           when
           This   ::     wxWindow(),
           Colour :: wx:wx_colour().
                     %% The colour to be used as the foreground colour, 
                     %% pass wxNullColour to reset to the default colour.

setForegroundColour(#wx_ref{type=ThisT,ref=ThisRef},
                                            Colour)
           when tuple_size(Colour) =:= 3;
                tuple_size(Colour) =:= 4 ->
                                          ?CLASS(ThisT,wxWindow),
                            wxe_util:call(?wxWindow_SetForegroundColour,
                            <<ThisRef:32/?UI,(wxe_util:colour_bin(Colour)):16/binary>>).




           %·%% SET OWN FOREGROUND COLOUR %%·%

%%   
%%   Sets the foreground colour of the window but prevents it from being 
%%   inherited by the children of this window.
%%   
%% Return Value:
%% See Also: SetForegroundColour, InheritAttributes
%%*%%*%%
          -spec setOwnForegroundColour(This, Colour) -> ok
           when
           This   ::     wxWindow(),
           Colour :: wx:wx_colour().

setOwnForegroundColour(#wx_ref{type=ThisT,ref=ThisRef},
                                               Colour)
           when
           tuple_size(Colour) =:= 3;
           tuple_size(Colour) =:= 4 ->
                                     ?CLASS(ThisT,wxWindow),
                       wxe_util:cast(?wxWindow_SetOwnForegroundColour,
                       <<ThisRef:32/?UI,(wxe_util:colour_bin(Colour)):16/binary>>).










           %·%% GET BACKGROUND COLOUR %%·%
%%    
%% Returns the background colour of the window.
%%
%% Return Value:
%% See Also: wxWindow::SetBackgroundColour, 
%%           wxWindow::SetForegroundColour, 
%%           wxWindow::GetForegroundColour 
%%*%%*%%
          -spec getBackgroundColour(This) -> wx:wx_colour4()
           when
           This :: wxWindow().
           
getBackgroundColour(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                      ?CLASS(ThisT,wxWindow),
                                        wxe_util:call(?wxWindow_GetBackgroundColour,
                                        <<ThisRef:32/?UI>>).





           %·%% SET BACKGROUND COLOUR %%·%

%%   
%%   Sets the background colour of the window.
%%   Please see InheritAttributes for explanation of the difference between 
%%   this method and SetOwnBackgroundColour.
%%   
%%   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 wxWindow::ClearBackground or wxWindow::Refresh 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 Value:
%% See Also: wxWindow::GetBackgroundColour, wxWindow::SetForegroundColour, 
%%           wxWindow::GetForegroundColour, wxWindow::ClearBackground, 
%%           wxWindow::Refresh, wxEraseEvent
%%*%%*%%
          -spec setBackgroundColour(This, Colour) -> boolean()
           when
           This   ::     wxWindow(),
           Colour :: wx:wx_colour().
                  %% The colour to be used as the background colour, 
                  %% pass wxNullColour to reset to the default colour.

setBackgroundColour(#wx_ref{type=ThisT,ref=ThisRef},
                                            Colour)
           when
           tuple_size(Colour) =:= 3;
           tuple_size(Colour) =:= 4 ->
                                     ?CLASS(ThisT,wxWindow),
                       wxe_util:call(?wxWindow_SetBackgroundColour,
                       <<ThisRef:32/?UI,(wxe_util:colour_bin(Colour)):16/binary>>).




           %·%% SET OWN BACKGROUND COLOUR %%·%

%%   
%%   Sets the background colour of the window but prevents it from being 
%%   inherited by the children of this window.
%%   
%% Return Value:
%% See Also: SetBackgroundColour, InheritAttributes
%%*%%*%%
          -spec setOwnBackgroundColour(This, Colour) -> ok
           when
           This   ::     wxWindow(),
           Colour :: wx:wx_colour().

setOwnBackgroundColour(#wx_ref{type=ThisT,ref=ThisRef},Colour)
           when
           tuple_size(Colour) =:= 3;
           tuple_size(Colour) =:= 4 ->
                                     ?CLASS(ThisT,wxWindow),
                       wxe_util:cast(?wxWindow_SetOwnBackgroundColour,
                       <<ThisRef:32/?UI,(wxe_util:colour_bin(Colour)):16/binary>>).





           %·%% GET BACKGROUND STYLE %%·%

%%   
%%   Returns the background style of the window. 
%%   The background style indicates 
%%   
%%  wxBG_STYLE_SYSTEM,
%%       whether background colour 
%%       should be determined by the system 
%%
%%  wxBG_STYLE_COLOUR
%%       be set to a specific colour ,
%%
%%  wxBG_STYLE_CUSTOM
%%       or should be left to the application to implement .
%%   
%%   On GTK+, use of wxBG_STYLE_CUSTOM allows the flicker-free drawing 
%%   of a custom background, such as a tiled bitmap. 
%%   Currently the style has no effect on other platforms.
%%   
%% Return Value:
%% See Also:  wxWindow::SetBackgroundColour, 
%%            wxWindow::GetForegroundColour, 
%%            wxWindow::SetBackgroundStyle
%%*%%*%%
%%<br /> Res = ?wxBG_STYLE_SYSTEM 
%%           | ?wxBG_STYLE_COLOUR 
%%           | ?wxBG_STYLE_CUSTOM

          -spec getBackgroundStyle(This) -> wx:wx_enum()
           when
           This :: wxWindow().
           
getBackgroundStyle(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                     ?CLASS(ThisT,wxWindow),
                                       wxe_util:call(?wxWindow_GetBackgroundStyle,
                                      <<ThisRef:32/?UI>>).







           %·%% SET BACKGROUND STYLE %%·%

%%   
%%   Sets the background style of the window. 
%%   The background style indicates whether background colour should be
%%   determined by the system (wxBG_STYLE_SYSTEM), be set to a specific colour 
%%   (wxBG_STYLE_COLOUR), or should be left to the application to implement 
%%   (wxBG_STYLE_CUSTOM).
%%
%%   On GTK+, use of wxBG_STYLE_CUSTOM allows the flicker-free drawing of a 
%%   custom background, such as a tiled bitmap. Currently the style has no 
%%   effect on other platforms.
%%   
%% Return Value:
%% See Also:  wxWindow::SetBackgroundColour, wxWindow::GetForegroundColour, wxWindow::GetBackgroundStyle
%%*%%*%%

          -spec setBackgroundStyle(This, Style) -> boolean()
           when
           This  ::   wxWindow(),
           Style :: wx:wx_enum().
                 %%-define(wxBG_STYLE_SYSTEM, 0).
                 %%-define(wxBG_STYLE_COLOUR, 1).
                 %%-define(wxBG_STYLE_CUSTOM, 2).

setBackgroundStyle(#wx_ref{type=ThisT,ref=ThisRef},Style)
           when
           is_integer(Style) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:call(?wxWindow_SetBackgroundStyle,
                <<ThisRef:32/?UI,Style:32/?UI>>).






           %·%% CLEAR BACKGROUND %%·%

%%   
%%    Clears the window by filling it with the current background colour.
%%    Does not cause an erase background event to be generated.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec clearBackground(This) -> ok
           when
           This   ::  wxWindow().

clearBackground(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                  ?CLASS(ThisT,wxWindow),
                                    wxe_util:cast(?wxWindow_ClearBackground,
                                    <<ThisRef:32/?UI>>).






           %·%% SET THEME ENABLED %%·%

%%   
%%   This function tells a window if it should use the system's "theme" code to 
%%   draw the windows' background instead if 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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setThemeEnabled(This, EnableTheme) -> ok
           when
           This        :: wxWindow(), 
           EnableTheme ::  boolean().

setThemeEnabled(#wx_ref{type=ThisT,ref=ThisRef}, EnableTheme)
           when
           is_boolean(EnableTheme) ->
                                      ?CLASS(ThisT,wxWindow),
                        wxe_util:cast(?wxWindow_SetThemeEnabled,
                        <<ThisRef:32/?UI,(wxe_util:from_bool(EnableTheme)):32/?UI>>).





           %·%% HAS TRANSPARENT BACKGROUND %%·%

%%   
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec hasTransparentBackground(This) -> boolean()
           when
           This :: wxWindow().
           
hasTransparentBackground(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                           ?CLASS(ThisT,wxWindow),
                                             wxe_util:call(?wxWindow_HasTransparentBackground,
                                             <<ThisRef:32/?UI>>).



















           %·%% SCREEN TO CLIENT %%·%

%%   
%%    Converts from screen to client window coordinates.
%%   
%%    x - Stores the screen x coordinate and receives the client x coordinate.
%%    y - Stores the screen x coordinate and receives the client x coordinate.
%%   
%% Return Value: Gives you the X & Y of a client window. 
%% See Also:
%%*%%*%%
          -spec screenToClient(This) -> {X :: integer(), Y :: integer()}
           when
           This :: wxWindow().
           
screenToClient(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                 ?CLASS(ThisT,wxWindow),
                                   wxe_util:call(?wxWindow_ScreenToClient_2,
                                   <<ThisRef:32/?UI>>).







           %·%% SCREEN TO CLIENT %%·%

%%   
%%      Pt  - The screen position for the second form of the function.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec screenToClient(This, Pt) -> {X :: integer(), Y :: integer()}
           when
           This ::                      wxWindow(),
           Pt   :: {X :: integer(), Y :: integer()}.

screenToClient(#wx_ref{type=ThisT,ref=ThisRef},
                                     {PtX,PtY})
           when
           is_integer(PtX),
           is_integer(PtY) ->
                            ?CLASS(ThisT,wxWindow),
              wxe_util:call(?wxWindow_ScreenToClient_1,
              <<ThisRef:32/?UI,PtX:32/?UI,PtY:32/?UI>>).





           %·%% CLIENT TO SCREEN %%·%


          -spec clientToScreen(This, Pt) -> {X  ::  integer(), Y  ::  integer()}
           when
           This ::                       wxWindow(),
           Pt   ::  {X :: integer(), Y :: integer()}.
                     %%  X & Y %% A pointer to a integer value for the x coordinate. 
                               %% Pass the client coordinate in, and a screen coordinate will be passed out.

%%    Converts to screen coordinates from coordinates relative to this window.
%%   
%%    Takes a point in the client area, 
%%    and says where that is, in comparison to the scren. 
%%    
%% Return Value: 
%% See Also:
%%*%%*%%

clientToScreen(#wx_ref{type=ThisT,ref=ThisRef},{PtX,PtY})
           when
          is_integer(PtX),
          is_integer(PtY) ->
                           ?CLASS(ThisT,wxWindow),
             wxe_util:call(?wxWindow_ClientToScreen_1,
             <<ThisRef:32/?UI,PtX:32/?UI,PtY:32/?UI>>).



           %·%% CLIENT TO SCREEN / 3 %%·%

          -spec clientToScreen(This, X, Y) -> {X :: integer(), Y :: integer()}
           when
           This :: wxWindow(),
              X ::  integer(),
              Y ::  integer().

clientToScreen(#wx_ref{type=ThisT,ref=ThisRef},X,Y)
           when
           is_integer(X),
           is_integer(Y) ->
                          ?CLASS(ThisT,wxWindow),
            wxe_util:call(?wxWindow_ClientToScreen_2,
            <<ThisRef:32/?UI,X:32/?UI,Y:32/?UI>>).







           %·%% CONVERT DIALOG TO PIXELS %%·%

%%   
%%   Converts a point or size from dialog units to pixels.
%%   
%%   For the x dimension, the dialog units are multiplied by
%%   the average character width and then divided by 4.
%%   
%%   For the y dimension, the dialog units are multiplied by
%%   the average character height and then divided by 8.
%%  
%%    Dialog units are used for maintaining a dialog's proportions even if the font changes.
%%   
%%   You can also use these functions programmatically. A convenience macro is defined:
%%   
%%         #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
%%
%% Return Value: 
%% See Also: wxWindow::ConvertPixelsToDialog
%%*%%*%%
          -spec convertDialogToPixels(This, Sz) -> {W :: integer(), H :: integer()}
           when
           This ::                      wxWindow(),
           Sz   :: {W :: integer(), H :: integer()}.

convertDialogToPixels(#wx_ref{type=ThisT,ref=ThisRef},{SzW,SzH})
           when
           is_integer(SzW),
           is_integer(SzH) ->
                                            ?CLASS(ThisT,wxWindow),
                              wxe_util:call(?wxWindow_ConvertDialogToPixels,
                              <<ThisRef:32/?UI,SzW:32/?UI,SzH:32/?UI>>).




           %·%% CONVERT PIXELS TO DIALOG %%·%

%%   
%%    Converts a point or size from pixels to dialog units.
%%
%%   For the x dimension, the pixels are multiplied by 4 and then divided by the average character width.
%%   For the y dimension, the pixels are multiplied by 8 and then divided by the average character height.
%%   
%%   Dialog units are used for maintaining a dialog's proportions even if the font changes.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec convertPixelsToDialog(This, Sz) -> {W :: integer(), H :: integer()}
           when
           This ::      wxWindow(), 
           Sz   :: {W :: integer(),
           H    ::       integer()}.

convertPixelsToDialog(#wx_ref{type=ThisT,ref=ThisRef},{SzW,SzH})
           when
           is_integer(SzW),
           is_integer(SzH) ->
                            ?CLASS(ThisT,wxWindow),
              wxe_util:call(?wxWindow_ConvertPixelsToDialog,
              <<ThisRef:32/?UI,SzW:32/?UI,SzH:32/?UI>>).






           %·%% GET POSITION %%·%

%%   
%%   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.
%%   
%%   x
%%    Receives the x position of the window if non-NULL.
%%   y
%%    Receives the y position of the window if non-NULL.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getPosition(This) -> {X :: integer(), Y :: integer()}
           when
           This :: wxWindow().
           
getPosition(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                              ?CLASS(ThisT,wxWindow),
                                wxe_util:call(?wxWindow_GetPosition,
                                <<ThisRef:32/?UI>>).




           %·%% GET RECT %%·%

%%   
%%    Returns the size and position of the window as a wxRect object.
%%   
%% Return Value:
%% See Also: GetScreenRect
%%*%%*%%
          -spec getRect(This) -> {X :: integer(), Y :: integer(), W :: integer(), H :: integer()}
           when
           This :: wxWindow().
           
getRect(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                          ?CLASS(ThisT,wxWindow),
                            wxe_util:call(?wxWindow_GetRect,
                            <<ThisRef:32/?UI>>).




           %·%% GET SCREEN POSITION %%·%

%%   
%%    Returns the window position in screen coordinates, 
%%    whether the window is a child window or a top level one.
%%   
%%   x
%%    Receives the x position of the window if non-NULL.
%%   y
%%    Receives the y position of the window if non-NULL.
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getScreenPosition(This) -> {X :: integer(), Y :: integer()}
           when
           This :: wxWindow().
           
getScreenPosition(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                    ?CLASS(ThisT,wxWindow),
                                      wxe_util:call(?wxWindow_GetScreenPosition,
                                      <<ThisRef:32/?UI>>).




           %·%% GET SCREEN RECT %%·%

%%   
%%    Returns the size and position of the window on the screen as a wxRect object.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getScreenRect(This) -> {X :: integer(), Y :: integer(), W :: integer(), H :: integer()}
           when
           This :: wxWindow().
           
getScreenRect(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                ?CLASS(ThisT,wxWindow),
                                  wxe_util:call(?wxWindow_GetScreenRect,
                                  <<ThisRef:32/?UI>>).





           %·%% GET VIRTUAL SIZE %%·%

%%   
%%   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 it will return that size.
%%   
%%    width
%%        Receives the window width.
%%    height
%%        Receives the window height.
%%
%% Return Value:
%% See Also: GetSize, GetClientSize
%%*%%*%%
          -spec getVirtualSize(This) -> {W :: integer(), H :: integer()}
           when
           This :: wxWindow().
           
getVirtualSize(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                 ?CLASS(ThisT,wxWindow),
                                   wxe_util:call(?wxWindow_GetVirtualSize,
                                   <<ThisRef:32/?UI>>).







           %·%% SET VIRTUAL SIZE %%·%

%%   
%%    Sets the virtual size of the window in pixels.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setVirtualSize(This, Size) -> ok
           when
           This :: wxWindow(), 
           Size :: {W :: integer(), 
                    H :: integer()}.

setVirtualSize(#wx_ref{type=ThisT,ref=ThisRef}, {SizeW, SizeH})
           when
           is_integer(SizeW),
           is_integer(SizeH) ->
                                ?CLASS(ThisT,wxWindow),
                  wxe_util:cast(?wxWindow_SetVirtualSize_1,
                  <<ThisRef:32/?UI,SizeW:32/?UI,SizeH:32/?UI>>).

           %·%% SET VIRTUAL SIZE %%·%

%%   
%%    Sets the virtual size of the window in pixels.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setVirtualSize(This, X, Y) -> ok
           when
           This :: wxWindow(), 
           X    ::  integer(), 
           Y    ::  integer().

setVirtualSize(#wx_ref{type=ThisT,ref=ThisRef}, X, Y)
           when
           is_integer(X),
           is_integer(Y) ->
                            ?CLASS(ThisT,wxWindow),
              wxe_util:cast(?wxWindow_SetVirtualSize_2,
              <<ThisRef:32/?UI,X:32/?UI,Y:32/?UI>>).





           %·%% SET VIRTUAL SIZE HINTS %%·%

%%   
%% See below...
%% @equiv setVirtualSizeHints(This,MinSize, [])
          -spec setVirtualSizeHints(This, MinSize) -> ok
           when
           This    ::      wxWindow(), 
           MinSize :: {W :: integer(), 
                       H :: integer()}.

setVirtualSizeHints(This,MinSize={MinSizeW, MinSizeH})
           when
           is_record(This, wx_ref),
           is_integer(MinSizeW),
           is_integer(MinSizeH) ->  setVirtualSizeHints(This,MinSize, []).


%%    
%%   Allows specification of minimum and maximum virtual window sizes. 
%%   If a pair of values is not set (or set to -1), the default values will be used.
%% 
%%   If this function is called, the user will not be able to 
%%   size the virtual area of the window outside the given bounds.
%%  
%%         minW
%%                  Specifies the minimum width allowable.
%%
%%         minH
%%                  Specifies the minimum height allowable.
%%
%%         maxW
%%                  Specifies the maximum width allowable.
%%
%%         maxH
%%                  Specifies the maximum height allowable.
%%
%%         minSize
%%                  Minimum size.
%%
%%         maxSize
%%                  Maximum size.
%% Return Value:
%% See Also:
%%*%%*%%
%% 
          -spec setVirtualSizeHints(This, MinW, MinH)        ->  ok
           when
           This :: wxWindow(),
           MinW ::  integer(),
           MinH ::  integer();
                                   (This, MinSize, [Option]) ->  ok
           when
           This     ::                                wxWindow(),
           MinSize  ::           {W :: integer(), H :: integer()},
           Option   :: {maxSize, {W :: integer(), H :: integer()}}.

setVirtualSizeHints(This,MinW,MinH)
           when
           is_record(This, wx_ref),
           is_integer(MinW),
           is_integer(MinH) ->  setVirtualSizeHints(This,MinW,MinH, []);

setVirtualSizeHints(#wx_ref{type=ThisT,ref=ThisRef},
                                {MinSizeW,MinSizeH},
                                           Options)
           when
           is_integer(MinSizeW),
           is_integer(MinSizeH),
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   MOpts  = fun({maxSize, {MaxSizeW,MaxSizeH}}, Acc) -> [<<1:32/?UI,MaxSizeW:32/?UI,MaxSizeH:32/?UI,0:32>>|Acc];
                              (BadOpt, _) -> erlang:error({badoption, BadOpt})
                            end,
                   BinOpt =    list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                           wxe_util:cast(?wxWindow_SetVirtualSizeHints_2,
                                           <<ThisRef:32/?UI,MinSizeW:32/?UI,MinSizeH:32/?UI, 0:32,BinOpt/binary>>).
           %·%% SET VIRTUAL SIZE HINTS %%·%

%%   
%%   /\
%% See Above...  
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setVirtualSizeHints(This, MinW, MinH, [Option]) -> ok
           when
           This     ::        wxWindow(),
           MinW     ::         integer(),
           MinH     ::         integer(),
           Option   ::  {maxW, integer()}
                     |  {maxH, integer()}.

setVirtualSizeHints(#wx_ref{type=ThisT,ref=ThisRef}, MinW, MinH, Options)
           when
           is_integer(MinW),
           is_integer(MinH),
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   MOpts = fun({maxW, MaxW}, Acc) -> [<<1:32/?UI,MaxW:32/?UI>>|Acc];
                              ({maxH, MaxH}, Acc) -> [<<2:32/?UI,MaxH:32/?UI>>|Acc];
                                      (BadOpt, _) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_SetVirtualSizeHints_3,
                                        <<ThisRef:32/?UI,MinW:32/?UI,MinH:32/?UI, 0:32,BinOpt/binary>>).










































           %·%% FIT %%·%

%%   
%%   Sizes the window so that it fits around its subwindows. 
%%   This function won't do anything if there are no subwindows 
%%   and will only really work correctly if the sizers are used for 
%%   the subwindows layout. Also, if the window has exactly one subwindow 
%%   it is better (faster and the result is more precise as Fit adds some 
%%   margin to account for fuzziness of its calculations) to call
%%   
%%                                 window->SetClientSize(child->GetSize());
%%   
%%                                 instead of calling Fit.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec fit(This) -> ok
           when
           This :: wxWindow().
           
fit(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                      ?CLASS(ThisT,wxWindow),
                        wxe_util:cast(?wxWindow_Fit,
                        <<ThisRef:32/?UI>>).





           %·%% FIT INSIDE %%·%

%%   
%%   Similar to Fit, 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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec fitInside(This) -> ok 
           when
           This :: wxWindow().
           
fitInside(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                            ?CLASS(ThisT,wxWindow),
                              wxe_util:cast(?wxWindow_FitInside,
                              <<ThisRef:32/?UI>>).


















           %·%% ENABLE %%·%

%%   
%% See below...
%% @equiv enable(This, [])
          -spec enable(This)       ->  boolean()
           when
           This :: wxWindow().

enable(This)
           when
           is_record(This, wx_ref) ->  enable(This, []).

%%    
%%   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 reenabled again when the parent is. 
%%   
%% Return Value:  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 Also: wxWindow::IsEnabled, 
%%           wxWindow::Disable, 
%%           wxRadioBox::Enable
%%*%%*%%
          -spec enable(This, [Option]) -> boolean()
           when
           This    ::          wxWindow(),
           Option  ::  {enable, boolean()}. %% If vtrue, enables the window for input. 
                                            %% If false, disables the window.

enable(#wx_ref{type=ThisT,ref=ThisRef}, Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
  MOpts  = fun({enable, Enable}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(Enable)):32/?UI>>|Acc];
              (BadOpt, _) -> erlang:error({badoption, BadOpt})
           end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:call(?wxWindow_Enable,
                       <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).



           %·%% DISABLE %%·%

%%   
%%    Disables the window, same as Enable(false).
%%   
%% Return Value: Returns  true if the window has been disabled, 
%%                       false if it had been already disabled before the call to this function.
%% See Also:
%%*%%*%%
          -spec disable(This) -> boolean()
           when
           This :: wxWindow().

disable(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                          ?CLASS(ThisT,wxWindow),
                            wxe_util:call(?wxWindow_Disable,
                            <<ThisRef:32/?UI>>).







           %·%% IS ENABLED %%·%

%%   
%%    Returns true if the window is enabled for input, false otherwise.
%%   
%% Return Value:
%% See Also: wxWindow::Enable
%%*%%*%%
          -spec isEnabled(This) -> boolean()
           when
           This :: wxWindow().
           
isEnabled(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                            ?CLASS(ThisT,wxWindow),
                              wxe_util:call(?wxWindow_IsEnabled,
                              <<ThisRef:32/?UI>>).






           %·%% FREEZE %%·%

%%   
%%   Freezes the window or, in other words, 
%%   prevents any updates from taking place on screen, 
%%   the window is not redrawn at all. 
%%   Thaw must be called to reenable window redrawing. 
%%   Calls to these two functions may be nested.
%%   
%%   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.
%%   
%% Return Value:
%% See Also: wxWindowUpdateLocker
%%*%%*%%
          -spec freeze(This) -> ok
           when
           This :: wxWindow().
           
freeze(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                         ?CLASS(ThisT,wxWindow),
                           wxe_util:cast(?wxWindow_Freeze,
                           <<ThisRef:32/?UI>>).


           %·%% THAW %%·%

%%   
%%   Reenables window updating after a previous call to Freeze. 
%%   To really thaw the control, it must be called exactly 
%%   the same number of times as Freeze.
%%   
%% Return Value:
%% See Also: wxWindowUpdateLocker
%%*%%*%%
          -spec thaw(This) -> ok
           when
           This :: wxWindow().
           
thaw(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                       ?CLASS(ThisT,wxWindow),
                         wxe_util:cast(?wxWindow_Thaw,
                         <<ThisRef:32/?UI>>).























           %·%% SET FOCUS %%·%

%%   
%%    This sets the window to receive keyboard input.
%%       rc_note: havn't got this work successfully,
%%                used wxWindow:raise() instead.
%%                Havn't tried the one below, though.
%%
%% Return Value:
%% See Also: wxFocusEvent wxPanel::SetFocus wxPanel::SetFocusIgnoringChildren
%%*%%*%%
          -spec setFocus(This) -> ok  
           when
           This :: wxWindow().        
           
setFocus(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                           ?CLASS(ThisT,wxWindow),
                             wxe_util:cast(?wxWindow_SetFocus,
                             <<ThisRef:32/?UI>>).
 



           %·%% SET FOCUS FROM KBD(keyboard) %%·%

%%   
%%   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 but can be overridden to 
%%   do something in addition to this in the derived classes.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setFocusFromKbd(This) -> ok
           when
           This :: wxWindow().
           
setFocusFromKbd(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                  ?CLASS(ThisT,wxWindow),
                                    wxe_util:cast(?wxWindow_SetFocusFromKbd,
                                    <<ThisRef:32/?UI>>).







           %·%% FIND FOCUS %%·%

%%   
%%    Finds the window or control which currently has the keyboard focus.
%%   
%%    Note that this is a static function, so it can be called without needing a wxWindow pointer.
%%   
%% Return Value:
%% See Also: wxWindow::SetFocus
%%*%%*%%
          -spec findFocus() -> wxWindow().

findFocus() ->
                wxe_util:call(?wxWindow_FindFocus,
                <<>>).



           %·%% RAISE %%·%

%%   
%%   Raises the window to the top of the window hierarchy (z-order).
%%
%%   In current version of wxWidgets this works both 
%%   for managed and child windows.
%%   
%% Return Value:
%% See Also: Lower
%%*%%*%%
          -spec raise(This) -> ok
           when
           This :: wxWindow().
           
raise(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                        ?CLASS(ThisT,wxWindow),
                          wxe_util:cast(?wxWindow_Raise,
                          <<ThisRef:32/?UI>>).

           %·%% LOWER %%·%

%%   
%%    Lowers the window to the bottom of the window hierarchy (z-order).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec lower(This) -> ok 
           when
           This :: wxWindow().
           
lower(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                        ?CLASS(ThisT,wxWindow),
                          wxe_util:cast(?wxWindow_Lower,
                          <<ThisRef:32/?UI>>).







           %·%% MAKE MODAL %%·%

%%   
%% See below...
%% @equiv makeModal(This, [])
          -spec makeModal(This)    ->  ok
           when
           This :: wxWindow().
           
makeModal(This)
           when
           is_record(This, wx_ref) ->  makeModal(This, []).


%%    
%%   Disables all other windows in the application so that the user can only 
%%   interact with this window.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec makeModal(This, [Option]) -> ok
           when
           This   ::         wxWindow(),
           Option ::  {modal, boolean()}.
                  %%   If true, this call disables all other windows in the application 
                  %%   so that the user can only interact with this window. 
                  %%   If false, the effect is reversed.

makeModal(#wx_ref{type=ThisT,ref=ThisRef}, Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   MOpts =  fun({modal, Modal}, Acc)  ->  [<<1:32/?UI,(wxe_util:from_bool(Modal)):32/?UI>>|Acc];
                                         (BadOpt, _)  ->  erlang:error({badoption, BadOpt})
                            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_MakeModal,         
                                        <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).

















%% @equiv findWindowById(Winid, [])
          -spec findWindowById(Winid) ->  wxWindow()
           when
           Winid :: integer().

findWindowById(Winid)
           when
           is_integer(Winid)          ->  findWindowById(Winid, []).



















           %·%% FIND WINDOW BY ID %%·%

%%   
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec findWindowById(Winid, [Option]) -> wxWindow()
           when
           Winid  ::            integer(),
           Option ::  {parent, wxWindow()}.
           
findWindowById(Winid, Options)
           when
           is_integer(Winid),
           is_list(Options) ->
  
  MOpts =  fun({parent, #wx_ref{type=ParentT,ref=ParentRef}}, Acc) ->
                        ?CLASS(ParentT,wxWindow),[<<1:32/?UI,ParentRef:32/?UI>>|Acc];

              (BadOpt, _) -> erlang:error({badoption, BadOpt})
           end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:call(?wxWindow_FindWindowById,
                       <<Winid:32/?UI, 0:32,BinOpt/binary>>).



   


           %·%% FIND WINDOW BY NAME %%·%

%%   
%% See below...
%% @equiv findWindowByName(Name, [])
          -spec findWindowByName(Name)           ->   wxWindow()
           when
           Name :: unicode:chardata().

findWindowByName(Name)
           when
           is_list(Name)                         ->   findWindowByName(Name, []).


%%   
%%   Find a window by its name (as given in a window constructor or Create 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.
%%
%%   If no window with such name is found, FindWindowByLabel is called.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec findWindowByName(Name, [Option]) -> wxWindow()
           when
           Name   ::   unicode:chardata() ,
           Option ::  {parent, wxWindow()}.
           
findWindowByName(Name, Options)
           when
           is_list(Name),
           is_list(Options) ->

                   Name_UC = unicode:characters_to_binary([Name,0]),
                   MOpts   = fun({parent, #wx_ref{type=ParentT,ref=ParentRef}}, Acc) ->
                                   ?CLASS(ParentT,wxWindow),[<<1:32/?UI,ParentRef:32/?UI>>|Acc];
                                                                         (BadOpt, _) ->
                             erlang:error({badoption, BadOpt})
                             end,
      BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                           wxe_util:call(?wxWindow_FindWindowByName,
                      <<(byte_size(Name_UC)):32/?UI,(Name_UC)/binary,
             0:(((8- ((4+byte_size(Name_UC)) band 16#7)) band 16#7))/unit:8, BinOpt/binary>>).






           %·%% FIND WINDOW BY LABEL %%·%

%%   
%% See below...
%% @equiv findWindowByLabel(Label, [])
          -spec findWindowByLabel(Label)           -> wxWindow()
           when
           Label :: unicode:chardata().

findWindowByLabel(Label)
           when
           is_list(Label)                          ->   findWindowByLabel(Label, []).


%%    
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec findWindowByLabel(Label, [Option]) -> wxWindow()
           when
           Label   ::   unicode:chardata(),
           Option  ::  {parent, wxWindow()}.

findWindowByLabel(Label, Options)
           when
           is_list(Label),
           is_list(Options) ->

                   Label_UC = unicode:characters_to_binary([Label,0]),
                   MOpts    = fun({parent, #wx_ref{type=ParentT,ref=ParentRef}}, Acc) -> 
                                                 ?CLASS(ParentT,wxWindow),[<<1:32/?UI,ParentRef:32/?UI>>|Acc];
                                 (BadOpt, _)                                          ->
                                           erlang:error({badoption, BadOpt})
                              end,
                    BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                         wxe_util:call(?wxWindow_FindWindowByLabel,
                    <<(byte_size(Label_UC)):32/?UI,(Label_UC)/binary,
                     0:(((8- ((4+byte_size(Label_UC)) band 16#7)) band 16#7))/unit:8, BinOpt/binary>>).























           %·%% GET ACCELERATOR TABLE %%·%

%%   
%%    Gets the accelerator table for this window. See wxAcceleratorTable.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getAcceleratorTable(This) -> wxAcceleratorTable:wxAcceleratorTable()
           when
           This :: wxWindow().
           
getAcceleratorTable(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                      ?CLASS(ThisT,wxWindow),
                                        wxe_util:call(?wxWindow_GetAcceleratorTable,
                                        <<ThisRef:32/?UI>>).


           %·%% SET ACCELERATOR TABLE %%·%

%%   
%%    Sets the accelerator table for this window. See wxAcceleratorTable.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setAcceleratorTable(This, Accel) -> ok
           when
           This  :: wxWindow(),
           Accel :: wxAcceleratorTable:wxAcceleratorTable().

setAcceleratorTable(#wx_ref{type=ThisT,ref=ThisRef},
                    #wx_ref{type=AccelT,ref=AccelRef}) ->
                                                        ?CLASS(ThisT,wxWindow),
                                                        ?CLASS(AccelT,wxAcceleratorTable),
                                          wxe_util:cast(?wxWindow_SetAcceleratorTable,
                                          <<ThisRef:32/?UI,AccelRef:32/?UI>>).















           %·%% GET CARET %%·%

%%   
%%    Returns the caret associated with the window.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getCaret(This) -> wxCaret:wxCaret()
           when
           This :: wxWindow().
           
getCaret(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                           ?CLASS(ThisT,wxWindow),
                             wxe_util:call(?wxWindow_GetCaret,
                             <<ThisRef:32/?UI>>).




           %·%% SET CARET %%·%

%%   
%%    Sets the caret associated with the window.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setCaret(This, Caret) -> ok
           when
           This  ::        wxWindow(), 
           Caret :: wxCaret:wxCaret().

setCaret(#wx_ref{type=ThisT,ref=ThisRef},
         #wx_ref{type=CaretT,ref=CaretRef}) ->
                                             ?CLASS(ThisT,wxWindow),
                                             ?CLASS(CaretT,wxCaret),
                               wxe_util:cast(?wxWindow_SetCaret,
                               <<ThisRef:32/?UI,CaretRef:32/?UI>>).











           %·%% GET CLIENT SIZE %%·%

%%   
%%   This gets the size of the window 'client area' in pixels. 
%%   The client area is the area which may be drawn on by the programmer, 
%%   excluding title bar, border, scrollbars, etc.
%%   
%%   W - Receives the client width  in pixels.
%%   H - Receives the client height in pixels.
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getClientSize(This) -> {W :: integer(), H :: integer()}
           when
           This :: wxWindow().
           
getClientSize(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                ?CLASS(ThisT,wxWindow),
                                  wxe_util:call(?wxWindow_GetClientSize,
                                  <<ThisRef:32/?UI>>).






           %·%% SET CLIENT SIZE %%·%

%%   
%%   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 wxWindow::SetSize, 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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setClientSize(This, Size) -> ok
           when
           This ::      wxWindow(),
           Size :: {W :: integer(),  %% The required client area width.
                    H :: integer()}; %% The required client area height.

                             (This, Rect) -> ok
           when
           This :: wxWindow(),
           Rect :: {X :: integer(),
                    Y :: integer(),
                    W :: integer(),
                    H :: integer()}.

setClientSize(#wx_ref{type=ThisT,ref=ThisRef},
                                {SizeW,SizeH})
           when
           is_integer(SizeW),
           is_integer(SizeH) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:cast(?wxWindow_SetClientSize_1_0,
                <<ThisRef:32/?UI,SizeW:32/?UI,SizeH:32/?UI>>);

setClientSize(#wx_ref{type=ThisT,ref=ThisRef},
                    {RectX,RectY,RectW,RectH})
           when
           is_integer(RectX),
           is_integer(RectY),
           is_integer(RectW),
           is_integer(RectH) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:cast(?wxWindow_SetClientSize_1_1,
                <<ThisRef:32/?UI,RectX:32/?UI,RectY:32/?UI,RectW:32/?UI,RectH:32/?UI>>).

%% See Above
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setClientSize(This, Width, Height) -> ok
           when
           This   :: wxWindow(),
           Width  ::  integer(), %% The required client area width.
           Height ::  integer(). %% The required client area height.

setClientSize(#wx_ref{type=ThisT,ref=ThisRef},
                                        Width,
                                       Height)
           when
           is_integer(Width),
           is_integer(Height) ->
                               ?CLASS(ThisT,wxWindow),
                 wxe_util:cast(?wxWindow_SetClientSize_2,
                 <<ThisRef:32/?UI,Width:32/?UI,Height:32/?UI>>).









           %·%% GET CURSOR %%·%

%%   
%%    Return the cursor associated with this window.
%%   
%% Return Value:
%% See Also: wxWindow::SetCursor
%%*%%*%%
          -spec getCursor(This) -> wxCursor:wxCursor()
           when
           This :: wxWindow().
           
getCursor(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                            ?CLASS(ThisT,wxWindow),
                              wxe_util:call(?wxWindow_GetCursor,
                              <<ThisRef:32/?UI>>).


           %·%% SET CURSOR %%·%

%%   
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setCursor(This, Cursor) -> boolean()
           when
           This   ::          wxWindow(),
           Cursor :: wxCursor:wxCursor(). %% Specifies the cursor that the window should normally display.

setCursor(#wx_ref{type=ThisT,ref=ThisRef},
          #wx_ref{type=CursorT,ref=CursorRef}) ->
                                                ?CLASS(ThisT,wxWindow),
                                                ?CLASS(CursorT,wxCursor),
                                  wxe_util:call(?wxWindow_SetCursor,
                                  <<ThisRef:32/?UI,CursorRef:32/?UI>>).









           %·%% GET DROP TARGET %%·%

%%   
%%   Returns the associated drop target, which may be NULL.
%%   
%% Return Value:
%% See Also: wxWindow::SetDropTarget, Drag and drop overview 
%%*%%*%%
          -spec getDropTarget(This) -> wx:wx_object()
           when
           This :: wxWindow().
           
getDropTarget(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                ?CLASS(ThisT,wxWindow),
                                  wxe_util:call(?wxWindow_GetDropTarget,
                                  <<ThisRef:32/?UI>>).





           %·%% SET DROP TARGET %%·%

%%   
%%   Associates a drop target with this window.
%%
%%   If the window already has a drop target, it is deleted.
%%   
%% Return Value:
%% See Also: wxWindow::GetDropTarget, Drag and drop overview
%%*%%*%%
          -spec setDropTarget(This, DropTarget) -> ok
           when
           This       ::     wxWindow(),
           DropTarget :: wx:wx_object().

setDropTarget(#wx_ref{type=ThisT,ref=ThisRef},
              #wx_ref{type=DropTargetT,ref=DropTargetRef}) ->
                                                            ?CLASS(ThisT,wxWindow),
                                                            ?CLASS(DropTargetT,wxDropTarget),
                                              wxe_util:cast(?wxWindow_SetDropTarget,
                                              <<ThisRef:32/?UI,DropTargetRef:32/?UI>>).














           %·%% GET EXTRA STYLE %%·%

%%   
%%    Returns the extra style bits for the window.
%%   
%%    See below for details. 
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getExtraStyle(This) -> integer()
           when
           This :: wxWindow().
           
getExtraStyle(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                ?CLASS(ThisT,wxWindow),
                                  wxe_util:call(?wxWindow_GetExtraStyle,
                                  <<ThisRef:32/?UI>>).






           %·%% SET EXTRA STYLE %%·%

%%   
%%   Sets the extra style bits for the window. 
%%   The currently defined extra style bits are:
%%   
%%   wxWS_EX_VALIDATE_RECURSIVELY   TransferDataTo/FromWindow() and Validate() 
%%                                  methods will recursively descend into all 
%%                                  children of the window if it has 
%%                                  this style flag set.
%%                                 
%%           wxWS_EX_BLOCK_EVENTS   Normally, the command events are propagated 
%%                                  upwards to the window parent recursively 
%%                                  until a handler for them is found.
%%                                  Using this style:
%%                                  allows to prevent them from being propagated 
%%                                  beyond this window. Notice that wxDialog 
%%                                  has this style on by default for the reasons
%%                                  explained in the event processing overview.
%%                                  
%%              wxWS_EX_TRANSIENT   This can be used to prevent a window from 
%%                                  being used as an implicit parent for the 
%%                                  dialogs which were created without a parent. 
%%                                  It is useful for the windows which can 
%%                                  disappear at any moment as creating children 
%%                                  of such windows results in fatal problems.
%%                                  
%%            wxWS_EX_CONTEXTHELP   Under Windows, puts a query button on the 
%%                                  caption. When pressed, Windows will go into
%%                                  a context-sensitive help mode and wxWidgets 
%%                                  will send a wxEVT_HELP event if the user 
%%                                  clicked on an application window. 
%%                                  This style cannot be used together 
%%                                  with wxMAXIMIZE_BOX or wxMINIMIZE_BOX,
%%                                  so these two styles are automatically 
%%                                  turned of if this one is used.
%%                                  
%%           wxWS_EX_PROCESS_IDLE   This window should always process idle 
%%                                  events, even if the mode set by 
%%                                  wxIdleEvent::SetMode is 
%%                                                wxIDLE_PROCESS_SPECIFIED.
%%                                  
%%     wxWS_EX_PROCESS_UI_UPDATES   This window should always process UI 
%%                                  update events, even if the mode 
%%                                  set by wxUpdateUIEvent::SetMode 
%%                                  is wxUPDATE_UI_PROCESS_SPECIFIED. 
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setExtraStyle(This, ExStyle) -> ok
           when
           This    :: wxWindow(),
           ExStyle ::  integer().

setExtraStyle(#wx_ref{type=ThisT,ref=ThisRef},ExStyle)
           when
           is_integer(ExStyle) ->
                                ?CLASS(ThisT,wxWindow),
                  wxe_util:cast(?wxWindow_SetExtraStyle,
                  <<ThisRef:32/?UI,ExStyle:32/?UI>>).






           %·%% GET FONT %%·%

%%   
%%    Returns the font for this window.
%%   
%% Return Value:
%% See Also: wxWindow::SetFont
%%*%%*%%
          -spec getFont(This) -> wxFont:wxFont()
           when
           This :: wxWindow().
           
getFont(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                          ?CLASS(ThisT,wxWindow),
                            wxe_util:call(?wxWindow_GetFont,
                            <<ThisRef:32/?UI>>).







           %·%% SET FONT %%·%

%%   
%%   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 instead in this case and see InheritAttributes 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() too. 
%%   However this font is used by any standard controls for drawing their text 
%%   as well as by wxWindow::GetTextExtent().
%%   
%% Return Value:
%% See Also:  wxWindow::GetFont, InheritAttributes
%%*%%*%%
          -spec setFont(This, Font) -> boolean()
           when
           This ::      wxWindow(),
           Font :: wxFont:wxFont(). %% 
                %% Font to associate with this window, 
                %% pass wxNullFont to reset to the default font.

setFont(#wx_ref{type=ThisT,ref=ThisRef},
        #wx_ref{type=FontT,ref=FontRef}) ->
                                          ?CLASS(ThisT,wxWindow),
                                          ?CLASS(FontT,wxFont),
                            wxe_util:call(?wxWindow_SetFont,
                            <<ThisRef:32/?UI,FontRef:32/?UI>>).




           %·%% SET OWN FONT %%·%

%%   
%%   Sets the font of the window but prevents it from being inherited 
%%   by the children of this window.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setOwnFont(This, Font) -> ok
           when
           This ::      wxWindow(),
           Font :: wxFont:wxFont().

setOwnFont(#wx_ref{type=ThisT,ref=ThisRef},
           #wx_ref{type=FontT,ref=FontRef}) ->
                                             ?CLASS(ThisT,wxWindow),
                                             ?CLASS(FontT,wxFont),
                               wxe_util:cast(?wxWindow_SetOwnFont,
                               <<ThisRef:32/?UI,FontRef:32/?UI>>).














           %·%% GET HELP TEXT %%·%

%%   
%%    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 implementation,
%%   and not in the window object itself.
%%   
%% Return Value:
%% See Also: SetHelpText, GetHelpTextAtPoint, wxHelpProvider
%%*%%*%%
          -spec getHelpText(This) -> unicode:charlist()
           when
           This :: wxWindow().
           
getHelpText(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                              ?CLASS(ThisT,wxWindow),
                                wxe_util:call(?wxWindow_GetHelpText,
                                <<ThisRef:32/?UI>>).






           %·%% SET HELP TEXT %%·%

%%   
%%   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 
%%   implementation, and not in the window object itself.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setHelpText(This, Text) -> ok
           when
           This ::         wxWindow(),
           Text :: unicode:chardata().

setHelpText(#wx_ref{type=ThisT,ref=ThisRef},Text)
           when
           is_list(Text)  ->
                           ?CLASS(ThisT,wxWindow),
                   Text_UC = unicode:characters_to_binary([Text,0]),
                            wxe_util:cast(?wxWindow_SetHelpText,
                   <<ThisRef:32/?UI,(byte_size(Text_UC)):32/?UI,(Text_UC)/binary,
                         0:(((8- ((0+byte_size(Text_UC)) band 16#7)) band 16#7))/unit:8>>).
















           %·%% GET ID %%·%

%%   
%%   Returns the identifier of the window.
%%   
%%   Each window has an integer identifier. 
%%   If the application has not provided one 
%%   (or the default wxID_ANY) an unique identifier with a 
%%   negative value will be generated.
%%   
%% Return Value:
%% See Also: wxWindow::SetId, Window identifiers
%%*%%*%%
          -spec getId(This) -> integer()
           when
           This :: wxWindow().
           
getId(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                        ?CLASS(ThisT,wxWindow),
                          wxe_util:call(?wxWindow_GetId,
                          <<ThisRef:32/?UI>>).




           %·%% SET ID %%·%

%%   
%%   Sets the identifier of the window.
%%
%%   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.
%%   
%% Return Value:
%% See Also: wxWindow::GetId, Window identifiers
%%*%%*%%
          -spec setId(This, Winid) -> ok
           when
           This  :: wxWindow(),
           Winid ::  integer().

setId(#wx_ref{type=ThisT,ref=ThisRef},
                               Winid)
           when
           is_integer(Winid) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:cast(?wxWindow_SetId,
                <<ThisRef:32/?UI,Winid:32/?UI>>).








           %·%% GET LABEL %%·%

%%   
%%    Generic way of getting a label from any window, for identification purposes.
%%   
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getLabel(This) -> unicode:charlist()
           when
           This :: wxWindow().
           
getLabel(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                           ?CLASS(ThisT,wxWindow),
                             wxe_util:call(?wxWindow_GetLabel,
                            <<ThisRef:32/?UI>>).


           %·%% SET LABEL %%·%

%%   
%%    Sets the window's label.
%%   
%% Return Value:
%% See Also: wxWindow::GetLabel
%%*%%*%%
          -spec setLabel(This, Label) -> ok
           when
           This  ::         wxWindow(),
           Label :: unicode:chardata(). %% The window label.

setLabel(#wx_ref{type=ThisT,ref=ThisRef},Label)
           when
           is_list(Label)  ->
                            ?CLASS(ThisT,wxWindow),
                   Label_UC = unicode:characters_to_binary([Label,0]),
                             wxe_util:cast(?wxWindow_SetLabel,
                    <<ThisRef:32/?UI,(byte_size(Label_UC)):32/?UI,(Label_UC)/binary,
                          0:(((8- ((0+byte_size(Label_UC)) band 16#7)) band 16#7))/unit:8>>).











           %·%% GET MAX SIZE %%·%

%%   
%%   Returns the maximum size of the window, an indication to the sizer 
%%   layout mechanism that this is the maximum possible size. 
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getMaxSize(This) -> {W :: integer(), H :: integer()}
           when
           This :: wxWindow().
           
getMaxSize(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                             ?CLASS(ThisT,wxWindow),
                               wxe_util:call(?wxWindow_GetMaxSize,
                               <<ThisRef:32/?UI>>).

           %·%% SET MAX SIZE %%·%

%%   
%%   Sets the maximum size of the window, 
%%   to indicate to the sizer layout mechanism 
%%   that this is the maximum possible size.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setMaxSize(This, MaxSize) -> ok
           when
           This    ::      wxWindow(),
           MaxSize :: {W :: integer(),
                       H :: integer()}.

setMaxSize(#wx_ref{type=ThisT,ref=ThisRef},
                       {MaxSizeW,MaxSizeH})
           when
           is_integer(MaxSizeW),
           is_integer(MaxSizeH) ->
                                 ?CLASS(ThisT,wxWindow),
                   wxe_util:cast(?wxWindow_SetMaxSize,
                   <<ThisRef:32/?UI,MaxSizeW:32/?UI,MaxSizeH:32/?UI>>).






           %·%% GET MIN SIZE %%·%

%%   
%%   Returns the minimum size of the window, an indication to the sizer 
%%   layout mechanism that this is the minimum required size. 
%%   It normally just returns the value set by SetMinSize, 
%%   but it can be overridden to do the calculation on demand.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getMinSize(This) -> {W :: integer(), H :: integer()}
           when
           This :: wxWindow().
           
getMinSize(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                             ?CLASS(ThisT,wxWindow),
                               wxe_util:call(?wxWindow_GetMinSize,
                               <<ThisRef:32/?UI>>).





           %·%% SET MIN SIZE %%·%

%%   
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setMinSize(This, MinSize) -> ok
           when
           This     ::      wxWindow(),
            MinSize :: {W :: integer(),
                        H :: integer()}.
setMinSize(#wx_ref{type=ThisT,ref=ThisRef},{MinSizeW,MinSizeH})
           when
           is_integer(MinSizeW),
           is_integer(MinSizeH) ->
                                 ?CLASS(ThisT,wxWindow),
                   wxe_util:cast(?wxWindow_SetMinSize,
                   <<ThisRef:32/?UI,MinSizeW:32/?UI,MinSizeH:32/?UI>>).







           %·%% GET NAME %%·%

%%   
%%    Returns the window's name.
%%   
%%   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 wxWindow::SetName.
%%   
%% Return Value:
%% See Also: wxWindow::SetName
%%*%%*%%
          -spec getName(This) -> unicode:charlist()
           when
           This :: wxWindow().
           
getName(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                          ?CLASS(ThisT,wxWindow),
                            wxe_util:call(?wxWindow_GetName,
                            <<ThisRef:32/?UI>>).





           %·%% SET NAME %%·%

%%   
%%    Sets the window's name.
%%   
%% Return Value:
%% See Also: wxWindow::GetName
%%*%%*%%
          -spec setName(This, Name) -> ok
           when
           This ::         wxWindow(), 
           Name :: unicode:chardata(). %% A name to set for the window.

setName(#wx_ref{type=ThisT,ref=ThisRef},Name)
           when
           is_list(Name)  ->
                           ?CLASS(ThisT,wxWindow),
                   Name_UC = unicode:characters_to_binary([Name,0]),
                            wxe_util:cast(?wxWindow_SetName,
                   <<ThisRef:32/?UI,(byte_size(Name_UC)):32/?UI,(Name_UC)/binary,
                         0:(((8- ((0+byte_size(Name_UC)) band 16#7)) band 16#7))/unit:8>>).













           %·%% HAS SCROLLBAR %%·%

%%   
%%    Returns true if this window has a scroll bar for this orientation.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec hasScrollbar(This, Orient) -> boolean()
           when
           This  :: wxWindow(),
          Orient ::  integer(). %% Orientation to check, either wxHORIZONTAL or wxVERTICAL.
hasScrollbar(#wx_ref{type=ThisT,ref=ThisRef},
                                     Orient)
           when
           is_integer(Orient) ->
                               ?CLASS(ThisT,wxWindow),
                 wxe_util:call(?wxWindow_HasScrollbar,
                 <<ThisRef:32/?UI,Orient:32/?UI>>).






           %·%% GET SCROLL RANGE %%·%

%%   
%%    Returns the built-in scrollbar range.
%%   
%% Return Value:
%% See Also: wxWindow::SetScrollbar
%%*%%*%%
          -spec getScrollRange(This, Orient) -> integer()
           when
           This   :: wxWindow(),
           Orient ::  integer().
getScrollRange(#wx_ref{type=ThisT,ref=ThisRef},
                                      Orient )
           when
           is_integer(Orient) ->
                               ?CLASS(ThisT,wxWindow),
                 wxe_util:call(?wxWindow_GetScrollRange,
                 <<ThisRef:32/?UI,Orient:32/?UI>>).




           %·%% GET SCROLL THUMB %%·%

%%   
%%    Returns the built-in scrollbar thumb size.
%%   
%% Return Value:
%% See Also: wxWindow::SetScrollbar
%%*%%*%%
          -spec getScrollThumb(This, Orient) -> integer()
           when
           This  :: wxWindow(),
          Orient ::  integer().
getScrollThumb(#wx_ref{type=ThisT,ref=ThisRef},
                                       Orient)
           when
           is_integer(Orient) ->
                               ?CLASS(ThisT,wxWindow),
                 wxe_util:call(?wxWindow_GetScrollThumb,
                 <<ThisRef:32/?UI,Orient:32/?UI>>).








           %·%% GET SCROLL POS %%·%

%%   
%%    Returns the built-in scrollbar position.
%%   
%% Return Value:
%% See Also: See wxWindow::SetScrollbar
%%*%%*%%
          -spec getScrollPos(This, Orient) -> integer()
           when
           This   :: wxWindow(),
           Orient ::  integer().

getScrollPos(#wx_ref{type=ThisT,ref=ThisRef},
                                    Orient)
           when
           is_integer(Orient) ->
                               ?CLASS(ThisT,wxWindow),
                 wxe_util:call(?wxWindow_GetScrollPos,
                 <<ThisRef:32/?UI,Orient:32/?UI>>).








           %·%% SET SCROLL POS %%·%

%%   
%% See below...
%% @equiv setScrollPos(This,Orient,Pos, [])
          -spec setScrollPos(This, Orient, Pos) ->  ok
           when
           This   :: wxWindow(),
           Orient ::  integer(),
           Pos    ::  integer().

setScrollPos(This,Orient,Pos)
           when
           is_record(This, wx_ref),
           is_integer(Orient),
           is_integer(Pos)                      ->  setScrollPos(This,Orient,Pos, []).


%%    
%%   Sets the position of one of the built-in scrollbars.
%%
%%   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.
%%
%% Return Value:
%% See Also: wxWindow::SetScrollbar, wxWindow::GetScrollPos, wxWindow::GetScrollThumb, wxScrollBar, wxScrolledWindow
%%*%%*%%
          -spec setScrollPos(This, Orient, Pos, [Option]) -> ok
           when
           This   ::           wxWindow(),
           Orient ::            integer(),  %% Determines the scrollbar whose position is to be set. 
                                            %% May be wxHORIZONTAL or wxVERTICAL.
           Pos    ::            integer(),  %% Position in scroll units.
           Option ::  {refresh, boolean()}. %% true to redraw the scrollbar, false otherwise.

setScrollPos(#wx_ref{type=ThisT,ref=ThisRef},
                                     Orient,
                                        Pos, 
                                    Options)
           when
           is_integer(Orient),
           is_integer(Pos),
           is_list(Options) ->
                            ?CLASS(ThisT,wxWindow),
                   MOpts  = fun({refresh, Refresh}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(Refresh)):32/?UI>>|Acc];
                                             (BadOpt, _) -> erlang:error({badoption, BadOpt})
                            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_SetScrollPos,
                                        <<ThisRef:32/?UI,Orient:32/?UI,Pos:32/?UI, 0:32,BinOpt/binary>>).









           %·%% SET SCROLLBAR %%·%

%%   
%% See below...
%% @equiv setScrollbar(This,Orient,Pos,ThumbVisible,Range, [])
          -spec setScrollbar(This, Orient, Pos, ThumbVisible, Range) -> ok
           when
           This         :: wxWindow(),
           Orient       ::  integer(),
           Pos          ::  integer(),
           ThumbVisible ::  integer(),
           Range        ::  integer().

setScrollbar(This,Orient,Pos,ThumbVisible,Range)
           when
           is_record(This, wx_ref),
           is_integer(Orient),
           is_integer(Pos),
           is_integer(ThumbVisible),
           is_integer(Range)          ->  setScrollbar(This,Orient,Pos,ThumbVisible,Range, []).

%%   
%%   Sets the scrollbar properties of a built-in scrollbar.
%%   
%%   Parameters
%%   
%%         orientation
%%                 Determines the scrollbar whose page size is to be set. May be wxHORIZONTAL or wxVERTICAL.
%%         position
%%                 The position of the scrollbar in scroll units.
%%         thumbSize
%%                 The size of the thumb, or visible portion of the scrollbar, in scroll units.
%%         range
%%                 The maximum position of the scrollbar.
%%         refresh
%%                 true to redraw the scrollbar, false otherwise.
%%  
%%   
%%   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:
%%           SetScrollbar(wxVERTICAL, 0, 16, 50);
%%   
%%   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.
%% 
%% Return Value:
%% See Also: Scrolling overview, wxScrollBar, wxScrolledWindow, wxScrollWinEvent
%%*%%*%%
          -spec setScrollbar(This, Orient, Pos, ThumbVisible, Range, [Option]) -> ok
           when
           This         ::           wxWindow(),
           Orient       ::            integer(),
           Pos          ::            integer(),
           ThumbVisible ::            integer(),
           Range        ::            integer(),
           Option       ::  {refresh, boolean()}.

setScrollbar(#wx_ref{type=ThisT,ref=ThisRef},Orient,Pos,ThumbVisible,Range, Options)
           when
           is_integer(Orient),
           is_integer(Pos),
           is_integer(ThumbVisible),
           is_integer(Range),
           is_list(Options)      ->
                                  ?CLASS(ThisT,wxWindow),
                       MOpts  = fun({refresh, Refresh}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(Refresh)):32/?UI>>|Acc];
                                                 (BadOpt, _) -> erlang:error({badoption, BadOpt})
                                end,
                       BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                            wxe_util:cast(?wxWindow_SetScrollbar,
                                            <<ThisRef:32/?UI,Orient:32/?UI,Pos:32/?UI,ThumbVisible:32/?UI,Range:32/?UI, 0:32,BinOpt/binary>>).











           %·%% SCROLL LINES %%·%

%%   
%%    Scrolls the window by the given number of lines down (if lines is positive) or up.
%%   
%%    This function is currently only implemented under MSW and wxTextCtrl 
%%    under wxGTK (it also works for wxScrolledWindow derived classes under all platforms).
%%
%% Return Value:  Returns true  if the window was scrolled, 
%%                        false if it was already on top/bottom and nothing was done.
%% See Also:  ScrollPages
%%*%%*%%
          -spec scrollLines(This, Lines) -> boolean()
           when
           This :: wxWindow(),
           Lines :: integer().

scrollLines(#wx_ref{type=ThisT,ref=ThisRef},
                                     Lines)
           when
           is_integer(Lines) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:call(?wxWindow_ScrollLines,
                <<ThisRef:32/?UI,Lines:32/?UI>>).







           %·%% LINE DOWN %%·%

%%   
%%    This is just a wrapper for ScrollLines(1).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec lineDown(This) -> boolean()
           when
           This :: wxWindow().
           
lineDown(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                           ?CLASS(ThisT,wxWindow),
                             wxe_util:call(?wxWindow_LineDown,
                             <<ThisRef:32/?UI>>).






           %·%% LINE UP %%·%

%%   
%%    This is just a wrapper for ScrollLines(-1).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec lineUp(This) -> boolean()
           when
           This :: wxWindow().
           
lineUp(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                         ?CLASS(ThisT,wxWindow),
                           wxe_util:call(?wxWindow_LineUp,
                           <<ThisRef:32/?UI>>).














           %·%% SCROLL PAGES %%·%

%%   
%%   Scrolls the window by the given number of pages down (if pages is positive) or up.
%%   
%%    This function is currently only implemented under MSW and wxGTK.
%%
%% Return Value:  Returns true  if the window was scrolled, 
%%                        false if it was already on top/bottom and nothing was done.
%% See Also:
%%*%%*%%
          -spec scrollPages(This, Pages) -> boolean()
           when
           This :: wxWindow(),
           Pages :: integer().

scrollPages(#wx_ref{type=ThisT,ref=ThisRef},Pages)
           when
           is_integer(Pages) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:call(?wxWindow_ScrollPages,
                <<ThisRef:32/?UI,Pages:32/?UI>>).






           %·%% PAGE DOWN %%·%

%%   
%%    This is just a wrapper for ScrollPages()(1).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec pageDown(This) -> boolean()
           when
           This :: wxWindow().
           
pageDown(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                           ?CLASS(ThisT,wxWindow),
                             wxe_util:call(?wxWindow_PageDown,
                             <<ThisRef:32/?UI>>).




           %·%% PAGE UP %%·%

%%   
%%    This is just a wrapper for ScrollPages()(-1).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec pageUp(This) -> boolean()
           when
           This :: wxWindow().
           
pageUp(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                         ?CLASS(ThisT,wxWindow),
                           wxe_util:call(?wxWindow_PageUp,
                           <<ThisRef:32/?UI>>).











           %·%% SCROLL WINDOW %%·%

%%   
%% See below...
%% @equiv scrollWindow(This,Dx,Dy, [])
          -spec scrollWindow(This, Dx, Dy) ->  ok
           when
           This :: wxWindow(),
           Dx   :: integer(),
           Dy   :: integer().

scrollWindow(This,Dx,Dy)
           when
           is_record(This, wx_ref),
           is_integer(Dx),
           is_integer(Dy)                  ->  scrollWindow(This,Dx,Dy, []).

%%    
%%    Physically scrolls the pixels in the window and move child windows accordingly.
%%
%%
%%    Note: that you can often USE wxScrolledWindow INSTEAD
%%          of using this function directly.
%%
%%
%%    dx - Amount to scroll horizontally.
%%    dy - Amount to scroll vertically.
%%    rect - Rectangle to scroll, if it is NULL, the whole window 
%%           is scrolled (this is always the case under wxGTK which doesn't
%%           support this parameter)
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec scrollWindow(This, Dx, Dy, [Option]) -> ok
           when
           This   ::              wxWindow(),
           Dx     ::               integer(),
           Dy     ::               integer(),
           Option ::  {rect, {X :: integer(),
                              Y :: integer(),
                              W :: integer(),
                              H :: integer()}}.

scrollWindow(#wx_ref{type=ThisT,ref=ThisRef},Dx,Dy, Options)
           when
           is_integer(Dx),
           is_integer(Dy),
           is_list(Options)  ->
                              ?CLASS(ThisT,wxWindow),
                   MOpts  = fun({rect, {RectX,RectY,RectW,RectH}}, Acc) -> [<<1:32/?UI,RectX:32/?UI,RectY:32/?UI,RectW:32/?UI,RectH:32/?UI,0:32>>|Acc];
                                                            (BadOpt, _) -> erlang:error({badoption, BadOpt})
                            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_ScrollWindow,
                                        <<ThisRef:32/?UI,Dx:32/?UI,Dy:32/?UI, 0:32,BinOpt/binary>>).






           %·%% GET SIZE %%·%

%%   
%%    This gets the size of the entire window in pixels, 
%%    including title bar, border, scrollbars, etc.
%%   
%%    width
%%        Receives the window width.
%%    height
%%        Receives the window height.
%%
%% Return Value:
%% See Also:  GetClientSize, GetVirtualSize
%%*%%*%%
          -spec getSize(This) -> {W :: integer(), H :: integer()}
           when
           This :: wxWindow().
           
getSize(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                          ?CLASS(ThisT,wxWindow),
                            wxe_util:call(?wxWindow_GetSize,
                            <<ThisRef:32/?UI>>).






           %·%% SET SIZE %%·%

%%   
%%    Sets the size and position of the window in pixels.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setSize(This, Rect) -> ok
           when
           This :: wxWindow(),
           Rect :: {X :: integer(),
                    Y :: integer(), 
                    W :: integer(), 
                    H :: integer()};

                       (This, Size) -> ok
           when
           This :: wxWindow(),
           Size :: {W :: integer(),
                    H :: integer()}.

setSize(This,Rect={RectX,RectY,RectW,RectH})
           when
           is_record(This, wx_ref),
           is_integer(RectX),
           is_integer(RectY),
           is_integer(RectW),
           is_integer(RectH)        ->  setSize(This,Rect, []);

setSize(#wx_ref{type=ThisT,ref=ThisRef},
                          {SizeW,SizeH})
           when
           is_integer(SizeW),
           is_integer(SizeH)        ->
                                     ?CLASS(ThisT,wxWindow),
                       wxe_util:cast(?wxWindow_SetSize_1,
                       <<ThisRef:32/?UI,SizeW:32/?UI,SizeH:32/?UI>>).

           %·%% SET SIZE / 3 %%·%

%%   
%%   Sets the size and position of the window in pixels.
%%   
%%   The second form is a convenience for calling the first form with 
%%   default x and y parameters, and must be used with 
%%   non-default width and height values.
%%   
%%   The first form 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.
%%
%%    Parameters
%% 
%%    X          Required x position in pixels, or wxDefaultCoord to indicate that the existing value should be used.
%%    Y          Required y position in pixels, or wxDefaultCoord to indicate that the existing value should be used.
%%    width      Required width in pixels, or wxDefaultCoord to indicate that the existing value should be used.
%%    height     Required height position in pixels, or wxDefaultCoord to indicate that the existing value should be used.
%%    size       wxSize object for setting the size.
%%    rect       wxRect object for setting the position and size.
%%    sizeFlags  Indicates the interpretation of other parameters. It is a bit list of the following:
%%    
%%                 wxSIZE_AUTO_WIDTH: a wxDefaultCoord width value is taken to indicate a wxWidgets-supplied default width.
%%                wxSIZE_AUTO_HEIGHT: a wxDefaultCoord height value is taken to indicate a wxWidgets-supplied default height.
%%                       wxSIZE_AUTO: wxDefaultCoord size values are taken to indicate a wxWidgets-supplied default size.
%%               wxSIZE_USE_EXISTING: existing dimensions should be used if wxDefaultCoord values are supplied.
%%            wxSIZE_ALLOW_MINUS_ONE: allow negative dimensions (ie. value of wxDefaultCoord) to be interpreted 
%%                                    as real dimensions, not default values. 
%%                      wxSIZE_FORCE: normally, if the position and the size of the window are already 
%%                                    the same as the parameters of this function, nothing is done. 
%%                                    but with this flag a window resize may be forced even in this case 
%%                                    (supported in wx 2.6.2 and later and only implemented for MSW and 
%%                                    ignored elsewhere currently) 
%%   
%% Return Value:
%% See Also:
%%*%%*%%
%% 
          -spec setSize(This, Width, Height) -> ok
           when
           This   :: wxWindow(),
           Width  ::  integer(),
           Height ::  integer();

          (This, Rect, [Option]) -> ok
           when
           This   ::             wxWindow(),
           Rect   :: {X  ::       integer(),
                      Y  ::       integer(),
                      W  ::       integer(),
                      H  ::       integer()},
           Option ::  {sizeFlags, integer()}.

setSize(#wx_ref{type=ThisT,ref=ThisRef},Width,Height)
           when
           is_integer(Width),
           is_integer(Height) ->
                               ?CLASS(ThisT,wxWindow),
                 wxe_util:cast(?wxWindow_SetSize_2_0,
                 <<ThisRef:32/?UI,Width:32/?UI,Height:32/?UI>>);

setSize(#wx_ref{type=ThisT,ref=ThisRef},
              {RectX,RectY,RectW,RectH},
                               Options)
           when
           is_integer(RectX),
           is_integer(RectY),
           is_integer(RectW),
           is_integer(RectH),
           is_list(Options)   ->
                               ?CLASS(ThisT,wxWindow),
                   MOpts  =  fun({sizeFlags, SizeFlags}, Acc) -> [<<1:32/?UI,SizeFlags:32/?UI>>|Acc];
                                                  (BadOpt, _) -> erlang:error({badoption, BadOpt})
                             end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_SetSize_2_1,
                                        <<ThisRef:32/?UI,RectX:32/?UI,RectY:32/?UI,RectW:32/?UI,RectH:32/?UI, 0:32,BinOpt/binary>>).

           %·%% SET SIZE / 5 %%·%

%% /\  
%% See above...
%% @equiv setSize(This,X,Y,Width,Height, [])
          -spec setSize(This, X, Y, Width, Height) -> ok
           when
           This :: wxWindow(),
              X :: integer(),
              Y :: integer(),
          Width :: integer(),
         Height :: integer().

setSize(This,X,Y,Width,Height)
           when
           is_record(This, wx_ref),
           is_integer(X),
           is_integer(Y),
           is_integer(Width),
           is_integer(Height) -> setSize(This,X,Y,Width,Height, []).

%% /\   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setSize(This, X, Y, Width, Height, [Option]) -> ok
           when
           This :: wxWindow(), 
              X :: integer(), 
              Y :: integer(),
          Width :: integer(), 
         Height :: integer(),
         Option :: {sizeFlags, integer()}.

setSize(#wx_ref{type=ThisT,ref=ThisRef},X,Y,Width,Height, Options)
           when
           is_integer(X),
           is_integer(Y),
           is_integer(Width),
           is_integer(Height),
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   MOpts  = fun({sizeFlags, SizeFlags}, Acc) -> [<<1:32/?UI,SizeFlags:32/?UI>>|Acc];
                                                 (BadOpt, _) -> erlang:error({badoption, BadOpt})
                            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_SetSize_5,
                                        <<ThisRef:32/?UI,X:32/?UI,Y:32/?UI,Width:32/?UI,Height:32/?UI, 0:32,BinOpt/binary>>).










           %·%% SET SIZE HINTS %%·%

%%   
%% See below...
%% @equiv setSizeHints(This,MinSize, [])
          -spec setSizeHints(This, MinSize) ->  ok
           when
           This :: wxWindow(),
           MinSize :: {W :: integer(),
                       H :: integer()}.

setSizeHints(This,MinSize={MinSizeW,MinSizeH})
           when
           is_record(This, wx_ref),
           is_integer(MinSizeW),
           is_integer(MinSizeH)             ->  setSizeHints(This,MinSize, []).


%%    
%%   Use of this function for windows which are not toplevel windows 
%%   (such as wxDialog or wxFrame) is discouraged. Please use SetMinSize 
%%   and SetMaxSize instead.
%%
%% Return Value:
%% See Also:  wxTopLevelWindow::SetSizeHints.
%%*%%*%%
          -spec setSizeHints(This, MinW, MinH)        -> ok
           when
           This :: wxWindow(), 
           MinW :: integer(), 
           MinH :: integer();

                            (This, MinSize, [Option]) -> ok 
           when
           This     ::      wxWindow(), 
           MinSize  :: {W :: integer(), 
                        H :: integer()},
           Option   :: {maxSize, {W :: integer(), H :: integer()}}
                     | {incSize, {W :: integer(), H :: integer()}}.

setSizeHints(This,MinW,MinH)
           when
           is_record(This, wx_ref),
           is_integer(MinW),
           is_integer(MinH) ->
  setSizeHints(This,MinW,MinH, []);

setSizeHints(#wx_ref{type=ThisT,ref=ThisRef}, {MinSizeW, MinSizeH}, Options)
           when
           is_integer(MinSizeW),
           is_integer(MinSizeH),
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                      MOpts =  fun({maxSize, {MaxSizeW,MaxSizeH}}, Acc) -> [<<1:32/?UI,MaxSizeW:32/?UI,MaxSizeH:32/?UI,0:32>>|Acc];
                                  ({incSize, {IncSizeW,IncSizeH}}, Acc) -> [<<2:32/?UI,IncSizeW:32/?UI,IncSizeH:32/?UI,0:32>>|Acc];
                                                            (BadOpt, _) -> erlang:error({badoption, BadOpt}) 
                               end,
                      BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                           wxe_util:cast(?wxWindow_SetSizeHints_2,
                                           <<ThisRef:32/?UI,MinSizeW:32/?UI,MinSizeH:32/?UI, 0:32,BinOpt/binary>>).

           %·%% SET SIZE HINTS %%·%

%%   
%%   
%% See above.
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setSizeHints(This, MinW, MinH, [Option]) -> ok
           when
           This     :: wxWindow(), 
           MinW     ::  integer(), 
           MinH     ::  integer(),
           Option   :: {maxW, integer()}
                     | {maxH, integer()}
                     | {incW, integer()}
                     | {incH, integer()}.

setSizeHints(#wx_ref{type=ThisT,ref=ThisRef}, MinW, MinH, Options)
           when
           is_integer(MinW),
           is_integer(MinH),
           is_list(Options) ->
                              ?CLASS(ThisT,wxWindow),
                        MOpts = fun({maxW, MaxW}, Acc) -> [<<1:32/?UI,MaxW:32/?UI>>|Acc];
                                   ({maxH, MaxH}, Acc) -> [<<2:32/?UI,MaxH:32/?UI>>|Acc];
                                   ({incW, IncW}, Acc) -> [<<3:32/?UI,IncW:32/?UI>>|Acc];
                                   ({incH, IncH}, Acc) -> [<<4:32/?UI,IncH:32/?UI>>|Acc];
                                           (BadOpt, _) -> erlang:error({badoption, BadOpt})
                                end,
                       BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                            wxe_util:cast(?wxWindow_SetSizeHints_3,
                                            <<ThisRef:32/?UI,MinW:32/?UI,MinH:32/?UI, 0:32,BinOpt/binary>>).









           %·%% SET SIZER AND FIT %%·%

%%   
%% See below...
%% @equiv setSizerAndFit(This,Sizer, [])
          -spec setSizerAndFit(This, Sizer) ->  ok
           when
           This :: wxWindow(), Sizer :: wxSizer:wxSizer().

setSizerAndFit(This,Sizer)
           when
           is_record(This, wx_ref),
           is_record(Sizer, wx_ref)         ->   setSizerAndFit(This,Sizer, []).

%%    
%%    The same as SetSizer, except it also sets the size hints 
%%    for the window based on the sizer's minimum size.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setSizerAndFit(This, Sizer, [Option]) -> ok
           when
           This     ::        wxWindow(), 
           Sizer    :: wxSizer:wxSizer(),
           Option   :: {deleteOld, boolean()}.

setSizerAndFit(#wx_ref{type=ThisT,ref=ThisRef},
               #wx_ref{type=SizerT,ref=SizerRef}, Options)
           when
           is_list(Options) ->
                              ?CLASS(ThisT,wxWindow),
                              ?CLASS(SizerT,wxSizer),
                        MOpts =  fun({deleteOld, DeleteOld}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(DeleteOld)):32/?UI>>|Acc];
                                                      (BadOpt, _) -> erlang:error({badoption, BadOpt})
                                 end,
                       BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                            wxe_util:cast(?wxWindow_SetSizerAndFit,
                                            <<ThisRef:32/?UI,SizerRef:32/?UI, BinOpt/binary>>).





           %·%% GET SIZER %%·%

%%   
%%    Return the sizer associated with the window by a 
%%    previous call to SetSizer() or NULL.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getSizer(This) -> wxSizer:wxSizer()
           when
           This :: wxWindow().
           
getSizer(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                           ?CLASS(ThisT,wxWindow),
                             wxe_util:call(?wxWindow_GetSizer,
                             <<ThisRef:32/?UI>>).






           %·%% SET SIZER / 2 %%·%

%% @equiv setSizer(This,Sizer, [])
          -spec setSizer(This, Sizer) -> ok
           when
           This :: wxWindow(), 
           Sizer :: wxSizer:wxSizer().

setSizer(This,Sizer)
           when
           is_record(This, wx_ref),
           is_record(Sizer, wx_ref)   ->  setSizer(This,Sizer, []).

           %·%% SET SIZER / 3 %%·%
%%   
%%   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 implicitly with 
%%   true parameter if the sizer is non-NULL and false otherwise.
%%   
%%   SetSizer now enables and disables Layout automatically, 
%%   but prior to wxWidgets 2.3.3 the following applied:
%%   You must call wxWindow::SetAutoLayout to tell a window 
%%   to use the sizer automatically in OnSize; otherwise, 
%%   you must override OnSize and call Layout() explicitly. 
%%   When setting both a wxSizer and a wxLayoutConstraints, 
%%   only the sizer will have effect.
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setSizer(This, Sizer, [Option]) -> ok
           when
           This     ::        wxWindow(), 
           Sizer    :: wxSizer:wxSizer(),       %% The sizer to set. 
                                                %% Pass NULL to disassociate and conditionally delete the window's sizer. 
                                                %% See below.
           Option   ::  {deleteOld, boolean()}. %% If true (the default), this will delete any prexisting sizer. 
                                                %% Pass false if you wish to handle deleting the old sizer yourself.

setSizer(#wx_ref{type=ThisT,ref=ThisRef},
         #wx_ref{type=SizerT,ref=SizerRef}, Options)
           when
           is_list(Options) ->
                              ?CLASS(ThisT,wxWindow),
                              ?CLASS(SizerT,wxSizer),
                        MOpts =  fun({deleteOld, DeleteOld}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(DeleteOld)):32/?UI>>|Acc];
                                                      (BadOpt, _) -> erlang:error({badoption, BadOpt})
                                 end,
                       BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                            wxe_util:cast(?wxWindow_SetSizer,
                                            <<ThisRef:32/?UI,SizerRef:32/?UI, BinOpt/binary>>).




           %·%% GET CONTAINING SIZER %%·%

%%   
%%    Return the sizer that this window is a member of, if any, otherwise NULL.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getContainingSizer(This) -> wxSizer:wxSizer()
           when
           This :: wxWindow().
           
getContainingSizer(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                     ?CLASS(ThisT,wxWindow),
                                       wxe_util:call(?wxWindow_GetContainingSizer,
                                       <<ThisRef:32/?UI>>).


           %·%% SET CONTAINING SIZER %%·%

%%   
%%   This normally does not need to be called by user code. 
%%   It is called when a window is added to a sizer, and 
%%   is used so the window can remove itself from the sizer when it is destroyed.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setContainingSizer(This, Sizer) -> ok
           when
           This  ::        wxWindow(),
           Sizer :: wxSizer:wxSizer().

setContainingSizer(#wx_ref{type=ThisT,ref=ThisRef},
                   #wx_ref{type=SizerT,ref=SizerRef}) ->
                                                       ?CLASS(ThisT,wxWindow),
                                                       ?CLASS(SizerT,wxSizer),
                                         wxe_util:cast(?wxWindow_SetContainingSizer,
                                         <<ThisRef:32/?UI,SizerRef:32/?UI>>).





           %·%% LAYOUT %%·%

%%   
%%   Invokes the constraint-based layout algorithm or the sizer-based 
%%   algorithm for this window.
%%
%%   See wxWindow::SetAutoLayout: when auto layout is on, 
%%     this function gets called automatically 
%%     when the window is resized.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec layout(This) -> boolean()
           when
           This :: wxWindow().
           
layout(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                         ?CLASS(ThisT,wxWindow),
                           wxe_util:call(?wxWindow_Layout,
                           <<ThisRef:32/?UI>>).






           %·%% SET AUTO LAYOUT %%·%

%%   
%%   Determines whether the wxWindow::Layout function will be called 
%%   automatically when the window is resized. 
%%   Please note:
%%   that this only happens for the windows usually 
%%   used to contain children, namely wxPanel and wxTopLevelWindow 
%%   (and the classes deriving from them).
%%
%%   This method is called implicitly by wxWindow::SetSizer but if you 
%%   use wxWindow::SetConstraints you should call it manually or otherwise 
%%   the window layout won't be correctly updated when its size changes.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setAutoLayout(This, AutoLayout) -> ok
           when
           This       :: wxWindow(),
           AutoLayout ::  boolean().
                      %% Set this to true if you wish the Layout function to be called 
                      %% automatically when the window is resized.

setAutoLayout(#wx_ref{type=ThisT,ref=ThisRef},AutoLayout)
           when
           is_boolean(AutoLayout) ->
                                   ?CLASS(ThisT,wxWindow),
                     wxe_util:cast(?wxWindow_SetAutoLayout,
                     <<ThisRef:32/?UI,(wxe_util:from_bool(AutoLayout)):32/?UI>>).






















           %·%% GET TOOL TIP %%·%

%%   
%%    Get the associated tooltip or NULL if none.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getToolTip(This) -> wxToolTip:wxToolTip()
           when
           This :: wxWindow().
           
getToolTip(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                            ?CLASS(ThisT,wxWindow),
                              wxe_util:call(?wxWindow_GetToolTip,
                              <<ThisRef:32/?UI>>).




           %·%% SET TOOL TIP %%·%

%%   
%%   Attach a tooltip to the window.
%%   
%% Return Value:
%% See Also: See also: GetToolTip, wxToolTip
%%*%%*%%

          -spec setToolTip(This, Tip) -> ok
           when
           This ::         wxWindow(), 
           Tip  :: unicode:chardata();

                          (This, Tip) -> ok 
           when
           This ::            wxWindow(), 
           Tip  :: wxToolTip:wxToolTip().

setToolTip(#wx_ref{type=ThisT,ref=ThisRef}, Tip)
           when
           is_list(Tip) ->
                          ?CLASS(ThisT,wxWindow),
                   Tip_UC = unicode:characters_to_binary([Tip,0]),
                           wxe_util:cast(?wxWindow_SetToolTip_1_0,
                           <<ThisRef:32/?UI,(byte_size(Tip_UC)):32/?UI,(Tip_UC)/binary, 0:(((8- ((0+byte_size(Tip_UC)) band 16#7)) band 16#7))/unit:8>>);

]setToolTip(#wx_ref{type=ThisT,ref=ThisRef},
            #wx_ref{type=TipT,ref=TipRef}) ->
                                            ?CLASS(ThisT,wxWindow),
                                            ?CLASS(TipT,wxToolTip),
                              wxe_util:cast(?wxWindow_SetToolTip_1_1,
                              <<ThisRef:32/?UI,TipRef:32/?UI>>).












           %·%% SHOW %%·%

%%   
%% See below...
%% @equiv show(This, [])
          -spec show(This)          ->  boolean()
           when
           This :: wxWindow().
           

show(This)
           when
           is_record(This, wx_ref)  ->  show(This, []).

%%    
%%   Shows or hides the window. 
%%   You may need to call Raise for a top level window if you want to bring 
%%   it to top, although this is not needed if Show() is called immediately 
%%   after the frame creation.
%%
%% Return Value:
%% See Also: wxWindow::IsShown, wxWindow::Hide, wxRadioBox::Show
%%*%%*%%
          -spec show(This, [Option]) -> boolean()
           when
           This     ::        wxWindow(),
           Option   ::  {show, boolean()}. %% If true displays the window. Otherwise, hides it.

show(#wx_ref{type=ThisT,ref=ThisRef}, Options)
           when
           is_list(Options)  ->
                              ?CLASS(ThisT,wxWindow),
                   MOpts =  fun({show, Show}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(Show)):32/?UI>>|Acc];
                                       (BadOpt, _) -> erlang:error({badoption, BadOpt}) 
                            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:call(?wxWindow_Show,
                                        <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).





           %·%% IS SHOWN %%·%

%%   
%%    Returns true if the window is shown, false if it has been hidden.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec isShown(This) -> boolean()
           when
           This :: wxWindow().
           
isShown(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                          ?CLASS(ThisT,wxWindow),
                            wxe_util:call(?wxWindow_IsShown,
                            <<ThisRef:32/?UI>>).



           %·%% HIDE %%·%

%%   
%%    Equivalent to calling Show(false).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec hide(This) -> boolean()
           when
           This :: wxWindow().
           
hide(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                       ?CLASS(ThisT,wxWindow),
                         wxe_util:call(?wxWindow_Hide,
                         <<ThisRef:32/?UI>>).















           %·%% GET WINDOW STYLE FLAG %%·%

%%   
%%   Gets the window style that was passed 
%%   to the constructor or Create method. 
%% 
%%   GetWindowStyle() is another name for the same function.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getWindowStyleFlag(This) -> integer()
           when
           This :: wxWindow().
           
getWindowStyleFlag(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                     ?CLASS(ThisT,wxWindow),
                                       wxe_util:call(?wxWindow_GetWindowStyleFlag,
                                       <<ThisRef:32/?UI>>).




           %·%% SET WINDOW STYLE FLAG %%·%

%%   
%%    Sets the style of the window. 
%%    Please note that some styles cannot be changed after 
%%    the window creation and that Refresh() 
%%    might need to be be called after changing the
%%    others for the change to take place immediately.
%%
%%    See WINDOW STYLES, at the top og page, for more information about flags.
%%   
%% Return Value:
%% See Also:  GetWindowStyleFlag
%%*%%*%%
          -spec setWindowStyleFlag(This, Style) -> ok
           when
           This  :: wxWindow(),
           Style ::  integer().

setWindowStyleFlag(#wx_ref{type=ThisT,ref=ThisRef},
                                            Style)
           when
           is_integer(Style) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:cast(?wxWindow_SetWindowStyleFlag,
                <<ThisRef:32/?UI,Style:32/?UI>>).







           %·%% SET WINDOW STYLE %%·%

%%   
%%    Identical to SetWindowStyleFlag.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setWindowStyle(This, Style) -> ok
           when
           This  :: wxWindow(),
           Style ::  integer().

setWindowStyle(#wx_ref{type=ThisT,ref=ThisRef},Style)
           when
           is_integer(Style) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:cast(?wxWindow_SetWindowStyle,
                <<ThisRef:32/?UI,Style:32/?UI>>).













           %·%% GET WINDOW VARIANT %%·%

%%   
%%    Returns the value previously passed to wxWindow::SetWindowVariant.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
%%<br /> Res = ?wxWINDOW_VARIANT_NORMAL 
%%           | ?wxWINDOW_VARIANT_SMALL 
%%           | ?wxWINDOW_VARIANT_MINI 
%%           | ?wxWINDOW_VARIANT_LARGE 
%%           | ?wxWINDOW_VARIANT_MAX

          -spec getWindowVariant(This) -> wx:wx_enum()
           when
           This :: wxWindow().
           
getWindowVariant(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                   ?CLASS(ThisT,wxWindow),
                                     wxe_util:call(?wxWindow_GetWindowVariant,
                                     <<ThisRef:32/?UI>>).







           %·%% SET WINDOW VARIANT %%·%

%%   
%%   This function can be called under all platforms but only does anything 
%%   under Mac OS X 10.3+ currently. Under this system, each of the standard 
%%   control can exist in several sizes which correspond to the elements 
%%   of wxWindowVariant enum:
%%
%%                    enum wxWindowVariant
%%         {
%%             wxWINDOW_VARIANT_NORMAL,    // Normal size
%%             wxWINDOW_VARIANT_SMALL,     // Smaller size (about 25 % smaller than normal )
%%             wxWINDOW_VARIANT_MINI,      // Mini size (about 33 % smaller than normal )
%%             wxWINDOW_VARIANT_LARGE,     // Large size (about 25 % larger than normal )
%%         };
%%
%%   By default the controls use the normal size, of course, but this function can be used to change this.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
%%<br /> Variant = ?wxWINDOW_VARIANT_NORMAL 
%%               | ?wxWINDOW_VARIANT_SMALL 
%%               | ?wxWINDOW_VARIANT_MINI 
%%               | ?wxWINDOW_VARIANT_LARGE 
%%               | ?wxWINDOW_VARIANT_MAX

          -spec setWindowVariant(This, Variant) -> ok
           when
           This    ::   wxWindow(),
           Variant :: wx:wx_enum().

setWindowVariant(#wx_ref{type=ThisT,ref=ThisRef},
                                        Variant)
           when
           is_integer(Variant) ->
                                ?CLASS(ThisT,wxWindow),
                  wxe_util:cast(?wxWindow_SetWindowVariant,
                  <<ThisRef:32/?UI,Variant:32/?UI>>).

























           %·%% MOVE AFTER IN TAB ORDER %%·%

%%   
%%   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() allow to change it after creating 
%%   all the windows.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec moveAfterInTabOrder(This, Win) -> ok
           when
           This :: wxWindow(),
           Win  :: wxWindow(). %%  A sibling of this window which should precede it in tab order, must not be NULL
           
moveAfterInTabOrder(#wx_ref{type=ThisT,ref=ThisRef},
                    #wx_ref{type=WinT,ref=WinRef}) ->
                                                    ?CLASS(ThisT,wxWindow),
                                                    ?CLASS(WinT,wxWindow),
                                      wxe_util:cast(?wxWindow_MoveAfterInTabOrder,
                                      <<ThisRef:32/?UI,WinRef:32/?UI>>).






           %·%% MOVE BEFORE IN TAB ORDER %%·%

%%   
%%    Same as MoveAfterInTabOrder except that it inserts this window just
%%    before win instead of putting it right after it.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec moveBeforeInTabOrder(This, Win) -> ok
           when
           This :: wxWindow(),
           Win  :: wxWindow().
           
moveBeforeInTabOrder(#wx_ref{type=ThisT,ref=ThisRef},
                     #wx_ref{type=WinT,ref=WinRef}) ->
                                                     ?CLASS(ThisT,wxWindow),
                                                     ?CLASS(WinT,wxWindow),
                                       wxe_util:cast(?wxWindow_MoveBeforeInTabOrder,
                                       <<ThisRef:32/?UI,WinRef:32/?UI>>).






           %·%% NAVIGATE / 1 %%·%

%%   
%% See below...
%% @equiv navigate(This, [])  
          -spec navigate(This)     ->  boolean()
           when
           This :: wxWindow().

navigate(This)
           when
           is_record(This, wx_ref) ->  navigate(This, []).


           %·%% NAVIGATE / 2 %%·%
%%   
%%   Does keyboard navigation from this window to another, 
%%   by sending a wxNavigationKeyEvent.
%%       
%%        -#wx{ event = #wxNavigationKey{  type = navigation_key
%%                                        flags = integer(),
%%                                        focus = wxWindow:wxWindow() 
%%                                                                     } },
%%  
%%   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.     
%%                              ctrl+tab traditionally switches doc in AUI
%%    
%% Return Value:
%% See Also:
%%*%%*%%
          -spec navigate(This, [Option]) -> boolean()
           when
           This    ::         wxWindow(),
           Option  ::  {flags, integer()}.
                         %%  flags - A combination of wxNavigationKeyEvent::IsForward 
                         %%                       and wxNavigationKeyEvent::WinChange.
navigate(#wx_ref{type=ThisT,ref=ThisRef},
                      Options)
           when
           is_list(Options)  ->
                              ?CLASS(ThisT,wxWindow),
                   MOpts  = fun({flags, Flags}, Acc) -> [<<1:32/?UI,Flags:32/?UI>>|Acc];
                                         (BadOpt, _) -> erlang:error({badoption, BadOpt})
                            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:call(?wxWindow_Navigate,
                                        <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).









           %·%% MOVE %%·%

%%   
%% See below...
%% @equiv move(This,Pt, [])
          -spec move(This, Pt) ->  ok 
           when
           This ::      wxWindow(),
           Pt   :: {X :: integer(), %% wxPoint object representing the position.
           Y    ::       integer()}.

move(This,Pt={PtX,PtY})
           when
           is_record(This, wx_ref),
           is_integer(PtX),
           is_integer(PtY)     ->   move(This,Pt, []).

%%    
%%    Moves the window to the given position.
%%
%% See below ... 
%% Return Value:
%% See Also:
%%*%%*%%
          -spec move(This, X, Y) -> ok
           when
           This :: wxWindow(),
           X    ::  integer(),
           Y    ::  integer();

          (This, Pt, [Option]) -> ok
           when
           This   ::        wxWindow(),
           Pt     ::   {X :: integer(),
           Y      ::         integer()},
           Option :: {flags, integer()}.

move(This,X,Y)
           when
           is_record(This, wx_ref),
           is_integer(X),
           is_integer(Y) ->    move(This,X,Y, []);

move(#wx_ref{type=ThisT,ref=ThisRef},
            {PtX,PtY},
             Options)
           when
           is_integer(PtX),
           is_integer(PtY),
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   MOpts =  fun({flags, Flags}, Acc) -> [<<1:32/?UI,Flags:32/?UI>>|Acc];
                                         (BadOpt, _) -> erlang:error({badoption, BadOpt}) 
                            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_Move_2,
                                        <<ThisRef:32/?UI,PtX:32/?UI,PtY:32/?UI, 0:32,BinOpt/binary>>).

           %·%% MOVE / 4 %%·%

%%
%%   Moves the window to the given position.
%%   
%%   Implementations of SetSize can also implicitly 
%%   implement the wxWindow::Move function, 
%%   which is defined in the base wxWindow class as the call:
%%
%%          SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);
%%
%%   
%% Return Value:
%% See Also: wxWindow::SetSize
%%*%%*%%
          -spec move(This, X, Y, [Option]) -> ok
           when
           This    ::         wxWindow(),
           X       ::          integer(), %% Required x position.
           Y       ::          integer(), %% Required y position
           Option  ::  {flags, integer()}.

move(#wx_ref{type=ThisT,ref=ThisRef},X,Y, Options)
           when
           is_integer(X),
           is_integer(Y),
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   MOpts = fun({flags, Flags}, Acc) -> [<<1:32/?UI,Flags:32/?UI>>|Acc];
                                        (BadOpt, _) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_Move_3,
                                        <<ThisRef:32/?UI,X:32/?UI,Y:32/?UI, 0:32,BinOpt/binary>>).





















           %·%% INIT DIALOG %%·%

%%   
%%   Sends an wxEVT_INIT_DIALOG event, 
%%   whose handler usually transfers data to the dialog via validators.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec initDialog(This) -> ok
           when
           This :: wxWindow().
           
initDialog(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                             ?CLASS(ThisT,wxWindow),
                               wxe_util:cast(?wxWindow_InitDialog,
                               <<ThisRef:32/?UI>>).





           %·%% UPDATE WINDOW U I %%·%

%%   
%% See below...
%% @equiv updateWindowUI(This, [])
          -spec updateWindowUI(This) ->  ok
           when
           This :: wxWindow().

updateWindowUI(This)
           when
           is_record(This, wx_ref)   ->  updateWindowUI(This, []).

%%    
%%   This function sends wxUpdateUIEvents to the window. 
%%
%%        - #wx{  event =  #wxUpdateUI{ type= update_ui } } ,
%%
%%   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. 
%%
%%   RCNote - It is easier to think of it as a unique type of Idle Event; 
%%            One that is 'commanded'. 
%%            wxUpdateUIEvent inherits from wxCommandEvent. 
%%            Be sure to use the { obj = ObjectVariable } part of the record.          
%%
%%   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 or 
%%        wxUpdateUIEvent::SetUpdateInterval 
%%   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 following values.
%%   
%%      enum wxUpdateUI
%%      {
%%         wxUPDATE_UI_NONE          = 0x0000, // No particular value
%%         wxUPDATE_UI_RECURSE       = 0x0001, // Call the function for descendants
%%         wxUPDATE_UI_FROMIDLE      = 0x0002  // Invoked from On(Internal)Idle
%%       };
%%   
%%   If you are calling this function from an wxOnInternalIdle 
%%   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.
%%   
%%       void MyWindow::OnInternalIdle()
%%         {
%%             if (wxUpdateUIEvent::CanUpdate(this))
%%            UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
%%         }
%%    
%%
%% Return Value:
%% See Also: wxUpdateUIEvent, 
%%           wxWindow::DoUpdateWindowUI, 
%%           wxWindow::OnInternalIdle
%%*%%*%%
          -spec updateWindowUI(This, [Option]) -> ok
           when
           This     ::         wxWindow(),
           Option   ::  {flags, integer()}.

updateWindowUI(#wx_ref{type=ThisT,ref=ThisRef}, Options)
           when
           is_list(Options)  ->
                              ?CLASS(ThisT,wxWindow),
                   MOpts =  fun({flags, Flags},  Acc) -> [<<1:32/?UI,Flags:32/?UI>>|Acc];
                                (          BadOpt, _) -> erlang:error({badoption, BadOpt})
                            end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                         wxe_util:cast(?wxWindow_UpdateWindowUI,
                                         <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).













































           %·%% UPDATE %%·%

%%   
%%   Calling this method immediately repaints the invalidated area of 
%%   the window and all of its children recursively while this would 
%%   usually only happen 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 first if you want to immediately 
%%   redraw the window unconditionally.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec update(This) -> ok
           when
           This :: wxWindow().
           
update(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                         ?CLASS(ThisT,wxWindow),
                           wxe_util:cast(?wxWindow_Update,
                           <<ThisRef:32/?UI>>).








           %·%% GET UPDATE REGION %%·%

%%   
%%    Returns the region specifying which parts of
%%    the window have been damaged. 
%%  
%%    Should only be called within an wxPaintEvent handler.
%%   
%% Return Value:
%% See Also: wxRegion
%%*%%*%%
          -spec getUpdateRegion(This) -> wxRegion:wxRegion()
           when
           This :: wxWindow().
           
getUpdateRegion(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                  ?CLASS(ThisT,wxWindow),
                                    wxe_util:call(?wxWindow_GetUpdateRegion,
                                    <<ThisRef:32/?UI>>).
      








           %·%% IS EXPOSED / 2 %%·%

%%   
%%   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.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec isExposed(This, Pt) ->   boolean()
           when
           This ::                      wxWindow(),
           Pt   :: {X :: integer(), Y :: integer()};
          
          (This, Rect) -> boolean()
           when
           This ::      wxWindow(),
           Rect :: {X :: integer(), Y :: integer(), W :: integer(), H :: integer()}.

isExposed(#wx_ref{type=ThisT,ref=ThisRef},
                 {PtX,PtY})
           when
           is_integer(PtX),
           is_integer(PtY) ->
                            ?CLASS(ThisT,wxWindow),
              wxe_util:call(?wxWindow_IsExposed_1_0,
              <<ThisRef:32/?UI,PtX:32/?UI,PtY:32/?UI>>);

isExposed(#wx_ref{type=ThisT,ref=ThisRef},
                 {RectX,RectY,RectW,RectH})
           when
           is_integer(RectX),
           is_integer(RectY),
           is_integer(RectW),
           is_integer(RectH) ->
                              ?CLASS(ThisT,wxWindow),
                wxe_util:call(?wxWindow_IsExposed_1_1,
                <<ThisRef:32/?UI,RectX:32/?UI,RectY:32/?UI,RectW:32/?UI,RectH:32/?UI>>).


           %·%% IS EXPOSED / 3 %%·%

%%   
%%   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.
%%   
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec isExposed(This, X, Y) -> boolean()
           when
           This :: wxWindow(),
           X    ::  integer(),
           Y    ::  integer().

isExposed(#wx_ref{type=ThisT,ref=ThisRef},
                                     X,Y)
           when
           is_integer(X),
           is_integer(Y) ->
                          ?CLASS(ThisT,wxWindow),
            wxe_util:call(?wxWindow_IsExposed_2,
            <<ThisRef:32/?UI,X:32/?UI,Y:32/?UI>>).


           %·%% IS EXPOSED / 4 %%·%

%%   
%%   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.
%%      
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec isExposed(This, X, Y, W, H) -> boolean()
           when
           This :: wxWindow(),
           X :: integer(),
           Y :: integer(),
           W :: integer(),
           H :: integer().

isExposed(#wx_ref{type=ThisT,ref=ThisRef},X,Y,W,H)
           when
           is_integer(X),
           is_integer(Y),
           is_integer(W),
           is_integer(H) ->
                          ?CLASS(ThisT,wxWindow),
            wxe_util:call(?wxWindow_IsExposed_4,
            <<ThisRef:32/?UI,X:32/?UI,Y:32/?UI,W:32/?UI,H:32/?UI>>).




           %·%% REFRESH %%·%

%%   
%% See below...
%% @equiv refresh(This, [])
          -spec refresh(This)      ->  ok
           when
           This :: wxWindow().

refresh(This)
           when
           is_record(This, wx_ref) ->  refresh(This, []).

%%    
%%   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 instead.
%% 
%% Return Value:
%% See Also:
%%*%%*%%
          -spec refresh(This, [Option]) -> ok
           when
           This    ::                   wxWindow(),
           Option  ::  {eraseBackground, boolean()} %% If true, the background will be erased.
                    |  {rect, {X :: integer(), %% If non-NULL, only the given rectangle 
                               Y :: integer(),  %              will be treated as damaged.
                               W :: integer(),
                               H :: integer()}}.

refresh(#wx_ref{type=ThisT,ref=ThisRef}, 
                               Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   MOpts = fun({eraseBackground, EraseBackground}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(EraseBackground)):32/?UI>>|Acc];
                              ({rect,  {RectX,RectY,RectW,RectH}}, Acc) -> [<<2:32/?UI,RectX:32/?UI,RectY:32/?UI,RectW:32/?UI,RectH:32/?UI,0:32>>|Acc];
                                                            (BadOpt, _) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:cast(?wxWindow_Refresh,
                                        <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).







           %·%% REFRESH RECT %%·%

%%   
%% See below...
%% @equiv refreshRect(This,Rect, [])
          -spec refreshRect(This, Rect) ->  ok
           when
           This :: wxWindow(),
           Rect :: {X :: integer(),
                    Y :: integer(),
                    W :: integer(),
                    H :: integer()}.

refreshRect(This,Rect={RectX,RectY,RectW,RectH})
           when
           is_record(This, wx_ref),
           is_integer(RectX),
           is_integer(RectY),
           is_integer(RectW),
           is_integer(RectH)             ->  refreshRect(This,Rect, []).


%%    
%%   Redraws the contents of the given rectangle: only the area inside 
%%   it will be repainted.
%%
%%   This is the same as Refresh but has a nicer syntax as it can be 
%%   called with a temporary wxRect object as argument like 
%%   this RefreshRect(wxRect(x, y, w, h)).
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec refreshRect(This, Rect, [Option]) -> ok
           when
           This   ::                   wxWindow(),
           Rect   :: { X ::             integer(),
                       Y ::             integer(),
                       W ::             integer(),
                       H ::             integer()},
           Option ::  {eraseBackground, boolean()}.

refreshRect(#wx_ref{type=ThisT,ref=ThisRef},
                  {RectX,RectY,RectW,RectH},
                                   Options)
           when
           is_integer(RectX),
           is_integer(RectY),
           is_integer(RectW),
           is_integer(RectH),
              is_list(Options) ->
                                ?CLASS(ThisT,wxWindow),
                      MOpts = fun({eraseBackground, EraseBackground}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(EraseBackground)):32/?UI>>|Acc];
                                                               (BadOpt, _) -> erlang:error({badoption, BadOpt})
                              end,
                      BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                           wxe_util:cast(?wxWindow_RefreshRect,
                                           <<ThisRef:32/?UI,RectX:32/?UI,RectY:32/?UI,RectW:32/?UI,RectH:32/?UI, 0:32,BinOpt/binary>>).












           %·%% IS RETAINED %%·%

%%   
%%    Returns true if the window is retained, false otherwise.
%%   
%%    Retained windows are only available on X platforms.
%%
%%    A retained window is
%%    A window with an offscreen buffer for screen pixel values. 
%%    Images are rendered into the buffer for any portions 
%%    of the window that aren't visible onscreen. 
%%
%% Return Value:
%% See Also:
%%*%%*%%
          -spec isRetained(This) -> boolean()
           when
           This :: wxWindow().
           
isRetained(#wx_ref{type=ThisT,ref=ThisRef}) ->
                ?CLASS(ThisT,wxWindow),
  wxe_util:call(?wxWindow_IsRetained,
  <<ThisRef:32/?UI>>).































           %·%% IS TOP LEVEL %%·%

%%   
%%   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).
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec isTopLevel(This) -> boolean()
           when
           This :: wxWindow().
           
isTopLevel(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                             ?CLASS(ThisT,wxWindow),
                               wxe_util:call(?wxWindow_IsTopLevel,
                               <<ThisRef:32/?UI>>).

















           %·%% POPUP MENU / 2,3 %%·%

%%   
%% See below...
%% @equiv popupMenu(This,Menu, []) 
          -spec popupMenu(This, Menu) ->  boolean()
           when
           This ::      wxWindow(),
           Menu :: wxMenu:wxMenu().

popupMenu(This,Menu)
           when
           is_record(This, wx_ref),
           is_record(Menu, wx_ref)    ->  popupMenu(This,Menu, []).
    
    
           %·%% POPUP MENU / 3 %%·%
%%    
%%   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 usually. If the coordinates are not specified, 
%%   the current mouse cursor position is used.
%%
%%   Just before the menu is popped up,     
%%      wxMenu::UpdateUI 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.
%%   With that said, here are the two functions that do. 
%%
%% Return Value:
%% See Also:
%%*%%*%%

          -spec popupMenu(This, Menu, [Option]) -> boolean()
           when
           This     :: wxWindow(),
           Menu     :: wxMenu:wxMenu(), %%  Menu to pop up.
           Option   ::  {pos, {X :: integer(), %% The position where the menu will appear.
                               Y :: integer()}}.
popupMenu(#wx_ref{type=ThisT,ref=ThisRef},
          #wx_ref{type=MenuT,ref=MenuRef},
                                 Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                             ?CLASS(MenuT,wxMenu),
                   MOpts = fun({pos, {PosX,PosY}}, Acc) -> [<<1:32/?UI,PosX:32/?UI,PosY:32/?UI,0:32>>|Acc];
                                            (BadOpt, _) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt  = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                         wxe_util:call(?wxWindow_PopupMenu_2,
                                         <<ThisRef:32/?UI,MenuRef:32/?UI, BinOpt/binary>>).
           %·%% POPUP MENU / 4 %%·%
%%   
%%   /\
%% See above...
%% Return Value:
%% See Also:
%%*%%*%%
          -spec popupMenu(This, Menu, X, Y) -> boolean()
           when
           This ::      wxWindow(),
           Menu :: wxMenu:wxMenu(),
           X    ::       integer(),
           Y    ::       integer().
popupMenu(#wx_ref{type=ThisT,ref=ThisRef},
          #wx_ref{type=MenuT,ref=MenuRef},
                                        X,
                                        Y)
           when
           is_integer(X),
           is_integer(Y) ->
                          ?CLASS(ThisT,wxWindow),
                          ?CLASS(MenuT,wxMenu),
            wxe_util:call(?wxWindow_PopupMenu_3,
            <<ThisRef:32/?UI,MenuRef:32/?UI,X:32/?UI,Y:32/?UI>>).































 


























           %·%% GET CHAR HEIGHT %%·%

%%   
%%   Returns the character height for this window.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getCharHeight(This) -> integer()
           when
           This :: wxWindow().
           
getCharHeight(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                ?CLASS(ThisT,wxWindow),
                                  wxe_util:call(?wxWindow_GetCharHeight,
                                  <<ThisRef:32/?UI>>).




           %·%% GET CHAR WIDTH %%·%

%%   
%%    Returns the average character width for this window.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getCharWidth(This) -> integer()
           when
           This :: wxWindow().
           
getCharWidth(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                               ?CLASS(ThisT,wxWindow),
                                 wxe_util:call(?wxWindow_GetCharWidth,
                                 <<ThisRef:32/?UI>>).






           %·%% GET TEXT EXTENT %%·%

%%   
%% See below...
%% @equiv getTextExtent(This,String, [])
          -spec getTextExtent(This, String) -> Result
           when
           Result  :: {X               :: integer(),
                       Y               :: integer(),
                       Descent         :: integer(),
                       ExternalLeading :: integer()},
             This  ::         wxWindow(),
           String  :: unicode:chardata().

getTextExtent(This,String)
           when
           is_record(This, wx_ref),
           is_list(String) ->   getTextExtent(This,String, []).

%%    
%%   Gets the dimensions of the string as 
%%   it would be drawn on the window 
%%   with the currently selected font.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getTextExtent(This, String, [Option]) -> Result
           when
           Result  ::  {          X :: integer() , %% Return value for width.
                                  Y :: integer() , %% Return value for height.
                            Descent :: integer() , %% Return value for descent.
                    ExternalLeading :: integer()}, %% Return value for external leading.
           This    ::                 wxWindow() ,
           String  ::         unicode:chardata() , %% String whose extent is to be measured.
           Option  ::  {theFont, wxFont:wxFont()}. %% Font to use instead of the current window font (optional).

getTextExtent(#wx_ref{type=ThisT,ref=ThisRef},String, Options)
           when
           is_list(String),
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   String_UC = unicode:characters_to_binary([String,0]),
                       MOpts =  fun({theFont, #wx_ref{type=TheFontT,ref=TheFontRef}}, Acc) ->
                                                                                                  ?CLASS(TheFontT,wxFont),
                                                                                             [<<1:32/?UI,TheFontRef:32/?UI>>|Acc];
                                   (BadOpt, _ )                                            -> erlang:error({badoption, BadOpt})
                                end,
  BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                       wxe_util:call(?wxWindow_GetTextExtent,
  <<ThisRef:32/?UI,(byte_size(String_UC)):32/?UI,(String_UC)/binary,
        0:(((8- ((0+byte_size(String_UC)) band 16#7)) band 16#7))/unit:8, BinOpt/binary>>).









           %·%% POP EVENT HANDLER %%·%

%%   
%%    Use PushEventHandler/PopEventHandler to form a chain of event handlers, 
%%    where each handler processes a different range of events independently
%%    from the other handlers.
%%
%% See below...
%% @equiv popEventHandler(This, [])
          -spec popEventHandler(This) -> wxEvtHandler:wxEvtHandler()
           when
           This :: wxWindow().

popEventHandler(This)
           when
           is_record(This, wx_ref) -> popEventHandler(This, []).

%%    
%%    Removes and returns the top-most event handler 
%%    on the event handler stack.
%%   
%% Return Value:
%% See Also:  wxWindow::SetEventHandler, 
%%            wxWindow::GetEventHandler, 
%%            wxWindow::PushEventHandler, 
%%            wxEvtHandler::ProcessEvent, 
%%            wxEvtHandler
%%*%%*%%
          -spec popEventHandler(This, [Option]) -> wxEvtHandler:wxEvtHandler()
           when
           This   ::                 wxWindow(),
           Option ::  {deleteHandler, boolean()}. %% If this is true,
                                                  %% the handler will be deleted 
                                                  %% after it is removed. 
                                                  %% The default value is false.
popEventHandler(#wx_ref{type=ThisT,ref=ThisRef},
                                       Options)
           when
           is_list(Options) ->
                             ?CLASS(ThisT,wxWindow),
                   MOpts = fun({deleteHandler, DeleteHandler}, Acc) -> [<<1:32/?UI,(wxe_util:from_bool(DeleteHandler)):32/?UI>>|Acc];
                                                      (BadOpt,  _ ) -> erlang:error({badoption, BadOpt})
                           end,
                   BinOpt = list_to_binary(lists:foldl(MOpts, [<<0:32>>], Options)),
                                        wxe_util:call(?wxWindow_PopEventHandler,
                                        <<ThisRef:32/?UI, 0:32,BinOpt/binary>>).





           %·%% GET EVENT HANDLER %%·%

%%   
%%   Returns the event handler for this window. 
%%   
%%   By default, the window is its own event handler.
%%   
%% Return Value:
%% See Also: wxWindow::SetEventHandler, 
%%           wxWindow::PushEventHandler, 
%%           wxWindow::PopEventHandler, 
%%           wxEvtHandler::ProcessEvent, 
%%           wxEvtHandler
%%*%%*%%
          -spec getEventHandler(This) -> wxEvtHandler:wxEvtHandler()
           when
           This :: wxWindow().
           
getEventHandler(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                  ?CLASS(ThisT,wxWindow),
                                    wxe_util:call(?wxWindow_GetEventHandler,
                                    <<ThisRef:32/?UI>>).


           %·%% GET HANDLE %%·%

%%   
%%   Returns the platform-specific handle 
%%   of the physical window. 
%%   Cast it to an appropriate handle, 
%%   such as HWND for Windows, Widget for Motif, GtkWidget for GTK or 
%%   WinHandle for PalmOS.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec getHandle(This) -> integer()
           when
           This :: wxWindow().
           
getHandle(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                            ?CLASS(ThisT,wxWindow),
                              wxe_util:call(?wxWindow_GetHandle,
                              <<ThisRef:32/?UI>>).









           %·%% WARP POINTER %%·%

%%   
%%    Moves the pointer to the given position on the window.
%%    
%%    NB: This function IS NOT SUPPORTED UNDER MAC because Apple Human 
%%    Interface Guidelines forbid moving the mouse cursor programmatically.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec warpPointer(This, X, Y) -> ok 
           when
           This :: wxWindow(),
           X    ::  integer(), %% The new x position for the cursor.
           Y    ::  integer(). %% The new y position for the cursor.

warpPointer(#wx_ref{type=ThisT,ref=ThisRef},
                                         X,
                                         Y)
           when
           is_integer(X),
           is_integer(Y) ->
                          ?CLASS(ThisT,wxWindow),
            wxe_util:cast(?wxWindow_WarpPointer,
            <<ThisRef:32/?UI,X:32/?UI,Y:32/?UI>>).










           %·%% VALIDATE %%·%

%%   
%%   Validates the current values of the child controls using their validators.
%%
%%                   ———————————            ———————————
%%                   |    A    | -------->  |    B    |   
%%                   ———————————            ———————————
%%
%%        So A is going to send Data to B 
%%           a text entry to a change font size
%%
%%
%%        A validator is like a contract checker, to ensure the data type 
%%              flowing thorugh, will be accepted on the other 
%%                    end and not crash the program
%%                                   ||
%%                   ———————————     \/      ———————————
%%                   |    A    | -----—--->  |    B    |   
%%                   ———————————             ———————————
%%
%%
%%                   It typically beeps back at the user
%%
%%
%%                               Validator
%%             ———————————      ———————————       ———————————
%%             |    A    | -----|   VAL   |—--->  |    B    |   
%%             ———————————      ———————————       ———————————
%%
%%                   But Erlang is great at this already 
%%                     
%%    Other languages need this fuction to check that all other windows   
%%
%%
%%   If the window has wxWS_EX_VALIDATE_RECURSIVELY extra style flag set, 
%%   the method will also call Validate() of all child windows.
%%   
%%      wxWidgets supports validators, which are objects that
%%      link data variables and their corresponding controls. 
%%    
%%    Although not always applicable, the use of validators where possible
%%    will save you a lot of time and can make it unnecessary 
%%    to write TransferDataToWindow and TransferDataFromWindow functions.
%%
%%
%%
%% Return Value: Returns false if any of the validations failed.
%% See Also: wxWindow::TransferDataFromWindow, 
%%           wxWindow::TransferDataToWindow, 
%%           wxValidator
%%*%%*%%
          -spec validate(This) -> boolean()
           when
           This :: wxWindow().
           
validate(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                           ?CLASS(ThisT,wxWindow),
                             wxe_util:call(?wxWindow_Validate,
                             <<ThisRef:32/?UI>>).





           %·%% TRANSFER DATA FROM WINDOW %%·%
%%                            ————
%%   
%%   Transfers values from child controls to data areas 
%%   specified by their validators. 
%%   Returns false if a transfer failed.
%%   
%%   If the window has wxWS_EX_VALIDATE_RECURSIVELY extra style flag set, 
%%   the method will also call TransferDataFromWindow() of all child windows.
%%   
%% Return Value:
%% See Also: wxWindow::TransferDataToWindow, wxValidator, wxWindow::Validate
%%*%%*%%
          -spec transferDataFromWindow(This) -> boolean()
           when
           This :: wxWindow().
           
transferDataFromWindow(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                         ?CLASS(ThisT,wxWindow),
                                           wxe_util:call(?wxWindow_TransferDataFromWindow,
                                           <<ThisRef:32/?UI>>).




           %·%% TRANSFER DATA TO WINDOW %%·%
%%                            ——
%%   
%%   Transfers values to child controls 
%%   from data areas specified by their validators.
%%   
%%   If the window has wxWS_EX_VALIDATE_RECURSIVELY extra style flag set, 
%%   the method will also call TransferDataToWindow() of all child windows.
%%   
%% Return Value: Returns false if a transfer failed.
%% See Also: wxWindow::TransferDataFromWindow, wxValidator, wxWindow::Validate
%%*%%*%%
          -spec transferDataToWindow(This) -> boolean()
           when
           This :: wxWindow().
           
transferDataToWindow(#wx_ref{type=ThisT,ref=ThisRef}) ->
                                                       ?CLASS(ThisT,wxWindow),
                                         wxe_util:call(?wxWindow_TransferDataToWindow,
                                         <<ThisRef:32/?UI>>).


          %·%% SET PALETTE %%·%

%%   
%%    Obsolete - use wxDC::SetPalette instead.
%%   
%% Return Value:
%% See Also:
%%*%%*%%
          -spec setPalette(This, Pal)     -> ok
           when
           This ::            wxWindow(),
           Pal  :: wxPalette:wxPalette().

setPalette(#wx_ref{type=ThisT,ref=ThisRef},
           #wx_ref{type=PalT,ref=PalRef})  ->
                                            ?CLASS(ThisT,wxWindow),
                                            ?CLASS(PalT,wxPalette),
                              wxe_util:cast(?wxWindow_SetPalette,
                              <<ThisRef:32/?UI,PalRef:32/?UI>>).













 %% From wxEvtHandler


%% @hidden
disconnect(This,EventType, Options) -> wxEvtHandler:disconnect(This,EventType, Options).
%% @hidden
disconnect(This,EventType) -> wxEvtHandler:disconnect(This,EventType).
%% @hidden
disconnect(This) -> wxEvtHandler:disconnect(This).
%% @hidden
connect(This,EventType, Options) -> wxEvtHandler:connect(This,EventType, Options).
%% @hidden
connect(This,EventType) -> wxEvtHandler:connect(This,EventType).