1wxWindow(3)                Erlang Module Definition                wxWindow(3)
2
3
4

NAME

6       wxWindow - Functions for wxWindow class
7

DESCRIPTION

9       wxWindow  is  the base class for all windows and represents any visible
10       object on screen. All controls, top level windows and so  on  are  win‐
11       dows. Sizers and device contexts are not, however, as they don't appear
12       on screen themselves.
13
14       Please note that all children of the window will be  deleted  automati‐
15       cally by the destructor before the window itself is deleted which means
16       that you don't have to worry about deleting them manually.  Please  see
17       the window deletion overview for more information.
18
19       Also  note  that  in  this,  and  many  others,  wxWidgets classes some
20       GetXXX() methods may be overloaded (as, for example, getSize/1 or  get‐
21       ClientSize/1). In this case, the overloads are non-virtual because hav‐
22       ing multiple virtual functions with the same name results in a  virtual
23       function name hiding at the derived class level (in English, this means
24       that the derived class has to override all overloaded  variants  if  it
25       overrides  any of them). To allow overriding them in the derived class,
26       wxWidgets uses a unique protected virtual  DoGetXXX()  method  and  all
27       GetXXX() ones are forwarded to it, so overriding the former changes the
28       behaviour of the latter.
29
30       Styles
31
32       This class supports the following styles:
33
34       Extra Styles
35
36       This class supports the following extra styles:
37
38       See: Overview events, Overview windowsizing
39
40       This class is derived (and can use functions) from: wxEvtHandler
41
42       wxWidgets docs: wxWindow
43

EVENTS

45       Event types  emitted  from  this  class:  activate,  child_focus,  con‐
46       text_menu,  help,  drop_files, erase_background, set_focus, kill_focus,
47       idle, joy_button_down, joy_button_up,  joy_move,  joy_zmove,  key_down,
48       key_up,  char,  char_hook,  mouse_capture_lost,  mouse_capture_changed,
49       left_down, left_up, middle_down, middle_up, right_down,  right_up,  mo‐
50       tion,    enter_window,    leave_window,   left_dclick,   middle_dclick,
51       right_dclick, mousewheel, aux1_down, aux1_up,  aux1_dclick,  aux2_down,
52       aux2_up,  aux2_dclick,  paint, scrollwin_top, scrollwin_bottom, scroll‐
53       win_lineup, scrollwin_linedown,  scrollwin_pageup,  scrollwin_pagedown,
54       scrollwin_thumbtrack,    scrollwin_thumbrelease,    set_cursor,   size,
55       sys_colour_changed
56

DATA TYPES

58       wxWindow() = wx:wx_object()
59

EXPORTS

61       new() -> wxWindow()
62
63              Default constructor.
64
65       new(Parent, Id) -> wxWindow()
66
67              Types:
68
69                 Parent = wxWindow()
70                 Id = integer()
71
72       new(Parent, Id, Options :: [Option]) -> wxWindow()
73
74              Types:
75
76                 Parent = wxWindow()
77                 Id = integer()
78                 Option =
79                     {pos, {X :: integer(), Y :: integer()}} |
80                     {size, {W :: integer(), H :: integer()}} |
81                     {style, integer()}
82
83              Constructs a window, which can be a child of a frame, dialog  or
84              any other non-control window.
85
86       destroy(This :: wxWindow()) -> ok
87
88              Destructor.
89
90              Deletes  all  sub-windows, then deletes itself. Instead of using
91              the delete operator explicitly, you  should  normally  use  'De‐
92              stroy'/1  so  that wxWidgets can delete a window only when it is
93              safe to do so, in idle time.
94
95              See: Window Deletion Overview, 'Destroy'/1, wxCloseEvent
96
97       create(This, Parent, Id) -> boolean()
98
99              Types:
100
101                 This = Parent = wxWindow()
102                 Id = integer()
103
104       create(This, Parent, Id, Options :: [Option]) -> boolean()
105
106              Types:
107
108                 This = Parent = wxWindow()
109                 Id = integer()
110                 Option =
111                     {pos, {X :: integer(), Y :: integer()}} |
112                     {size, {W :: integer(), H :: integer()}} |
113                     {style, integer()}
114
115              Construct the actual window object after creating  the  C++  ob‐
116              ject.
117
118              The  non-default  constructor of wxWindow class does two things:
119              it initializes the C++ object and it also creates the window ob‐
120              ject  in  the  underlying graphical toolkit. The create/4 method
121              can be used to perform the second part later, while the  default
122              constructor can be used to perform the first part only.
123
124              Please  note  that the underlying window must be created exactly
125              once, i.e. if you use the default constructor, which doesn't  do
126              this,  you must call create/4 before using the window and if you
127              use the non-default constructor, you can not call  create/4,  as
128              the underlying window is already created.
129
130              Note  that  it  is  possible  and, in fact, useful, to call some
131              methods on the object between creating the C++ object itself and
132              calling  create/4  on it, e.g. a common pattern to avoid showing
133              the contents of a window before it is fully initialized is:
134
135              Also note that it is possible to create an object of  a  derived
136              type and then call create/4 on it: This is notably used by over‐
137              view_xrc.
138
139              The parameters of this method have exactly the same  meaning  as
140              the non-default constructor parameters, please refer to them for
141              their description.
142
143              Return: true if window creation succeeded or false if it failed
144
145       cacheBestSize(This, Size) -> ok
146
147              Types:
148
149                 This = wxWindow()
150                 Size = {W :: integer(), H :: integer()}
151
152              Sets the cached best size value.
153
154              See: getBestSize/1
155
156       captureMouse(This) -> ok
157
158              Types:
159
160                 This = wxWindow()
161
162              Directs all mouse input to this window.
163
164              Call releaseMouse/1 to release the capture.
165
166              Note that wxWidgets maintains the stack of windows  having  cap‐
167              tured  the  mouse and when the mouse is released the capture re‐
168              turns to the window which had had captured it previously and  it
169              is  only  really  released  if there were no previous window. In
170              particular, this means that you must release the mouse  as  many
171              times as you capture it, unless the window receives the wxMouse‐
172              CaptureLostEvent event.
173
174              Any application which captures the mouse  in  the  beginning  of
175              some  operation  must  handle wxMouseCaptureLostEvent and cancel
176              this operation when it receives the  event.  The  event  handler
177              must not recapture mouse.
178
179              See: releaseMouse/1, wxMouseCaptureLostEvent
180
181       center(This) -> ok
182
183              Types:
184
185                 This = wxWindow()
186
187       centre(This) -> ok
188
189              Types:
190
191                 This = wxWindow()
192
193       center(This, Options :: [Option]) -> ok
194
195              Types:
196
197                 This = wxWindow()
198                 Option = {dir, integer()}
199
200              See: centre/2.
201
202       centre(This, Options :: [Option]) -> ok
203
204              Types:
205
206                 This = wxWindow()
207                 Option = {dir, integer()}
208
209              Centres the window.
210
211              Remark:  If  the  window is a top level one (i.e. doesn't have a
212              parent), it will be centred relative to the screen anyhow.
213
214              See: center/2
215
216       centerOnParent(This) -> ok
217
218              Types:
219
220                 This = wxWindow()
221
222       centreOnParent(This) -> ok
223
224              Types:
225
226                 This = wxWindow()
227
228       centerOnParent(This, Options :: [Option]) -> ok
229
230              Types:
231
232                 This = wxWindow()
233                 Option = {dir, integer()}
234
235              See: centreOnParent/2.
236
237       centreOnParent(This, Options :: [Option]) -> ok
238
239              Types:
240
241                 This = wxWindow()
242                 Option = {dir, integer()}
243
244              Centres the window on its parent.
245
246              This is a more readable synonym for centre/2.
247
248              Remark: This methods provides for a way to centre top level win‐
249              dows  over  their parents instead of the entire screen. If there
250              is no parent or if the window is not a top  level  window,  then
251              behaviour is the same as centre/2.
252
253              See: wxTopLevelWindow:centreOnScreen/2
254
255       clearBackground(This) -> ok
256
257              Types:
258
259                 This = wxWindow()
260
261              Clears  the  window  by  filling  it with the current background
262              colour.
263
264              Does not cause an erase background event to be generated.
265
266              Notice that this uses wxClientDC to draw on the window  and  the
267              results  of  doing  it  while also drawing on wxPaintDC for this
268              window are undefined. Hence this method shouldn't be  used  from
269              EVT_PAINT  handlers,  just use wxDC:clear/1 on the wxPaintDC you
270              already use there instead.
271
272       clientToScreen(This, Pt) -> {X :: integer(), Y :: integer()}
273
274              Types:
275
276                 This = wxWindow()
277                 Pt = {X :: integer(), Y :: integer()}
278
279              Converts to screen coordinates from coordinates relative to this
280              window.
281
282       clientToScreen(This, X, Y) -> {X :: integer(), Y :: integer()}
283
284              Types:
285
286                 This = wxWindow()
287                 X = Y = integer()
288
289              Converts to screen coordinates from coordinates relative to this
290              window.
291
292       close(This) -> boolean()
293
294              Types:
295
296                 This = wxWindow()
297
298       close(This, Options :: [Option]) -> boolean()
299
300              Types:
301
302                 This = wxWindow()
303                 Option = {force, boolean()}
304
305              This function simply generates a wxCloseEvent whose handler usu‐
306              ally tries to close the window.
307
308              It doesn't close the window itself, however.
309
310              Return: true if the event was handled and not vetoed, false oth‐
311              erwise.
312
313              Remark: Close calls the close handler for the window,  providing
314              an  opportunity  for the window to choose whether to destroy the
315              window. Usually it is only  used  with  the  top  level  windows
316              (wxFrame and wxDialog classes) as the others are not supposed to
317              have any special OnClose() logic. The close handler should check
318              whether   the  window  is  being  deleted  forcibly,  using  wx‐
319              CloseEvent:canVeto/1, in which case it should destroy the window
320              using  'Destroy'/1.  Note  that calling Close does not guarantee
321              that the window will be destroyed; but it provides a way to sim‐
322              ulate a manual close of a window, which may or may not be imple‐
323              mented by destroying the window. The default  implementation  of
324              wxDialog::OnCloseWindow  does not necessarily delete the dialog,
325              since it will simply simulate an wxID_CANCEL event which is han‐
326              dled by the appropriate button event handler and may do anything
327              at all. To guarantee that the window  will  be  destroyed,  call
328              'Destroy'/1 instead
329
330              See: Window Deletion Overview, 'Destroy'/1, wxCloseEvent
331
332       convertDialogToPixels(This, Sz) ->
333                                {W :: integer(), H :: integer()}
334
335              Types:
336
337                 This = wxWindow()
338                 Sz = {W :: integer(), H :: integer()}
339
340              This is an overloaded member function, provided for convenience.
341              It differs from the above function only in what  argument(s)  it
342              accepts.
343
344       convertPixelsToDialog(This, Sz) ->
345                                {W :: integer(), H :: integer()}
346
347              Types:
348
349                 This = wxWindow()
350                 Sz = {W :: integer(), H :: integer()}
351
352              This is an overloaded member function, provided for convenience.
353              It differs from the above function only in what  argument(s)  it
354              accepts.
355
356       'Destroy'(This) -> boolean()
357
358              Types:
359
360                 This = wxWindow()
361
362              Destroys the window safely.
363
364              Use  this function instead of the delete operator, since differ‐
365              ent window classes can be destroyed differently. Frames and  di‐
366              alogs are not destroyed immediately when this function is called
367              - they are added to a list of windows  to  be  deleted  on  idle
368              time,  when  all  the  window's events have been processed. This
369              prevents problems with events being sent  to  non-existent  win‐
370              dows.
371
372              Return: true if the window has either been successfully deleted,
373              or it has been added to the list of windows pending  real  dele‐
374              tion.
375
376       destroyChildren(This) -> boolean()
377
378              Types:
379
380                 This = wxWindow()
381
382              Destroys all children of a window.
383
384              Called automatically by the destructor.
385
386       disable(This) -> boolean()
387
388              Types:
389
390                 This = wxWindow()
391
392              Disables the window.
393
394              Same as enable/2 Enable(false).
395
396              Return:  Returns  true if the window has been disabled, false if
397              it had been already disabled before the call to this function.
398
399       dragAcceptFiles(This, Accept) -> ok
400
401              Types:
402
403                 This = wxWindow()
404                 Accept = boolean()
405
406              Enables or disables eligibility for drop  file  events  (OnDrop‐
407              Files).
408
409              Remark: Windows only until version 2.8.9, available on all plat‐
410              forms since 2.8.10. Cannot be used together with setDropTarget/2
411              on non-Windows platforms.
412
413              See: setDropTarget/2
414
415       enable(This) -> boolean()
416
417              Types:
418
419                 This = wxWindow()
420
421       enable(This, Options :: [Option]) -> boolean()
422
423              Types:
424
425                 This = wxWindow()
426                 Option = {enable, boolean()}
427
428              Enable or disable the window for user input.
429
430              Note  that when a parent window is disabled, all of its children
431              are disabled as well and they are re-enabled again when the par‐
432              ent is.
433
434              A  window  can  be  created  initially  disabled by calling this
435              method on it before calling create/4 to create the actual under‐
436              lying window, e.g.
437
438              Return: Returns true if the window has been enabled or disabled,
439              false if nothing was done, i.e. if the window had  already  been
440              in the specified state.
441
442              See: isEnabled/1, disable/1, wxRadioBox:enable/3
443
444       findFocus() -> wxWindow()
445
446              Finds the window or control which currently has the keyboard fo‐
447              cus.
448
449              Remark: Note that this is a static function, so it can be called
450              without needing a wxWindow pointer.
451
452              See: setFocus/1, HasFocus() (not implemented in wx)
453
454       findWindow(This, Id) -> wxWindow()
455
456       findWindow(This, Name) -> wxWindow()
457
458              Types:
459
460                 This = wxWindow()
461                 Name = unicode:chardata()
462
463              Find a child of this window, by name.
464
465              May return this if it matches itself.
466
467              Notice that only real children, not top level windows using this
468              window as parent, are searched by this function.
469
470       findWindowById(Id) -> wxWindow()
471
472              Types:
473
474                 Id = integer()
475
476       findWindowById(Id, Options :: [Option]) -> wxWindow()
477
478              Types:
479
480                 Id = integer()
481                 Option = {parent, wxWindow()}
482
483              Find the first window with the given id.
484
485              If parent is NULL, the search  will  start  from  all  top-level
486              frames and dialog boxes; if non-NULL, the search will be limited
487              to the given window hierarchy. The search is recursive  in  both
488              cases.
489
490              See: findWindow/2
491
492              Return: Window with the given id or NULL if not found.
493
494       findWindowByName(Name) -> wxWindow()
495
496              Types:
497
498                 Name = unicode:chardata()
499
500       findWindowByName(Name, Options :: [Option]) -> wxWindow()
501
502              Types:
503
504                 Name = unicode:chardata()
505                 Option = {parent, wxWindow()}
506
507              Find  a  window by its name (as given in a window constructor or
508              create/4 function call).
509
510              If parent is NULL, the search  will  start  from  all  top-level
511              frames and dialog boxes; if non-NULL, the search will be limited
512              to the given window hierarchy.
513
514              The search is recursive in both cases and, unlike  findWindow/2,
515              recurses into top level child windows too.
516
517              If  no  window  with  such name is found, findWindowByLabel/2 is
518              called, i.e. the name is interpreted as  (internal)  name  first
519              but  if  this  fails,  it's internal as (user-visible) label. As
520              this behaviour may be confusing, it is usually better to use ei‐
521              ther  the findWindow/2 overload taking the name or findWindowBy‐
522              Label/2 directly.
523
524              Return: Window with the given name or NULL if not found.
525
526       findWindowByLabel(Label) -> wxWindow()
527
528              Types:
529
530                 Label = unicode:chardata()
531
532       findWindowByLabel(Label, Options :: [Option]) -> wxWindow()
533
534              Types:
535
536                 Label = unicode:chardata()
537                 Option = {parent, wxWindow()}
538
539              Find a window by its label.
540
541              Depending on the type of window, the label may be a window title
542              or  panel  item  label. If parent is NULL, the search will start
543              from all top-level frames and dialog  boxes;  if  non-NULL,  the
544              search will be limited to the given window hierarchy.
545
546              The  search is recursive in both cases and, unlike with findWin‐
547              dow/2, recurses into top level child windows too.
548
549              See: findWindow/2
550
551              Return: Window with the given label or NULL if not found.
552
553       fit(This) -> ok
554
555              Types:
556
557                 This = wxWindow()
558
559              Sizes the window to fit its best size.
560
561              Using this function is equivalent to setting window size to  the
562              return value of getBestSize/1.
563
564              Note  that,  unlike setSizerAndFit/3, this function only changes
565              the current window size and doesn't change its minimal size.
566
567              See: Overview windowsizing
568
569       fitInside(This) -> ok
570
571              Types:
572
573                 This = wxWindow()
574
575              Similar to fit/1, but sizes the interior  (virtual)  size  of  a
576              window.
577
578              Mainly  useful  with  scrolled windows to reset scrollbars after
579              sizing changes that do not trigger a size event, and/or scrolled
580              windows without an interior sizer. This function similarly won't
581              do anything if there are no subwindows.
582
583       freeze(This) -> ok
584
585              Types:
586
587                 This = wxWindow()
588
589              Freezes the window or, in other words, prevents any updates from
590              taking place on screen, the window is not redrawn at all.
591
592              thaw/1  must  be  called to re-enable window redrawing. Calls to
593              these two functions may be nested but to ensure that the  window
594              is  properly  repainted  again, you must thaw it exactly as many
595              times as you froze it.
596
597              If the window has any children, they are recursively frozen too.
598
599              This method is useful for visual  appearance  optimization  (for
600              example,  it  is  a  good idea to use it before doing many large
601              text insertions in a row into a wxTextCtrl under wxGTK)  but  is
602              not  implemented  on all platforms nor for all controls so it is
603              mostly just a hint to wxWidgets and not a mandatory directive.
604
605              See: wxWindowUpdateLocker (not implemented in wx),  thaw/1,  is‐
606              Frozen/1
607
608       getAcceleratorTable(This) ->
609                              wxAcceleratorTable:wxAcceleratorTable()
610
611              Types:
612
613                 This = wxWindow()
614
615              Gets the accelerator table for this window.
616
617              See wxAcceleratorTable.
618
619       getBackgroundColour(This) -> wx:wx_colour4()
620
621              Types:
622
623                 This = wxWindow()
624
625              Returns the background colour of the window.
626
627              See:   setBackgroundColour/2,   setForegroundColour/2,  getFore‐
628              groundColour/1
629
630       getBackgroundStyle(This) -> wx:wx_enum()
631
632              Types:
633
634                 This = wxWindow()
635
636              Returns the background style of the window.
637
638              See:  setBackgroundColour/2,   getForegroundColour/1,   setBack‐
639              groundStyle/2, setTransparent/2
640
641       getBestSize(This) -> {W :: integer(), H :: integer()}
642
643              Types:
644
645                 This = wxWindow()
646
647              This  functions returns the best acceptable minimal size for the
648              window.
649
650              For example, for a static control, it will be the  minimal  size
651              such  that  the control label is not truncated. For windows con‐
652              taining subwindows (typically wxPanel),  the  size  returned  by
653              this function will be the same as the size the window would have
654              had after calling fit/1.
655
656              Override virtual DoGetBestSize() (not  implemented  in  wx)  or,
657              better,  because  it's usually more convenient, DoGetBestClient‐
658              Size() (not implemented in wx) when writing your own custom win‐
659              dow  class  to change the value returned by this public non-vir‐
660              tual method.
661
662              Notice that the best size respects the minimal and maximal  size
663              explicitly  set  for  the window, if any. So even if some window
664              believes that it needs 200 pixels horizontally, calling  setMax‐
665              Size/2  with  a width of 100 would ensure that getBestSize/1 re‐
666              turns the width of at most 100 pixels.
667
668              See: cacheBestSize/2, Overview windowsizing
669
670       getCaret(This) -> wxCaret:wxCaret()
671
672              Types:
673
674                 This = wxWindow()
675
676              Returns the caret() associated with the window.
677
678       getCapture() -> wxWindow()
679
680              Returns the currently captured window.
681
682              See: hasCapture/1, captureMouse/1,  releaseMouse/1,  wxMouseCap‐
683              tureLostEvent, wxMouseCaptureChangedEvent
684
685       getCharHeight(This) -> integer()
686
687              Types:
688
689                 This = wxWindow()
690
691              Returns the character height for this window.
692
693       getCharWidth(This) -> integer()
694
695              Types:
696
697                 This = wxWindow()
698
699              Returns the average character width for this window.
700
701       getChildren(This) -> [wxWindow()]
702
703              Types:
704
705                 This = wxWindow()
706
707              Returns a const reference to the list of the window's children.
708
709              wxWindowList is a type-safe wxList-like class whose elements are
710              of type wxWindow*.
711
712       getClientSize(This) -> {W :: integer(), H :: integer()}
713
714              Types:
715
716                 This = wxWindow()
717
718              This is an overloaded member function, provided for convenience.
719              It  differs  from the above function only in what argument(s) it
720              accepts.
721
722       getContainingSizer(This) -> wxSizer:wxSizer()
723
724              Types:
725
726                 This = wxWindow()
727
728              Returns the sizer of which this window is a member, if any, oth‐
729              erwise NULL.
730
731       getCursor(This) -> wxCursor:wxCursor()
732
733              Types:
734
735                 This = wxWindow()
736
737              Return the cursor associated with this window.
738
739              See: setCursor/2
740
741       getDropTarget(This) -> wx:wx_object()
742
743              Types:
744
745                 This = wxWindow()
746
747              Returns the associated drop target, which may be NULL.
748
749              See: setDropTarget/2, Overview dnd
750
751       getDPIScaleFactor(This) -> number()
752
753              Types:
754
755                 This = wxWindow()
756
757              Returns the ratio of the DPI used by this window to the standard
758              DPI.
759
760              The returned value is 1 for standard DPI screens or 2 for  "200%
761              scaling"  and,  unlike  for getContentScaleFactor/1, is the same
762              under all platforms.
763
764              This factor should be used to increase the  size  of  icons  and
765              similar  windows  whose  best  size is not based on text metrics
766              when using DPI scaling.
767
768              E.g. the program may load a 32px bitmap  if  the  content  scale
769              factor is 1.0 or 64px version of the same bitmap if it is 2.0 or
770              bigger.
771
772              Notice that this method should not be used for window sizes  ex‐
773              pressed  in pixels, as they are already scaled by this factor by
774              the underlying toolkit under some platforms. Use  fromDIP/2  for
775              anything window-related instead.
776
777              Since: 3.1.4
778
779       getExtraStyle(This) -> integer()
780
781              Types:
782
783                 This = wxWindow()
784
785              Returns the extra style bits for the window.
786
787       getFont(This) -> wxFont:wxFont()
788
789              Types:
790
791                 This = wxWindow()
792
793              Returns the font for this window.
794
795              See: setFont/2
796
797       getForegroundColour(This) -> wx:wx_colour4()
798
799              Types:
800
801                 This = wxWindow()
802
803              Returns the foreground colour of the window.
804
805              Remark: The meaning of foreground colour varies according to the
806              window class; it may be the text colour or other colour,  or  it
807              may not be used at all.
808
809              See:   setForegroundColour/2,   setBackgroundColour/2,  getBack‐
810              groundColour/1
811
812       getGrandParent(This) -> wxWindow()
813
814              Types:
815
816                 This = wxWindow()
817
818              Returns the grandparent of a window, or NULL if there isn't one.
819
820       getHandle(This) -> integer()
821
822              Types:
823
824                 This = wxWindow()
825
826              Returns the platform-specific handle of the physical window.
827
828              Cast it to an appropriate handle, such as HWND for Windows, Wid‐
829              get for Motif or GtkWidget for GTK.
830
831       getHelpText(This) -> unicode:charlist()
832
833              Types:
834
835                 This = wxWindow()
836
837              Gets the help text to be used as context-sensitive help for this
838              window.
839
840              Note that the text is actually stored  by  the  current  wxHelp‐
841              Provider  (not implemented in wx) implementation, and not in the
842              window object itself.
843
844              See: setHelpText/2,  GetHelpTextAtPoint()  (not  implemented  in
845              wx), wxHelpProvider (not implemented in wx)
846
847       getId(This) -> integer()
848
849              Types:
850
851                 This = wxWindow()
852
853              Returns the identifier of the window.
854
855              Remark:  Each  window has an integer identifier. If the applica‐
856              tion has not provided one (or the  default  wxID_ANY)  a  unique
857              identifier with a negative value will be generated.
858
859              See: setId/2, Overview windowids
860
861       getLabel(This) -> unicode:charlist()
862
863              Types:
864
865                 This = wxWindow()
866
867              Generic  way of getting a label from any window, for identifica‐
868              tion purposes.
869
870              Remark: The interpretation of this function differs  from  class
871              to  class. For frames and dialogs, the value returned is the ti‐
872              tle. For buttons or static text controls, it is the button text.
873              This  function  can be useful for meta-programs (such as testing
874              tools or special-needs access programs) which need  to  identify
875              windows by name.
876
877       getMaxSize(This) -> {W :: integer(), H :: integer()}
878
879              Types:
880
881                 This = wxWindow()
882
883              Returns the maximum size of the window.
884
885              This is an indication to the sizer layout mechanism that this is
886              the maximum possible size as well as the upper bound on window's
887              size settable using setSize/6.
888
889              See:  GetMaxClientSize()  (not implemented in wx), Overview win‐
890              dowsizing
891
892       getMinSize(This) -> {W :: integer(), H :: integer()}
893
894              Types:
895
896                 This = wxWindow()
897
898              Returns the minimum size of the window,  an  indication  to  the
899              sizer layout mechanism that this is the minimum required size.
900
901              This method normally just returns the value set by setMinSize/2,
902              but it can be overridden to do the calculation on demand.
903
904              See: GetMinClientSize() (not implemented in wx),  Overview  win‐
905              dowsizing
906
907       getName(This) -> unicode:charlist()
908
909              Types:
910
911                 This = wxWindow()
912
913              Returns the window's name.
914
915              Remark:  This  name  is not guaranteed to be unique; it is up to
916              the programmer to supply an appropriate name in the window  con‐
917              structor or via setName/2.
918
919              See: setName/2
920
921       getParent(This) -> wxWindow()
922
923              Types:
924
925                 This = wxWindow()
926
927              Returns the parent of the window, or NULL if there is no parent.
928
929       getPosition(This) -> {X :: integer(), Y :: integer()}
930
931              Types:
932
933                 This = wxWindow()
934
935              This  gets the position of the window in pixels, relative to the
936              parent window for the child windows or relative to  the  display
937              origin for the top level windows.
938
939              See: getScreenPosition/1
940
941       getRect(This) ->
942                  {X :: integer(),
943                   Y :: integer(),
944                   W :: integer(),
945                   H :: integer()}
946
947              Types:
948
949                 This = wxWindow()
950
951              Returns  the  position and size of the window as a {X,Y,W,H} ob‐
952              ject.
953
954              See: getScreenRect/1
955
956       getScreenPosition(This) -> {X :: integer(), Y :: integer()}
957
958              Types:
959
960                 This = wxWindow()
961
962              Returns the window position in screen coordinates,  whether  the
963              window is a child window or a top level one.
964
965              See: getPosition/1
966
967       getScreenRect(This) ->
968                        {X :: integer(),
969                         Y :: integer(),
970                         W :: integer(),
971                         H :: integer()}
972
973              Types:
974
975                 This = wxWindow()
976
977              Returns  the  position and size of the window on the screen as a
978              {X,Y,W,H} object.
979
980              See: getRect/1
981
982       getScrollPos(This, Orientation) -> integer()
983
984              Types:
985
986                 This = wxWindow()
987                 Orientation = integer()
988
989              Returns the built-in scrollbar position.
990
991              See: setScrollbar/6
992
993       getScrollRange(This, Orientation) -> integer()
994
995              Types:
996
997                 This = wxWindow()
998                 Orientation = integer()
999
1000              Returns the built-in scrollbar range.
1001
1002              See: setScrollbar/6
1003
1004       getScrollThumb(This, Orientation) -> integer()
1005
1006              Types:
1007
1008                 This = wxWindow()
1009                 Orientation = integer()
1010
1011              Returns the built-in scrollbar thumb size.
1012
1013              See: setScrollbar/6
1014
1015       getSize(This) -> {W :: integer(), H :: integer()}
1016
1017              Types:
1018
1019                 This = wxWindow()
1020
1021              See the GetSize(int*,int*) overload for more info.
1022
1023       getSizer(This) -> wxSizer:wxSizer()
1024
1025              Types:
1026
1027                 This = wxWindow()
1028
1029              Returns the sizer associated with the window by a previous  call
1030              to setSizer/3, or NULL.
1031
1032       getTextExtent(This, String) -> Result
1033
1034              Types:
1035
1036                 Result =
1037                     {W :: integer(),
1038                      H :: integer(),
1039                      Descent :: integer(),
1040                      ExternalLeading :: integer()}
1041                 This = wxWindow()
1042                 String = unicode:chardata()
1043
1044       getTextExtent(This, String, Options :: [Option]) -> Result
1045
1046              Types:
1047
1048                 Result =
1049                     {W :: integer(),
1050                      H :: integer(),
1051                      Descent :: integer(),
1052                      ExternalLeading :: integer()}
1053                 This = wxWindow()
1054                 String = unicode:chardata()
1055                 Option = {theFont, wxFont:wxFont()}
1056
1057              Gets  the  dimensions  of the string as it would be drawn on the
1058              window with the currently selected font.
1059
1060              The text extent is returned in the w and h pointers.
1061
1062       getThemeEnabled(This) -> boolean()
1063
1064              Types:
1065
1066                 This = wxWindow()
1067
1068              Returns true if the window uses the system theme for drawing its
1069              background.
1070
1071              See: setThemeEnabled/2
1072
1073       getToolTip(This) -> wxToolTip:wxToolTip()
1074
1075              Types:
1076
1077                 This = wxWindow()
1078
1079              Get the associated tooltip or NULL if none.
1080
1081       getUpdateRegion(This) -> wxRegion:wxRegion()
1082
1083              Types:
1084
1085                 This = wxWindow()
1086
1087              Gets  the  dimensions  of the string as it would be drawn on the
1088              window with the currently selected font.
1089
1090              Returns the region specifying which parts  of  the  window  have
1091              been  damaged. Should only be called within an wxPaintEvent han‐
1092              dler.
1093
1094              See: wxRegion, wxRegionIterator (not implemented in wx)
1095
1096       getVirtualSize(This) -> {W :: integer(), H :: integer()}
1097
1098              Types:
1099
1100                 This = wxWindow()
1101
1102              This gets the virtual size of the window in pixels.
1103
1104              By default it returns the client size of the window, but after a
1105              call  to  setVirtualSize/3 it will return the size set with that
1106              method.
1107
1108              See: Overview windowsizing
1109
1110       getWindowStyleFlag(This) -> integer()
1111
1112              Types:
1113
1114                 This = wxWindow()
1115
1116              Gets the window style that was passed to the constructor or cre‐
1117              ate/4 method.
1118
1119              GetWindowStyle() (not implemented in wx) is another name for the
1120              same function.
1121
1122       getWindowVariant(This) -> wx:wx_enum()
1123
1124              Types:
1125
1126                 This = wxWindow()
1127
1128              Returns the value previously passed to setWindowVariant/2.
1129
1130       hasCapture(This) -> boolean()
1131
1132              Types:
1133
1134                 This = wxWindow()
1135
1136              Returns true if this window has the current mouse capture.
1137
1138              See:  captureMouse/1,  releaseMouse/1,  wxMouseCaptureLostEvent,
1139              wxMouseCaptureChangedEvent
1140
1141       hasScrollbar(This, Orient) -> boolean()
1142
1143              Types:
1144
1145                 This = wxWindow()
1146                 Orient = integer()
1147
1148              Returns  true if this window currently has a scroll bar for this
1149              orientation.
1150
1151              This method may return false even when CanScroll()  (not  imple‐
1152              mented in wx) for the same orientation returns true, but if Can‐
1153              Scroll() (not implemented in wx) returns false,  i.e.  scrolling
1154              in  this  direction is not enabled at all, hasScrollbar/2 always
1155              returns false as well.
1156
1157       hasTransparentBackground(This) -> boolean()
1158
1159              Types:
1160
1161                 This = wxWindow()
1162
1163              Returns true if this window background is transparent  (as,  for
1164              example,  for  wxStaticText)  and  should show the parent window
1165              background.
1166
1167              This method is mostly used internally by the library itself  and
1168              you  normally  shouldn't have to call it. You may, however, have
1169              to override it in your wxWindow-derived  class  to  ensure  that
1170              background is painted correctly.
1171
1172       hide(This) -> boolean()
1173
1174              Types:
1175
1176                 This = wxWindow()
1177
1178              Equivalent to calling show/2(false).
1179
1180       inheritAttributes(This) -> ok
1181
1182              Types:
1183
1184                 This = wxWindow()
1185
1186              This  function  is  (or  should  be, in case of custom controls)
1187              called during window creation to intelligently set up the window
1188              visual attributes, that is the font and the foreground and back‐
1189              ground colours.
1190
1191              By "intelligently" the following is meant: by default, all  win‐
1192              dows  use their own GetClassDefaultAttributes() (not implemented
1193              in wx) default attributes. However if some of  the  parents  at‐
1194              tributes  are  explicitly  (that is, using setFont/2 and not se‐
1195              tOwnFont/2) changed and if the  corresponding  attribute  hadn't
1196              been  explicitly  set  for  this window itself, then this window
1197              takes the same value as used by the parent. In addition, if  the
1198              window  overrides  shouldInheritColours/1  to  return false, the
1199              colours will not be changed no matter what  and  only  the  font
1200              might.
1201
1202              This  rather complicated logic is necessary in order to accommo‐
1203              date the different usage scenarios. The most common one is  when
1204              all default attributes are used and in this case, nothing should
1205              be inherited as in modern GUIs different controls use  different
1206              fonts  (and  colours)  than their siblings so they can't inherit
1207              the same value from the parent. However it was also  deemed  de‐
1208              sirable to allow to simply change the attributes of all children
1209              at once by just changing the font or colour of their common par‐
1210              ent, hence in this case we do inherit the parents attributes.
1211
1212       initDialog(This) -> ok
1213
1214              Types:
1215
1216                 This = wxWindow()
1217
1218              Sends  an  wxEVT_INIT_DIALOG event, whose handler usually trans‐
1219              fers data to the dialog via validators.
1220
1221       invalidateBestSize(This) -> ok
1222
1223              Types:
1224
1225                 This = wxWindow()
1226
1227              Resets the cached best size value so it will be recalculated the
1228              next time it is needed.
1229
1230              See: cacheBestSize/2
1231
1232       isFrozen(This) -> boolean()
1233
1234              Types:
1235
1236                 This = wxWindow()
1237
1238              Returns  true  if  the  window  is currently frozen by a call to
1239              freeze/1.
1240
1241              See: freeze/1, thaw/1
1242
1243       isEnabled(This) -> boolean()
1244
1245              Types:
1246
1247                 This = wxWindow()
1248
1249              Returns true if the window is enabled, i.e. if it  accepts  user
1250              input, false otherwise.
1251
1252              Notice that this method can return false even if this window it‐
1253              self hadn't been explicitly disabled when one of its parent win‐
1254              dows  is  disabled.  To get the intrinsic status of this window,
1255              use IsThisEnabled() (not implemented in wx)
1256
1257              See: enable/2
1258
1259       isExposed(This, Pt) -> boolean()
1260
1261       isExposed(This, Rect) -> boolean()
1262
1263              Types:
1264
1265                 This = wxWindow()
1266                 Rect =
1267                     {X :: integer(),
1268                      Y :: integer(),
1269                      W :: integer(),
1270                      H :: integer()}
1271
1272              This is an overloaded member function, provided for convenience.
1273              It  differs  from the above function only in what argument(s) it
1274              accepts.
1275
1276       isExposed(This, X, Y) -> boolean()
1277
1278              Types:
1279
1280                 This = wxWindow()
1281                 X = Y = integer()
1282
1283              Returns true if the given point or rectangle area has  been  ex‐
1284              posed since the last repaint.
1285
1286              Call  this  in  an  paint event handler to optimize redrawing by
1287              only redrawing those areas, which have been exposed.
1288
1289       isExposed(This, X, Y, W, H) -> boolean()
1290
1291              Types:
1292
1293                 This = wxWindow()
1294                 X = Y = W = H = integer()
1295
1296              This is an overloaded member function, provided for convenience.
1297              It  differs  from the above function only in what argument(s) it
1298              accepts.
1299
1300       isRetained(This) -> boolean()
1301
1302              Types:
1303
1304                 This = wxWindow()
1305
1306              Returns true if the window is retained, false otherwise.
1307
1308              Remark: Retained windows are only available on X platforms.
1309
1310       isShown(This) -> boolean()
1311
1312              Types:
1313
1314                 This = wxWindow()
1315
1316              Returns true if the window is shown, false if it has  been  hid‐
1317              den.
1318
1319              See: isShownOnScreen/1
1320
1321       isTopLevel(This) -> boolean()
1322
1323              Types:
1324
1325                 This = wxWindow()
1326
1327              Returns true if the given window is a top-level one.
1328
1329              Currently  all frames and dialogs are considered to be top-level
1330              windows (even if they have a parent window).
1331
1332       isShownOnScreen(This) -> boolean()
1333
1334              Types:
1335
1336                 This = wxWindow()
1337
1338              Returns true if the window is physically visible on the  screen,
1339              i.e.  it  is shown and all its parents up to the toplevel window
1340              are shown as well.
1341
1342              See: isShown/1
1343
1344       layout(This) -> boolean()
1345
1346              Types:
1347
1348                 This = wxWindow()
1349
1350              Lays out the children of this window using the associated sizer.
1351
1352              If a sizer hadn't been associated with  this  window  (see  set‐
1353              Sizer/3),  this  function  doesn't do anything, unless this is a
1354              top level window (see layout/1).
1355
1356              Note that this method is called automatically  when  the  window
1357              size  changes  if it has the associated sizer (or if setAutoLay‐
1358              out/2 with true argument had been explicitly  called),  ensuring
1359              that it is always laid out correctly.
1360
1361              See: Overview windowsizing
1362
1363              Return: Always returns true, the return value is not useful.
1364
1365       lineDown(This) -> boolean()
1366
1367              Types:
1368
1369                 This = wxWindow()
1370
1371              Same as scrollLines/2 (1).
1372
1373       lineUp(This) -> boolean()
1374
1375              Types:
1376
1377                 This = wxWindow()
1378
1379              Same as scrollLines/2 (-1).
1380
1381       lower(This) -> ok
1382
1383              Types:
1384
1385                 This = wxWindow()
1386
1387              Lowers  the  window to the bottom of the window hierarchy (Z-or‐
1388              der).
1389
1390              Remark: This function only  works  for  wxTopLevelWindow-derived
1391              classes.
1392
1393              See: raise/1
1394
1395       move(This, Pt) -> ok
1396
1397              Types:
1398
1399                 This = wxWindow()
1400                 Pt = {X :: integer(), Y :: integer()}
1401
1402       move(This, X, Y) -> ok
1403
1404       move(This, Pt, Y :: [Option]) -> ok
1405
1406              Types:
1407
1408                 This = wxWindow()
1409                 Pt = {X :: integer(), Y :: integer()}
1410                 Option = {flags, integer()}
1411
1412              Moves the window to the given position.
1413
1414              Remark:  Implementations of setSize/6 can also implicitly imple‐
1415              ment the move/4 function, which is defined in the base  wxWindow
1416              class as the call:
1417
1418              See: setSize/6
1419
1420       move(This, X, Y, Options :: [Option]) -> ok
1421
1422              Types:
1423
1424                 This = wxWindow()
1425                 X = Y = integer()
1426                 Option = {flags, integer()}
1427
1428              Moves the window to the given position.
1429
1430              Remark: Implementations of SetSize can also implicitly implement
1431              the move/4 function, which is defined in the base wxWindow class
1432              as the call:
1433
1434              See: setSize/6
1435
1436       moveAfterInTabOrder(This, Win) -> ok
1437
1438              Types:
1439
1440                 This = Win = wxWindow()
1441
1442              Moves  this  window in the tab navigation order after the speci‐
1443              fied win.
1444
1445              This means that when the user presses TAB key on that other win‐
1446              dow, the focus switches to this window.
1447
1448              Default  tab  order is the same as creation order, this function
1449              and moveBeforeInTabOrder/2 allow to change it after creating all
1450              the windows.
1451
1452       moveBeforeInTabOrder(This, Win) -> ok
1453
1454              Types:
1455
1456                 This = Win = wxWindow()
1457
1458              Same as moveAfterInTabOrder/2 except that it inserts this window
1459              just before win instead of putting it right after it.
1460
1461       navigate(This) -> boolean()
1462
1463              Types:
1464
1465                 This = wxWindow()
1466
1467       navigate(This, Options :: [Option]) -> boolean()
1468
1469              Types:
1470
1471                 This = wxWindow()
1472                 Option = {flags, integer()}
1473
1474              Performs a keyboard navigation action starting from this window.
1475
1476              This method is equivalent to calling  NavigateIn()  (not  imple‐
1477              mented in wx) method on the parent window.
1478
1479              Return: Returns true if the focus was moved to another window or
1480              false if nothing changed.
1481
1482              Remark: You may wish to call this from  a  text  control  custom
1483              keypress  handler to do the default navigation behaviour for the
1484              tab key, since the standard default behaviour  for  a  multiline
1485              text  control with the wxTE_PROCESS_TAB style is to insert a tab
1486              and not navigate to the next  control.  See  also  wxNavigation‐
1487              KeyEvent and HandleAsNavigationKey.
1488
1489       pageDown(This) -> boolean()
1490
1491              Types:
1492
1493                 This = wxWindow()
1494
1495              Same as scrollPages/2 (1).
1496
1497       pageUp(This) -> boolean()
1498
1499              Types:
1500
1501                 This = wxWindow()
1502
1503              Same as scrollPages/2 (-1).
1504
1505       popupMenu(This, Menu) -> boolean()
1506
1507              Types:
1508
1509                 This = wxWindow()
1510                 Menu = wxMenu:wxMenu()
1511
1512       popupMenu(This, Menu, Options :: [Option]) -> boolean()
1513
1514              Types:
1515
1516                 This = wxWindow()
1517                 Menu = wxMenu:wxMenu()
1518                 Option = {pos, {X :: integer(), Y :: integer()}}
1519
1520              Pops up the given menu at the specified coordinates, relative to
1521              this window, and returns control when the user has dismissed the
1522              menu.
1523
1524              If a menu item is selected, the corresponding menu event is gen‐
1525              erated and will be processed as usual. If  coordinates  are  not
1526              specified, the current mouse cursor position is used.
1527
1528              menu is the menu to pop up.
1529
1530              The  position where the menu will appear can be specified either
1531              as a {X,Y} pos or by two integers (x and y).
1532
1533              Note that this function switches focus  to  this  window  before
1534              showing the menu.
1535
1536              Remark: Just before the menu is popped up, wxMenu::UpdateUI (not
1537              implemented in wx) is called to ensure that the menu  items  are
1538              in  the correct state. The menu does not get deleted by the win‐
1539              dow. It is recommended to  not  explicitly  specify  coordinates
1540              when  calling PopupMenu in response to mouse click, because some
1541              of the ports (namely, wxGTK) can do a better job of  positioning
1542              the menu in that case.
1543
1544              See: wxMenu
1545
1546       popupMenu(This, Menu, X, Y) -> boolean()
1547
1548              Types:
1549
1550                 This = wxWindow()
1551                 Menu = wxMenu:wxMenu()
1552                 X = Y = integer()
1553
1554              This is an overloaded member function, provided for convenience.
1555              It differs from the above function only in what  argument(s)  it
1556              accepts.
1557
1558       raise(This) -> ok
1559
1560              Types:
1561
1562                 This = wxWindow()
1563
1564              Raises the window to the top of the window hierarchy (Z-order).
1565
1566              Notice  that  this  function only requests the window manager to
1567              raise this window to the top of Z-order. Depending on  its  con‐
1568              figuration,  the  window manager may raise the window, not do it
1569              at all or indicate that a window requested to be raised in  some
1570              other way, e.g. by flashing its icon if it is minimized.
1571
1572              Remark:  This  function  only works for wxTopLevelWindow-derived
1573              classes.
1574
1575              See: lower/1
1576
1577       refresh(This) -> ok
1578
1579              Types:
1580
1581                 This = wxWindow()
1582
1583       refresh(This, Options :: [Option]) -> ok
1584
1585              Types:
1586
1587                 This = wxWindow()
1588                 Option =
1589                     {eraseBackground, boolean()} |
1590                     {rect,
1591                      {X :: integer(),
1592                       Y :: integer(),
1593                       W :: integer(),
1594                       H :: integer()}}
1595
1596              Causes this window, and all of its children recursively  (except
1597              under wxGTK1 where this is not implemented), to be repainted.
1598
1599              Note  that repainting doesn't happen immediately but only during
1600              the next event loop iteration, if you need to update the  window
1601              immediately you should use update/1 instead.
1602
1603              See: refreshRect/3
1604
1605       refreshRect(This, Rect) -> ok
1606
1607              Types:
1608
1609                 This = wxWindow()
1610                 Rect =
1611                     {X :: integer(),
1612                      Y :: integer(),
1613                      W :: integer(),
1614                      H :: integer()}
1615
1616       refreshRect(This, Rect, Options :: [Option]) -> ok
1617
1618              Types:
1619
1620                 This = wxWindow()
1621                 Rect =
1622                     {X :: integer(),
1623                      Y :: integer(),
1624                      W :: integer(),
1625                      H :: integer()}
1626                 Option = {eraseBackground, boolean()}
1627
1628              Redraws  the  contents of the given rectangle: only the area in‐
1629              side it will be repainted.
1630
1631              This is the same as refresh/2 but has a nicer syntax as  it  can
1632              be  called  with  a  temporary {X,Y,W,H} object as argument like
1633              this RefreshRect(wxRect(x, y, w, h)).
1634
1635       releaseMouse(This) -> ok
1636
1637              Types:
1638
1639                 This = wxWindow()
1640
1641              Releases mouse input captured with captureMouse/1.
1642
1643              See: captureMouse/1, hasCapture/1,  releaseMouse/1,  wxMouseCap‐
1644              tureLostEvent, wxMouseCaptureChangedEvent
1645
1646       removeChild(This, Child) -> ok
1647
1648              Types:
1649
1650                 This = Child = wxWindow()
1651
1652              Removes a child window.
1653
1654              This  is  called  automatically  by window deletion functions so
1655              should not be required by  the  application  programmer.  Notice
1656              that this function is mostly internal to wxWidgets and shouldn't
1657              be called by the user code.
1658
1659       reparent(This, NewParent) -> boolean()
1660
1661              Types:
1662
1663                 This = NewParent = wxWindow()
1664
1665              Reparents the window, i.e. the window will be removed  from  its
1666              current parent window (e.g.
1667
1668              a  non-standard  toolbar in a wxFrame) and then re-inserted into
1669              another.
1670
1671              Notice that currently you need to  explicitly  call  wxBookCtrl‐
1672              Base:removePage/2 before reparenting a notebook page.
1673
1674       screenToClient(This) -> {X :: integer(), Y :: integer()}
1675
1676              Types:
1677
1678                 This = wxWindow()
1679
1680              Converts from screen to client window coordinates.
1681
1682       screenToClient(This, Pt) -> {X :: integer(), Y :: integer()}
1683
1684              Types:
1685
1686                 This = wxWindow()
1687                 Pt = {X :: integer(), Y :: integer()}
1688
1689              Converts from screen to client window coordinates.
1690
1691       scrollLines(This, Lines) -> boolean()
1692
1693              Types:
1694
1695                 This = wxWindow()
1696                 Lines = integer()
1697
1698              Scrolls  the  window by the given number of lines down (if lines
1699              is positive) or up.
1700
1701              Return: Returns true if the window was scrolled, false if it was
1702              already on top/bottom and nothing was done.
1703
1704              Remark:  This  function  is currently only implemented under MSW
1705              and wxTextCtrl under wxGTK (it also works  for  wxScrolled  (not
1706              implemented in wx) classes under all platforms).
1707
1708              See: scrollPages/2
1709
1710       scrollPages(This, Pages) -> boolean()
1711
1712              Types:
1713
1714                 This = wxWindow()
1715                 Pages = integer()
1716
1717              Scrolls  the  window by the given number of pages down (if pages
1718              is positive) or up.
1719
1720              Return: Returns true if the window was scrolled, false if it was
1721              already on top/bottom and nothing was done.
1722
1723              Remark:  This  function  is currently only implemented under MSW
1724              and wxGTK.
1725
1726              See: scrollLines/2
1727
1728       scrollWindow(This, Dx, Dy) -> ok
1729
1730              Types:
1731
1732                 This = wxWindow()
1733                 Dx = Dy = integer()
1734
1735       scrollWindow(This, Dx, Dy, Options :: [Option]) -> ok
1736
1737              Types:
1738
1739                 This = wxWindow()
1740                 Dx = Dy = integer()
1741                 Option =
1742                     {rect,
1743                      {X :: integer(),
1744                       Y :: integer(),
1745                       W :: integer(),
1746                       H :: integer()}}
1747
1748              Physically scrolls the pixels in the window and move child  win‐
1749              dows accordingly.
1750
1751              Remark:  Note that you can often use wxScrolled (not implemented
1752              in wx) instead of using this function directly.
1753
1754       setAcceleratorTable(This, Accel) -> ok
1755
1756              Types:
1757
1758                 This = wxWindow()
1759                 Accel = wxAcceleratorTable:wxAcceleratorTable()
1760
1761              Sets the accelerator table for this window.
1762
1763              See wxAcceleratorTable.
1764
1765       setAutoLayout(This, AutoLayout) -> ok
1766
1767              Types:
1768
1769                 This = wxWindow()
1770                 AutoLayout = boolean()
1771
1772              Determines whether the layout/1 function will be called automat‐
1773              ically when the window is resized.
1774
1775              This  method  is  called implicitly by setSizer/3 but if you use
1776              SetConstraints() (not implemented in wx) you should call it man‐
1777              ually  or otherwise the window layout won't be correctly updated
1778              when its size changes.
1779
1780              See: setSizer/3, SetConstraints() (not implemented in wx)
1781
1782       setBackgroundColour(This, Colour) -> boolean()
1783
1784              Types:
1785
1786                 This = wxWindow()
1787                 Colour = wx:wx_colour()
1788
1789              Sets the background colour of the window.
1790
1791              Notice that as with  setForegroundColour/2,  setting  the  back‐
1792              ground colour of a native control may not affect the entire con‐
1793              trol and could be not supported at all depending on the  control
1794              and platform.
1795
1796              Please see inheritAttributes/1 for explanation of the difference
1797              between this method and setOwnBackgroundColour/2.
1798
1799              Remark: The background colour is usually painted by the  default
1800              wxEraseEvent  event handler function under Windows and automati‐
1801              cally under GTK. Note that setting the  background  colour  does
1802              not  cause  an immediate refresh, so you may wish to call clear‐
1803              Background/1 or refresh/2 after  calling  this  function.  Using
1804              this  function will disable attempts to use themes for this win‐
1805              dow, if the system supports them. Use with  care  since  usually
1806              the  themes  represent  the  appearance chosen by the user to be
1807              used for all applications on the system.
1808
1809              Return: true if the colour was really changed, false if  it  was
1810              already set to this colour and nothing was done.
1811
1812              See:   getBackgroundColour/1,   setForegroundColour/2,  getFore‐
1813              groundColour/1,  clearBackground/1,   refresh/2,   wxEraseEvent,
1814              wxSystemSettings
1815
1816       setBackgroundStyle(This, Style) -> boolean()
1817
1818              Types:
1819
1820                 This = wxWindow()
1821                 Style = wx:wx_enum()
1822
1823              Sets the background style of the window.
1824
1825              The default background style is wxBG_STYLE_ERASE which indicates
1826              that the window background may be erased in EVT_ERASE_BACKGROUND
1827              handler.  This is a safe, compatibility default; however you may
1828              want to change it to wxBG_STYLE_SYSTEM if you don't  define  any
1829              erase  background  event  handlers  at all, to avoid unnecessary
1830              generation of erase background  events  and  always  let  system
1831              erase the background. And you should change the background style
1832              to wxBG_STYLE_PAINT if you define  an  EVT_PAINT  handler  which
1833              completely  overwrites  the  window  background  as in this case
1834              erasing it previously, either in EVT_ERASE_BACKGROUND handler or
1835              in  the  system  default handler, would result in flicker as the
1836              background pixels will be repainted twice every time the  window
1837              is  redrawn. Do ensure that the background is entirely erased by
1838              your EVT_PAINT handler in this case however as otherwise garbage
1839              may be left on screen.
1840
1841              Notice  that  in  previous versions of wxWidgets a common way to
1842              work around the above mentioned flickering problem was to define
1843              an  empty EVT_ERASE_BACKGROUND handler. Setting background style
1844              to wxBG_STYLE_PAINT is a simpler and more efficient solution  to
1845              the same problem.
1846
1847              Under  wxGTK  and  wxOSX, you can use ?wxBG_STYLE_TRANSPARENT to
1848              obtain full transparency of the  window  background.  Note  that
1849              wxGTK  supports this only since GTK 2.12 with a compositing man‐
1850              ager enabled, call IsTransparentBackgroundSupported()  (not  im‐
1851              plemented in wx) to check whether this is the case.
1852
1853              Also, in order for SetBackgroundStyle(wxBG_STYLE_TRANSPARENT) to
1854              work, it must be called before create/4. If  you're  using  your
1855              own  wxWindow-derived  class  you  should write your code in the
1856              following way:
1857
1858              See: setBackgroundColour/2, getForegroundColour/1,  setTranspar‐
1859              ent/2,  IsTransparentBackgroundSupported()  (not  implemented in
1860              wx)
1861
1862       setCaret(This, Caret) -> ok
1863
1864              Types:
1865
1866                 This = wxWindow()
1867                 Caret = wxCaret:wxCaret()
1868
1869              Sets the caret() associated with the window.
1870
1871       setClientSize(This, Size) -> ok
1872
1873       setClientSize(This, Rect) -> ok
1874
1875              Types:
1876
1877                 This = wxWindow()
1878                 Rect =
1879                     {X :: integer(),
1880                      Y :: integer(),
1881                      W :: integer(),
1882                      H :: integer()}
1883
1884              This is an overloaded member function, provided for convenience.
1885              It  differs  from the above function only in what argument(s) it
1886              accepts.
1887
1888       setClientSize(This, Width, Height) -> ok
1889
1890              Types:
1891
1892                 This = wxWindow()
1893                 Width = Height = integer()
1894
1895              This sets the size of the window client area in pixels.
1896
1897              Using this function to size a window tends to be more device-in‐
1898              dependent  than  setSize/6, since the application need not worry
1899              about what dimensions the border or title bar have  when  trying
1900              to fit the window around panel items, for example.
1901
1902              See: Overview windowsizing
1903
1904       setContainingSizer(This, Sizer) -> ok
1905
1906              Types:
1907
1908                 This = wxWindow()
1909                 Sizer = wxSizer:wxSizer()
1910
1911              Used by wxSizer internally to notify the window about being man‐
1912              aged by the given sizer.
1913
1914              This method should not be called from outside the  library,  un‐
1915              less  you're implementing a custom sizer class - and in the lat‐
1916              ter case you must call this method with the pointer to the sizer
1917              itself  whenever  a window is added to it and with NULL argument
1918              when the window is removed from it.
1919
1920       setCursor(This, Cursor) -> boolean()
1921
1922              Types:
1923
1924                 This = wxWindow()
1925                 Cursor = wxCursor:wxCursor()
1926
1927              Sets the window's cursor.
1928
1929              Notice that the window cursor also sets it for the  children  of
1930              the window implicitly.
1931
1932              The  cursor  may be wxNullCursor in which case the window cursor
1933              will be reset back to default.
1934
1935              See: wx_misc:setCursor/1, wxCursor
1936
1937       setMaxSize(This, Size) -> ok
1938
1939              Types:
1940
1941                 This = wxWindow()
1942                 Size = {W :: integer(), H :: integer()}
1943
1944              Sets the maximum size of the window, to indicate  to  the  sizer
1945              layout mechanism that this is the maximum possible size.
1946
1947              See:  SetMaxClientSize()  (not implemented in wx), Overview win‐
1948              dowsizing
1949
1950       setMinSize(This, Size) -> ok
1951
1952              Types:
1953
1954                 This = wxWindow()
1955                 Size = {W :: integer(), H :: integer()}
1956
1957              Sets the minimum size of the window, to indicate  to  the  sizer
1958              layout mechanism that this is the minimum required size.
1959
1960              You  may  need  to call this if you change the window size after
1961              construction and before adding to its parent sizer.
1962
1963              Notice that calling this method doesn't prevent the program from
1964              making  the window explicitly smaller than the specified size by
1965              calling setSize/6, it just ensures that it won't become  smaller
1966              than this size during the automatic layout.
1967
1968              See:  SetMinClientSize()  (not implemented in wx), Overview win‐
1969              dowsizing
1970
1971       setOwnBackgroundColour(This, Colour) -> ok
1972
1973              Types:
1974
1975                 This = wxWindow()
1976                 Colour = wx:wx_colour()
1977
1978              Sets the background colour of the window but  prevents  it  from
1979              being inherited by the children of this window.
1980
1981              See: setBackgroundColour/2, inheritAttributes/1
1982
1983       setOwnFont(This, Font) -> ok
1984
1985              Types:
1986
1987                 This = wxWindow()
1988                 Font = wxFont:wxFont()
1989
1990              Sets the font of the window but prevents it from being inherited
1991              by the children of this window.
1992
1993              See: setFont/2, inheritAttributes/1
1994
1995       setOwnForegroundColour(This, Colour) -> ok
1996
1997              Types:
1998
1999                 This = wxWindow()
2000                 Colour = wx:wx_colour()
2001
2002              Sets the foreground colour of the window but  prevents  it  from
2003              being inherited by the children of this window.
2004
2005              See: setForegroundColour/2, inheritAttributes/1
2006
2007       setDropTarget(This, Target) -> ok
2008
2009              Types:
2010
2011                 This = wxWindow()
2012                 Target = wx:wx_object()
2013
2014              Associates a drop target with this window.
2015
2016              If the window already has a drop target, it is deleted.
2017
2018              See: getDropTarget/1, Overview dnd
2019
2020       setExtraStyle(This, ExStyle) -> ok
2021
2022              Types:
2023
2024                 This = wxWindow()
2025                 ExStyle = integer()
2026
2027              Sets the extra style bits for the window.
2028
2029              The currently defined extra style bits are reported in the class
2030              description.
2031
2032       setFocus(This) -> ok
2033
2034              Types:
2035
2036                 This = wxWindow()
2037
2038              This sets the window to receive keyboard input.
2039
2040              See: HasFocus() (not implemented in  wx),  wxFocusEvent,  setFo‐
2041              cus/1, wxPanel:setFocusIgnoringChildren/1
2042
2043       setFocusFromKbd(This) -> ok
2044
2045              Types:
2046
2047                 This = wxWindow()
2048
2049              This  function  is  called by wxWidgets keyboard navigation code
2050              when the user gives the focus to this window from keyboard (e.g.
2051              using TAB key).
2052
2053              By  default this method simply calls setFocus/1 but can be over‐
2054              ridden to do something  in  addition  to  this  in  the  derived
2055              classes.
2056
2057       setFont(This, Font) -> boolean()
2058
2059              Types:
2060
2061                 This = wxWindow()
2062                 Font = wxFont:wxFont()
2063
2064              Sets the font for this window.
2065
2066              This  function should not be called for the parent window if you
2067              don't want its font to be inherited by its children, use setOwn‐
2068              Font/2 instead in this case and see inheritAttributes/1 for more
2069              explanations.
2070
2071              Please notice that the given font is not automatically used  for
2072              wxPaintDC  objects associated with this window, you need to call
2073              wxDC:setFont/2 too. However this font is used  by  any  standard
2074              controls for drawing their text as well as by getTextExtent/3.
2075
2076              Return: true if the font was really changed, false if it was al‐
2077              ready set to this font and nothing was done.
2078
2079              See: getFont/1, inheritAttributes/1
2080
2081       setForegroundColour(This, Colour) -> boolean()
2082
2083              Types:
2084
2085                 This = wxWindow()
2086                 Colour = wx:wx_colour()
2087
2088              Sets the foreground colour of the window.
2089
2090              The meaning of foreground colour varies according to the  window
2091              class;  it may be the text colour or other colour, or it may not
2092              be used at all. Additionally, not all  native  controls  support
2093              changing their foreground colour so this method may change their
2094              colour only partially or even not at all.
2095
2096              Please see inheritAttributes/1 for explanation of the difference
2097              between this method and setOwnForegroundColour/2.
2098
2099              Return:  true  if the colour was really changed, false if it was
2100              already set to this colour and nothing was done.
2101
2102              See:  getForegroundColour/1,   setBackgroundColour/2,   getBack‐
2103              groundColour/1, shouldInheritColours/1
2104
2105       setHelpText(This, HelpText) -> ok
2106
2107              Types:
2108
2109                 This = wxWindow()
2110                 HelpText = unicode:chardata()
2111
2112              Sets the help text to be used as context-sensitive help for this
2113              window.
2114
2115              Note that the text is actually stored  by  the  current  wxHelp‐
2116              Provider  (not implemented in wx) implementation, and not in the
2117              window object itself.
2118
2119              See: getHelpText/1, wxHelpProvider::AddHelp()  (not  implemented
2120              in wx)
2121
2122       setId(This, Winid) -> ok
2123
2124              Types:
2125
2126                 This = wxWindow()
2127                 Winid = integer()
2128
2129              Sets the identifier of the window.
2130
2131              Remark:  Each  window has an integer identifier. If the applica‐
2132              tion has not provided one, an identifier will be generated. Nor‐
2133              mally,  the identifier should be provided on creation and should
2134              not be modified subsequently.
2135
2136              See: getId/1, Overview windowids
2137
2138       setLabel(This, Label) -> ok
2139
2140              Types:
2141
2142                 This = wxWindow()
2143                 Label = unicode:chardata()
2144
2145              Sets the window's label.
2146
2147              See: getLabel/1
2148
2149       setName(This, Name) -> ok
2150
2151              Types:
2152
2153                 This = wxWindow()
2154                 Name = unicode:chardata()
2155
2156              Sets the window's name.
2157
2158              See: getName/1
2159
2160       setPalette(This, Pal) -> ok
2161
2162              Types:
2163
2164                 This = wxWindow()
2165                 Pal = wxPalette:wxPalette()
2166
2167              Deprecated: use wxDC:setPalette/2 instead.
2168
2169       setScrollbar(This, Orientation, Position, ThumbSize, Range) -> ok
2170
2171              Types:
2172
2173                 This = wxWindow()
2174                 Orientation = Position = ThumbSize = Range = integer()
2175
2176       setScrollbar(This, Orientation, Position, ThumbSize, Range,
2177                    Options :: [Option]) ->
2178                       ok
2179
2180              Types:
2181
2182                 This = wxWindow()
2183                 Orientation = Position = ThumbSize = Range = integer()
2184                 Option = {refresh, boolean()}
2185
2186              Sets the scrollbar properties of a built-in scrollbar.
2187
2188              Remark: Let's say you wish to display 50 lines  of  text,  using
2189              the  same  font. The window is sized so that you can only see 16
2190              lines at a time. You would use: Note that  with  the  window  at
2191              this size, the thumb position can never go above 50 minus 16, or
2192              34. You can determine how many lines are  currently  visible  by
2193              dividing  the  current view size by the character height in pix‐
2194              els. When defining your own scrollbar behaviour, you will always
2195              need  to recalculate the scrollbar settings when the window size
2196              changes. You could therefore put your scrollbar calculations and
2197              SetScrollbar  call into a function named AdjustScrollbars, which
2198              can be called initially and also from your  wxSizeEvent  handler
2199              function.
2200
2201              See:  Overview  scrolling,  wxScrollBar,  wxScrolled (not imple‐
2202              mented in wx), wxScrollWinEvent
2203
2204       setScrollPos(This, Orientation, Pos) -> ok
2205
2206              Types:
2207
2208                 This = wxWindow()
2209                 Orientation = Pos = integer()
2210
2211       setScrollPos(This, Orientation, Pos, Options :: [Option]) -> ok
2212
2213              Types:
2214
2215                 This = wxWindow()
2216                 Orientation = Pos = integer()
2217                 Option = {refresh, boolean()}
2218
2219              Sets the position of one of the built-in scrollbars.
2220
2221              Remark: This function does not directly affect the  contents  of
2222              the  window: it is up to the application to take note of scroll‐
2223              bar attributes and redraw contents accordingly.
2224
2225              See: setScrollbar/6, getScrollPos/2, getScrollThumb/2, wxScroll‐
2226              Bar, wxScrolled (not implemented in wx)
2227
2228       setSize(This, Rect) -> ok
2229
2230       setSize(This, Size) -> ok
2231
2232              Types:
2233
2234                 This = wxWindow()
2235                 Size = {W :: integer(), H :: integer()}
2236
2237              This is an overloaded member function, provided for convenience.
2238              It differs from the above function only in what  argument(s)  it
2239              accepts.
2240
2241       setSize(This, Width, Height) -> ok
2242
2243       setSize(This, Rect, Height :: [Option]) -> ok
2244
2245              Types:
2246
2247                 This = wxWindow()
2248                 Rect =
2249                     {X :: integer(),
2250                      Y :: integer(),
2251                      W :: integer(),
2252                      H :: integer()}
2253                 Option = {sizeFlags, integer()}
2254
2255              Sets the size of the window in pixels.
2256
2257              The  size is specified using a {X,Y,W,H}, {Width,Height} or by a
2258              couple of int objects.
2259
2260              Remark: This form must be used with non-default width and height
2261              values.
2262
2263              See: move/4, Overview windowsizing
2264
2265       setSize(This, X, Y, Width, Height) -> ok
2266
2267              Types:
2268
2269                 This = wxWindow()
2270                 X = Y = Width = Height = integer()
2271
2272       setSize(This, X, Y, Width, Height, Options :: [Option]) -> ok
2273
2274              Types:
2275
2276                 This = wxWindow()
2277                 X = Y = Width = Height = integer()
2278                 Option = {sizeFlags, integer()}
2279
2280              Sets the size of the window in pixels.
2281
2282              Remark:  This overload sets the position and optionally size, of
2283              the window. Parameters may be wxDefaultCoord to indicate  either
2284              that a default should be supplied by wxWidgets, or that the cur‐
2285              rent value of the dimension should be used.
2286
2287              See: move/4, Overview windowsizing
2288
2289       setSizeHints(This, MinSize) -> ok
2290
2291              Types:
2292
2293                 This = wxWindow()
2294                 MinSize = {W :: integer(), H :: integer()}
2295
2296       setSizeHints(This, MinW, MinH) -> ok
2297
2298       setSizeHints(This, MinSize, MinH :: [Option]) -> ok
2299
2300              Types:
2301
2302                 This = wxWindow()
2303                 MinSize = {W :: integer(), H :: integer()}
2304                 Option =
2305                     {maxSize, {W :: integer(), H :: integer()}} |
2306                     {incSize, {W :: integer(), H :: integer()}}
2307
2308              Use of this function for windows which are not toplevel  windows
2309              (such as wxDialog or wxFrame) is discouraged.
2310
2311              Please use setMinSize/2 and setMaxSize/2 instead.
2312
2313              See: setSizeHints/4, Overview windowsizing
2314
2315       setSizeHints(This, MinW, MinH, Options :: [Option]) -> ok
2316
2317              Types:
2318
2319                 This = wxWindow()
2320                 MinW = MinH = integer()
2321                 Option =
2322                     {maxW, integer()} |
2323                     {maxH, integer()} |
2324                     {incW, integer()} |
2325                     {incH, integer()}
2326
2327              This is an overloaded member function, provided for convenience.
2328              It differs from the above function only in what  argument(s)  it
2329              accepts.
2330
2331       setSizer(This, Sizer) -> ok
2332
2333              Types:
2334
2335                 This = wxWindow()
2336                 Sizer = wxSizer:wxSizer()
2337
2338       setSizer(This, Sizer, Options :: [Option]) -> ok
2339
2340              Types:
2341
2342                 This = wxWindow()
2343                 Sizer = wxSizer:wxSizer()
2344                 Option = {deleteOld, boolean()}
2345
2346              Sets the window to have the given layout sizer.
2347
2348              The  window  will then own the object, and will take care of its
2349              deletion. If an existing layout constraints  object  is  already
2350              owned by the window, it will be deleted if the deleteOld parame‐
2351              ter is true.
2352
2353              Note that this function will also call  setAutoLayout/2  implic‐
2354              itly with true parameter if the sizer is non-NULL and false oth‐
2355              erwise so that the sizer will be effectively used to layout  the
2356              window children whenever it is resized.
2357
2358              Remark: SetSizer enables and disables Layout automatically.
2359
2360       setSizerAndFit(This, Sizer) -> ok
2361
2362              Types:
2363
2364                 This = wxWindow()
2365                 Sizer = wxSizer:wxSizer()
2366
2367       setSizerAndFit(This, Sizer, Options :: [Option]) -> ok
2368
2369              Types:
2370
2371                 This = wxWindow()
2372                 Sizer = wxSizer:wxSizer()
2373                 Option = {deleteOld, boolean()}
2374
2375              Associate  the sizer with the window and set the window size and
2376              minimal size accordingly.
2377
2378              This method calls  setSizer/3  and  then  wxSizer:setSizeHints/2
2379              which  sets the initial window size to the size needed to accom‐
2380              modate all sizer elements and sets the minimal size to the  same
2381              size,  this  preventing the user from resizing this window to be
2382              less than this minimal size (if it's a  top-level  window  which
2383              can be directly resized by the user).
2384
2385       setThemeEnabled(This, Enable) -> ok
2386
2387              Types:
2388
2389                 This = wxWindow()
2390                 Enable = boolean()
2391
2392              This  function  tells  a  window  if  it should use the system's
2393              "theme" code to draw the windows' background instead of its  own
2394              background drawing code.
2395
2396              This  does not always have any effect since the underlying plat‐
2397              form obviously needs to support the notion of themes in user de‐
2398              fined  windows. One such platform is GTK+ where windows can have
2399              (very colourful) backgrounds defined by a user's selected theme.
2400
2401              Dialogs, notebook pages and the status bar have this flag set to
2402              true  by  default so that the default look and feel is simulated
2403              best.
2404
2405              See: getThemeEnabled/1
2406
2407       setToolTip(This, TipString) -> ok
2408
2409       setToolTip(This, Tip) -> ok
2410
2411              Types:
2412
2413                 This = wxWindow()
2414                 Tip = wxToolTip:wxToolTip()
2415
2416              This is an overloaded member function, provided for convenience.
2417              It  differs  from the above function only in what argument(s) it
2418              accepts.
2419
2420       setVirtualSize(This, Size) -> ok
2421
2422              Types:
2423
2424                 This = wxWindow()
2425                 Size = {W :: integer(), H :: integer()}
2426
2427              This is an overloaded member function, provided for convenience.
2428              It  differs  from the above function only in what argument(s) it
2429              accepts.
2430
2431       setVirtualSize(This, Width, Height) -> ok
2432
2433              Types:
2434
2435                 This = wxWindow()
2436                 Width = Height = integer()
2437
2438              Sets the virtual size of the window in pixels.
2439
2440              See: Overview windowsizing
2441
2442       setWindowStyle(This, Style) -> ok
2443
2444              Types:
2445
2446                 This = wxWindow()
2447                 Style = integer()
2448
2449              See setWindowStyleFlag/2 for more info.
2450
2451       setWindowStyleFlag(This, Style) -> ok
2452
2453              Types:
2454
2455                 This = wxWindow()
2456                 Style = integer()
2457
2458              Sets the style of the window.
2459
2460              Please note that some styles cannot be changed after the  window
2461              creation and that refresh/2 might need to be called after chang‐
2462              ing the others for the change to take place immediately.
2463
2464              See Window styles for more information about flags.
2465
2466              See: getWindowStyleFlag/1
2467
2468       setWindowVariant(This, Variant) -> ok
2469
2470              Types:
2471
2472                 This = wxWindow()
2473                 Variant = wx:wx_enum()
2474
2475              Chooses a different variant of the window display to use.
2476
2477              Window variants currently just differ in size, as  can  be  seen
2478              from  ?wxWindowVariant  documentation.  Under  all platforms but
2479              macOS, this function does nothing more than change the font used
2480              by  the  window.  However under macOS it is implemented natively
2481              and selects the appropriate variant of the native widget,  which
2482              has better appearance than just scaled down or up version of the
2483              normal variant, so it should be preferred to  directly  tweaking
2484              the font size.
2485
2486              By default the controls naturally use the normal variant.
2487
2488       shouldInheritColours(This) -> boolean()
2489
2490              Types:
2491
2492                 This = wxWindow()
2493
2494              Return  true from here to allow the colours of this window to be
2495              changed by inheritAttributes/1.
2496
2497              Returning false forbids inheriting them from the parent window.
2498
2499              The base class version returns false, but this method  is  over‐
2500              ridden in wxControl where it returns true.
2501
2502       show(This) -> boolean()
2503
2504              Types:
2505
2506                 This = wxWindow()
2507
2508       show(This, Options :: [Option]) -> boolean()
2509
2510              Types:
2511
2512                 This = wxWindow()
2513                 Option = {show, boolean()}
2514
2515              Shows or hides the window.
2516
2517              You  may need to call raise/1 for a top level window if you want
2518              to bring it to top, although this is not  needed  if  show/2  is
2519              called immediately after the frame creation.
2520
2521              Notice that the default state of newly created top level windows
2522              is hidden  (to  allow  you  to  create  their  contents  without
2523              flicker)  unlike for all the other, not derived from wxTopLevel‐
2524              Window, windows that are by default created in the shown state.
2525
2526              Return: true if the window has been shown or hidden or false  if
2527              nothing was done because it already was in the requested state.
2528
2529              See: isShown/1, hide/1, wxRadioBox:show/3, wxShowEvent
2530
2531       thaw(This) -> ok
2532
2533              Types:
2534
2535                 This = wxWindow()
2536
2537              Re-enables window updating after a previous call to freeze/1.
2538
2539              To  really  thaw the control, it must be called exactly the same
2540              number of times as freeze/1.
2541
2542              If the window has any children, they are recursively thawed too.
2543
2544              See: wxWindowUpdateLocker (not implemented in wx), freeze/1, is‐
2545              Frozen/1
2546
2547       transferDataFromWindow(This) -> boolean()
2548
2549              Types:
2550
2551                 This = wxWindow()
2552
2553              Transfers  values from child controls to data areas specified by
2554              their validators.
2555
2556              Returns false if a transfer failed.
2557
2558              Notice that this also  calls  transferDataFromWindow/1  for  all
2559              children recursively.
2560
2561              See:  transferDataToWindow/1,  wxValidator  (not  implemented in
2562              wx), validate/1
2563
2564       transferDataToWindow(This) -> boolean()
2565
2566              Types:
2567
2568                 This = wxWindow()
2569
2570              Transfers values to child controls from data areas specified  by
2571              their validators.
2572
2573              Notice that this also calls transferDataToWindow/1 for all chil‐
2574              dren recursively.
2575
2576              Return: Returns false if a transfer failed.
2577
2578              See: transferDataFromWindow/1, wxValidator (not  implemented  in
2579              wx), validate/1
2580
2581       update(This) -> ok
2582
2583              Types:
2584
2585                 This = wxWindow()
2586
2587              Calling this method immediately repaints the invalidated area of
2588              the window and all of its children  recursively  (this  normally
2589              only  happens  when  the  flow  of  control returns to the event
2590              loop).
2591
2592              Notice that this function doesn't invalidate  any  area  of  the
2593              window  so nothing happens if nothing has been invalidated (i.e.
2594              marked as requiring a redraw). Use refresh/2 first if  you  want
2595              to immediately redraw the window unconditionally.
2596
2597       updateWindowUI(This) -> ok
2598
2599              Types:
2600
2601                 This = wxWindow()
2602
2603       updateWindowUI(This, Options :: [Option]) -> ok
2604
2605              Types:
2606
2607                 This = wxWindow()
2608                 Option = {flags, integer()}
2609
2610              This function sends one or more wxUpdateUIEvent to the window.
2611
2612              The particular implementation depends on the window; for example
2613              a wxToolBar will send an update UI event for each  toolbar  but‐
2614              ton, and a wxFrame will send an update UI event for each menubar
2615              menu item.
2616
2617              You can call this function from your application to ensure  that
2618              your  UI  is  up-to-date  at  this point (as far as your wxUpda‐
2619              teUIEvent handlers are concerned). This may be necessary if  you
2620              have  called wxUpdateUIEvent:setMode/1 or wxUpdateUIEvent:setUp‐
2621              dateInterval/1 to limit the overhead that  wxWidgets  incurs  by
2622              sending update UI events in idle time. flags should be a bitlist
2623              of one or more of the ?wxUpdateUI enumeration.
2624
2625              If you are calling  this  function  from  an  OnInternalIdle  or
2626              OnIdle  function,  make  sure  you pass the wxUPDATE_UI_FROMIDLE
2627              flag, since this tells the window to only update the UI elements
2628              that  need to be updated in idle time. Some windows update their
2629              elements only when necessary, for example when a menu  is  about
2630              to  be  shown.  The  following  is an example of how to call Up‐
2631              dateWindowUI from an idle function.
2632
2633              See: wxUpdateUIEvent,  DoUpdateWindowUI()  (not  implemented  in
2634              wx), OnInternalIdle() (not implemented in wx)
2635
2636       validate(This) -> boolean()
2637
2638              Types:
2639
2640                 This = wxWindow()
2641
2642              Validates  the  current values of the child controls using their
2643              validators.
2644
2645              Notice that this also calls validate/1 for all  children  recur‐
2646              sively.
2647
2648              Return: Returns false if any of the validations failed.
2649
2650              See: transferDataFromWindow/1, transferDataToWindow/1, wxValida‐
2651              tor (not implemented in wx)
2652
2653       warpPointer(This, X, Y) -> ok
2654
2655              Types:
2656
2657                 This = wxWindow()
2658                 X = Y = integer()
2659
2660              Moves the pointer to the given position on the window.
2661
2662              Note: Apple Human Interface Guidelines forbid moving  the  mouse
2663              cursor  programmatically so you should avoid using this function
2664              in Mac applications (and probably avoid using it under the other
2665              platforms without good reason as well).
2666
2667       setTransparent(This, Alpha) -> boolean()
2668
2669              Types:
2670
2671                 This = wxWindow()
2672                 Alpha = integer()
2673
2674              Set the transparency of the window.
2675
2676              If the system supports transparent windows, returns true, other‐
2677              wise returns false and the window remains fully opaque. See also
2678              canSetTransparent/1.
2679
2680              The  parameter  alpha is in the range 0..255 where 0 corresponds
2681              to a fully transparent window and 255 to the fully  opaque  one.
2682              The constants wxIMAGE_ALPHA_TRANSPARENT and wxIMAGE_ALPHA_OPAQUE
2683              can be used.
2684
2685       canSetTransparent(This) -> boolean()
2686
2687              Types:
2688
2689                 This = wxWindow()
2690
2691              Returns true if the  system  supports  transparent  windows  and
2692              calling setTransparent/2 may succeed.
2693
2694              If  this  function  returns false, transparent windows are defi‐
2695              nitely not supported by the current system.
2696
2697       isDoubleBuffered(This) -> boolean()
2698
2699              Types:
2700
2701                 This = wxWindow()
2702
2703              Returns true if the window contents is  double-buffered  by  the
2704              system, i.e. if any drawing done on the window is really done on
2705              a temporary backing surface and transferred to the screen all at
2706              once later.
2707
2708              See: wxBufferedDC
2709
2710       setDoubleBuffered(This, On) -> ok
2711
2712              Types:
2713
2714                 This = wxWindow()
2715                 On = boolean()
2716
2717              Turn on or off double buffering of the window if the system sup‐
2718              ports it.
2719
2720       getContentScaleFactor(This) -> number()
2721
2722              Types:
2723
2724                 This = wxWindow()
2725
2726              Returns the factor mapping logical  pixels  of  this  window  to
2727              physical pixels.
2728
2729              This  function  can  be used to portably determine the number of
2730              physical pixels in a window of the given  size,  by  multiplying
2731              the  window  size by the value returned from it. I.e. it returns
2732              the factor converting window coordinates to "content view" coor‐
2733              dinates, where the view can be just a simple window displaying a
2734              wxBitmap or wxGLCanvas or any other kind of window rendering ar‐
2735              bitrary "content" on screen.
2736
2737              For  the platforms not doing any pixel mapping, i.e. where logi‐
2738              cal and physical pixels are one and the same, this function  al‐
2739              ways  returns  1.0 and so using it is, in principle, unnecessary
2740              and could  be  avoided  by  using  preprocessor  check  for  wx‐
2741              HAVE_DPI_INDEPENDENT_PIXELS  not  being  defined,  however using
2742              this function unconditionally under  all  platforms  is  usually
2743              simpler and so preferable.
2744
2745              Note:  Current  behaviour  of  this  function is compatible with
2746              wxWidgets 3.0, but different  from  its  behaviour  in  versions
2747              3.1.0 to 3.1.3, where it returned the same value as getDPIScale‐
2748              Factor/1. Please use the other function if you  need  to  use  a
2749              scaling  factor  greater than 1.0 even for the platforms without
2750              wxHAVE_DPI_INDEPENDENT_PIXELS, such as wxMSW.
2751
2752              Since: 2.9.5
2753
2754       getDPI(This) -> {W :: integer(), H :: integer()}
2755
2756              Types:
2757
2758                 This = wxWindow()
2759
2760              Return the DPI of the display used by this window.
2761
2762              The returned value can be different  for  different  windows  on
2763              systems  with support for per-monitor DPI values, such as Micro‐
2764              soft Windows 10.
2765
2766              If the DPI is not available, returns {Width,Height} object.
2767
2768              See: wxDisplay:getPPI/1, wxDPIChangedEvent (not  implemented  in
2769              wx)
2770
2771              Since: 3.1.3
2772
2773       fromDIP(D, W) -> integer()
2774
2775       fromDIP(Sz, W) -> {W :: integer(), H :: integer()}
2776
2777       fromDIP(This, D) -> integer()
2778
2779       fromDIP(This, Sz) -> {W :: integer(), H :: integer()}
2780
2781              Types:
2782
2783                 This = wxWindow()
2784                 Sz = {W :: integer(), H :: integer()}
2785
2786              Convert  DPI-independent pixel values to the value in pixels ap‐
2787              propriate for the current toolkit.
2788
2789              A DPI-independent pixel is just a pixel at the standard  96  DPI
2790              resolution. To keep the same physical size at higher resolution,
2791              the physical pixel value must be scaled  by  getDPIScaleFactor/1
2792              but  this  scaling may be already done by the underlying toolkit
2793              (GTK+, Cocoa, ...) automatically. This method performs the  con‐
2794              version  only if it is not already done by the lower level tool‐
2795              kit and so by using it with pixel values you can guarantee  that
2796              the  physical size of the corresponding elements will remain the
2797              same in all resolutions under all platforms.  For  example,  in‐
2798              stead  of  creating a bitmap of the hard coded size of 32 pixels
2799              you should use to avoid using tiny bitmaps on high DPI screens.
2800
2801              Notice that this function is only needed when using  hard  coded
2802              pixel values. It is not necessary if the sizes are already based
2803              on the DPI-independent units such as dialog units or if you  are
2804              relying  on  the  controls automatic best size determination and
2805              using sizers to lay out them.
2806
2807              Also note that if either component of sz has the  special  value
2808              of  -1,  it  is  returned unchanged independently of the current
2809              DPI, to preserve the special value of -1 in wxWidgets API (it is
2810              often used to mean "unspecified").
2811
2812              Since: 3.1.0
2813
2814       toDIP(D, W) -> integer()
2815
2816       toDIP(Sz, W) -> {W :: integer(), H :: integer()}
2817
2818       toDIP(This, D) -> integer()
2819
2820       toDIP(This, Sz) -> {W :: integer(), H :: integer()}
2821
2822              Types:
2823
2824                 This = wxWindow()
2825                 Sz = {W :: integer(), H :: integer()}
2826
2827              Convert  pixel  values of the current toolkit to DPI-independent
2828              pixel values.
2829
2830              A DPI-independent pixel is just a pixel at the standard  96  DPI
2831              resolution. To keep the same physical size at higher resolution,
2832              the physical pixel value must be scaled  by  getDPIScaleFactor/1
2833              but  this  scaling may be already done by the underlying toolkit
2834              (GTK+, Cocoa, ...) automatically. This method performs the  con‐
2835              version  only if it is not already done by the lower level tool‐
2836              kit, For example, you may want to use this to store window sizes
2837              and positions so that they can be re-used regardless of the dis‐
2838              play DPI:
2839
2840              Also note that if either component of sz has the  special  value
2841              of  -1,  it  is  returned unchanged independently of the current
2842              DPI, to preserve the special value of -1 in wxWidgets API (it is
2843              often used to mean "unspecified").
2844
2845              Since: 3.1.0
2846
2847
2848
2849wxWidgets team.                     wx 2.1                         wxWindow(3)
Impressum