1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: SWIG interface for wxWindow
7 // Created: 24-June-1997
9 // Copyright: (c) 2003 by Total Control Software
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
16 //---------------------------------------------------------------------------
21 MAKE_CONST_WXSTRING(PanelNameStr);
23 //---------------------------------------------------------------------------
27 wxLIST_WRAPPER(wxWindowList, wxWindow);
30 DocStr(wxVisualAttributes,
31 "struct containing all the visual attributes of a control", "");
33 struct wxVisualAttributes
36 wxVisualAttributes() { return new wxVisualAttributes; }
37 ~wxVisualAttributes() { delete self; }
40 // // the font used for control label/text inside it
42 // // the foreground colour
44 // // the background colour, may be wxNullColour if the controls background
45 // // colour is not solid
48 // Use our own getters and properties instead of the ones that SWIG will
49 // generate, so copies of the attributes will be made when they are
50 // accessed, instead of using a pointer to the one in the object which may
53 wxFont _get_font() { return self->font; }
54 wxColour _get_colFg() { return self->colFg; }
55 wxColour _get_colBg() { return self->colBg; }
58 %property(font, _get_font)
59 %property(colFg, _get_colFg)
60 %property(colBg, _get_colBg)
68 wxWINDOW_VARIANT_NORMAL, // Normal size
69 wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal )
70 wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal )
71 wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal )
77 "wx.Window is the base class for all windows and represents any visible
78 object on the screen. All controls, top level windows and so on are
79 wx.Windows. Sizers and device contexts are not however, as they don't
80 appear on screen themselves.
85 ============================= =====================================
86 wx.SIMPLE_BORDER Displays a thin border around the window.
88 wx.DOUBLE_BORDER Displays a double border. Windows and Mac only.
90 wx.SUNKEN_BORDER Displays a sunken border.
92 wx.RAISED_BORDER Displays a raised border.
94 wx.STATIC_BORDER Displays a border suitable for a static
95 control. Windows only.
97 wx.NO_BORDER Displays no border, overriding the default
98 border style for the window.
100 wx.TRANSPARENT_WINDOW The window is transparent, that is, it
101 will not receive paint events. Windows only.
103 wx.TAB_TRAVERSAL Use this to enable tab traversal for
106 wx.WANTS_CHARS Use this to indicate that the window
107 wants to get all char/key events for
108 all keys - even for keys like TAB or
109 ENTER which are usually used for
110 dialog navigation and which wouldn't
111 be generated without this style. If
112 you need to use this style in order to
113 get the arrows or etc., but would
114 still like to have normal keyboard
115 navigation take place, you should
116 create and send a wxNavigationKeyEvent
117 in response to the key events for Tab
120 wx.NO_FULL_REPAINT_ON_RESIZE Disables repainting the window
121 completely when its size is changed.
122 You will have to repaint the new
123 window area manually if you use this
124 style. As of version 2.5.1 this
125 style is on by default. Use
126 wx.FULL_REPAINT_ON_RESIZE to
129 wx.VSCROLL Use this style to enable a vertical scrollbar.
130 Notice that this style cannot be used with
131 native controls which don't support scrollbars
132 nor with top-level windows in most ports.
134 wx.HSCROLL Use this style to enable a horizontal scrollbar.
135 The same limitations as for wx.VSCROLL apply to
138 wx.ALWAYS_SHOW_SB If a window has scrollbars, disable them
139 instead of hiding them when they are
140 not needed (i.e. when the size of the
141 window is big enough to not require
142 the scrollbars to navigate it). This
143 style is currently only implemented
144 for wxMSW and wxUniversal and does
145 nothing on the other platforms.
147 wx.CLIP_CHILDREN Use this style to eliminate flicker caused by
148 the background being repainted, then
149 children being painted over
152 wx.FULL_REPAINT_ON_RESIZE Use this style to force a complete
153 redraw of the window whenever it is
154 resized instead of redrawing just the
155 part of the window affected by
156 resizing. Note that this was the
157 behaviour by default before 2.5.1
158 release and that if you experience
159 redraw problems with the code which
160 previously used to work you may want
162 ============================= =====================================
167 ============================= =====================================
168 wx.WS_EX_VALIDATE_RECURSIVELY By default,
169 Validate/TransferDataTo/FromWindow()
170 only work on direct children of
171 the window (compatible
172 behaviour). Set this flag to make
173 them recursively descend into all
176 wx.WS_EX_BLOCK_EVENTS wx.CommandEvents and the objects of the
177 derived classes are forwarded to
178 the parent window and so on
179 recursively by default. Using this
180 flag for the given window allows
181 to block this propagation at this
182 window, i.e. prevent the events
183 from being propagated further
184 upwards. Dialogs have this flag on
187 wx.WS_EX_TRANSIENT Don't use this window as an implicit parent for
188 the other windows: this must be
189 used with transient windows as
190 otherwise there is the risk of
191 creating a dialog/frame with this
192 window as a parent which would
193 lead to a crash if the parent is
194 destroyed before the child.
196 wx.WS_EX_PROCESS_IDLE This window should always process idle
197 events, even if the mode set by
198 `wx.IdleEvent.SetMode` is
199 wx.IDLE_PROCESS_SPECIFIED.
201 wx.WS_EX_PROCESS_UI_UPDATES This window should always process UI
202 update events, even if the mode
203 set by `wx.UpdateUIEvent.SetMode` is
204 wxUPDATE_UI_PROCESS_SPECIFIED.
205 ============================= =====================================
210 MustHaveApp(wxWindow);
211 MustHaveApp(wxWindow::FindFocus);
212 MustHaveApp(wxWindow::GetCapture);
214 // This one is not restricted to wxWindow
215 MustHaveApp(GetClassDefaultAttributes);
217 class wxWindow : public wxEvtHandler
220 %pythonAppend wxWindow "self._setOORInfo(self)"
221 %pythonAppend wxWindow() ""
222 %typemap(out) wxWindow*; // turn off this typemap
225 wxWindow(wxWindow* parent, const wxWindowID id=-1,
226 const wxPoint& pos = wxDefaultPosition,
227 const wxSize& size = wxDefaultSize,
229 const wxString& name = wxPyPanelNameStr),
230 "Construct and show a generic Window.", "");
234 "Precreate a Window for 2-phase creation.", "",
237 // Turn it back on again
238 %typemap(out) wxWindow* { $result = wxPyMake_wxObject($1, $owner); }
242 bool , Create(wxWindow* parent, const wxWindowID id=-1,
243 const wxPoint& pos = wxDefaultPosition,
244 const wxSize& size = wxDefaultSize,
246 const wxString& name = wxPyPanelNameStr),
247 "Create the GUI part of the Window for 2-phase creation mode.", "");
250 // deleting the window
251 // -------------------
255 bool , Close( bool force = false ),
256 "This function simply generates a EVT_CLOSE event whose handler usually
257 tries to close the window. It doesn't close the window itself,
258 however. If force is False (the default) then the window's close
259 handler will be allowed to veto the destruction of the window.",
261 Usually Close is only used with the top level windows (wx.Frame and
262 wx.Dialog classes) as the others are not supposed to have any special
265 The close handler should check whether the window is being deleted
266 forcibly, using wx.CloseEvent.GetForce, in which case it should
267 destroy the window using wx.Window.Destroy.
269 Note that calling Close does not guarantee that the window will be
270 destroyed; but it provides a way to simulate a manual close of a
271 window, which may or may not be implemented by destroying the
272 window. The default EVT_CLOSE handler for wx.Dialog does not
273 necessarily delete the dialog, since it will simply simulate an
274 wxID_CANCEL event which is handled by the appropriate button event
275 handler and may do anything at all.
277 To guarantee that the window will be destroyed, call wx.Window.Destroy
282 %pythonPrepend Destroy "args[0].this.own(False)"
284 virtual bool , Destroy(),
285 "Destroys the window safely. Frames and dialogs are not destroyed
286 immediately when this function is called -- they are added to a list
287 of windows to be deleted on idle time, when all the window's events
288 have been processed. This prevents problems with events being sent to
289 non-existent windows.
291 Returns True if the window has either been successfully deleted, or it
292 has been added to the list of windows pending real deletion.", "");
296 bool , DestroyChildren(),
297 "Destroys all children of a window. Called automatically by the
302 bool , IsBeingDeleted() const,
303 "Is the window in the process of being deleted?", "");
311 // virtual void , SetTitle( const wxString& title),
312 // "Sets the window's title. Applicable only to frames and dialogs.", "");
315 // virtual wxString , GetTitle() const,
316 // "Gets the window's title. Applicable only to frames and dialogs.", "");
319 virtual void , SetLabel(const wxString& label),
320 "Set the text which the window shows in its label if applicable.", "");
323 virtual wxString , GetLabel() const,
324 "Generic way of getting a label from any window, for identification
325 purposes. The interpretation of this function differs from class to
326 class. For frames and dialogs, the value returned is the title. For
327 buttons or static text controls, it is the button text. This function
328 can be useful for meta-programs such as testing tools or special-needs
329 access programs)which need to identify windows by name.", "");
333 virtual void , SetName( const wxString &name ),
334 "Sets the window's name. The window name is used for ressource setting
335 in X, it is not the same as the window title/label", "");
338 virtual wxString , GetName() const,
339 "Returns the windows name. This name is not guaranteed to be unique;
340 it is up to the programmer to supply an appropriate name in the window
341 constructor or via wx.Window.SetName.", "");
345 void , SetWindowVariant( wxWindowVariant variant ),
346 "Sets the variant of the window/font size to use for this window, if
347 the platform supports variants, for example, wxMac.",
351 ======================== =======================================
352 wx.WINDOW_VARIANT_NORMAL Normal size
353 wx.WINDOW_VARIANT_SMALL Smaller size (about 25 % smaller than normal)
354 wx.WINDOW_VARIANT_MINI Mini size (about 33 % smaller than normal)
355 wx.WINDOW_VARIANT_LARGE Large size (about 25 % larger than normal)
356 ======================== =======================================
360 wxWindowVariant , GetWindowVariant() const,
365 void , SetId( wxWindowID winid ),
366 "Sets the identifier of the window. Each window has an integer
367 identifier. If the application has not provided one, an identifier
368 will be generated. Normally, the identifier should be provided on
369 creation and should not be modified subsequently.", "");
372 wxWindowID , GetId() const,
373 "Returns the identifier of the window. Each window has an integer
374 identifier. If the application has not provided one (or the default Id
375 -1 is used) then an unique identifier with a negative value will be
380 static int , NewControlId(),
381 "Generate a control id for the controls which were not given one.", "");
385 static int , NextControlId(int winid),
386 "Get the id of the control following the one with the given
387 autogenerated) id", "");
391 static int , PrevControlId(int winid),
392 "Get the id of the control preceding the one with the given
393 autogenerated) id", "");
397 virtual wxLayoutDirection , GetLayoutDirection() const,
398 "Get the layout direction (LTR or RTL) for this window. Returns
399 ``wx.Layout_Default`` if layout direction is not supported.", "");
402 virtual void , SetLayoutDirection(wxLayoutDirection dir),
403 "Set the layout direction (LTR or RTL) for this window.", "");
407 virtual wxCoord , AdjustForLayoutDirection(wxCoord x,
409 wxCoord widthTotal) const,
410 "Mirror coordinates for RTL layout if this window uses it and if the
411 mirroring is not done automatically like Win32.", "");
422 void , SetSize( const wxSize& size ),
423 "Sets the size of the window in pixels.", "");
427 void , SetSize( int x, int y, int width, int height,
428 int sizeFlags = wxSIZE_AUTO ),
429 "Sets the position and size of the window in pixels. The sizeFlags
430 parameter indicates the interpretation of the other params if they are
433 ======================== ======================================
434 wx.SIZE_AUTO A -1 indicates that a class-specific
435 default should be used.
436 wx.SIZE_USE_EXISTING Axisting dimensions should be used if
437 -1 values are supplied.
438 wxSIZE_ALLOW_MINUS_ONE Allow dimensions of -1 and less to be
439 interpreted as real dimensions, not
441 ======================== ======================================
447 void , SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO),
448 "Sets the position and size of the window in pixels using a wx.Rect.", "",
453 void , SetSize( int width, int height ),
454 "Sets the size of the window in pixels.", "",
459 void , Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING),
460 "Moves the window to the given position.", "");
462 %pythoncode { SetPosition = Move }
466 void , Move(int x, int y, int flags = wxSIZE_USE_EXISTING),
467 "Moves the window to the given position.", "",
471 void , SetInitialSize(const wxSize& size=wxDefaultSize),
472 "A 'Smart' SetSize that will fill in default size components with the
473 window's *best size* values. Also set's the minsize for use with sizers.", "");
474 %pythoncode { SetBestFittingSize = wx._deprecated(SetInitialSize, 'Use `SetInitialSize`') }
478 virtual void , Raise(),
479 "Raises the window to the top of the window hierarchy. In current
480 version of wxWidgets this works both for managed and child windows.", "");
483 virtual void , Lower(),
484 "Lowers the window to the bottom of the window hierarchy. In current
485 version of wxWidgets this works both for managed and child windows.", "");
489 // client size is the size of the area available for subwindows
490 DocStr(SetClientSize,
491 "This sets the size of the window client area in pixels. Using this
492 function to size a window tends to be more device-independent than
493 wx.Window.SetSize, since the application need not worry about what
494 dimensions the border or title bar have when trying to fit the window
495 around panel items, for example.", "");
496 void SetClientSize( const wxSize& size );
497 %Rename(SetClientSizeWH, void, SetClientSize( int width, int height ));
498 %Rename(SetClientRect, void, SetClientSize(const wxRect& rect));
501 DocStr(GetPosition, // sets the docstring for both
502 "Get the window's position. Notice that the position is in client
503 coordinates for child windows and screen coordinates for the top level
504 ones, use `GetScreenPosition` if you need screen coordinates for all
505 kinds of windows.", "");
506 wxPoint GetPosition() const;
509 void, GetPosition(int *OUTPUT, int *OUTPUT) const,
510 "GetPositionTuple() -> (x,y)",
514 DocStr(GetScreenPosition, // sets the docstring for both
515 "Get the position of the window in screen coordinantes.", "");
516 wxPoint GetScreenPosition() const;
518 void, GetScreenPosition(int *OUTPUT, int *OUTPUT) const,
519 "GetScreenPositionTuple() -> (x,y)",
520 GetScreenPositionTuple);
523 wxRect , GetScreenRect() const,
524 "Returns the size and position of the window in screen coordinantes as
525 a `wx.Rect` object.", "
526 :see: `GetRect`, `GetScreenPosition`");
529 DocStr(GetSize, "Get the window size.", "");
530 wxSize GetSize() const;
532 void, GetSize( int *OUTPUT, int *OUTPUT ) const,
533 "GetSizeTuple() -> (width, height)",
539 wxRect , GetRect() const,
540 "Returns the size and position of the window as a `wx.Rect` object.", "");
543 DocStr(GetClientSize,
544 "This gets the size of the window's 'client area' in pixels. The client
545 area is the area which may be drawn on by the programmer, excluding
546 title bar, border, scrollbars, etc.", "");
547 wxSize GetClientSize() const;
549 void, GetClientSize( int *OUTPUT, int *OUTPUT ) const,
550 "GetClientSizeTuple() -> (width, height)",
556 virtual wxPoint , GetClientAreaOrigin() const,
557 "Get the origin of the client area of the window relative to the
558 window's top left corner (the client area may be shifted because of
559 the borders, scrollbars, other decorations...)", "");
563 wxRect , GetClientRect() const,
564 "Get the client area position and size as a `wx.Rect` object.", "");
569 "This function returns the best acceptable minimal size for the
570 window, if applicable. For example, for a static text control, it will
571 be the minimal size such that the control label is not truncated. For
572 windows containing subwindows (suzh aswx.Panel), the size returned by
573 this function will be the same as the size the window would have had
574 after calling Fit.", "");
575 wxSize GetBestSize() const;
577 void, GetBestSize(int *OUTPUT, int *OUTPUT) const,
578 "GetBestSizeTuple() -> (width, height)",
583 void , InvalidateBestSize(),
584 "Reset the cached best size value so it will be recalculated the next
585 time it is needed.", "");
588 void , CacheBestSize(const wxSize& size) const,
589 "Cache the best size so it doesn't need to be calculated again, (at least until
590 some properties of the window change.)", "");
594 wxSize , GetEffectiveMinSize() const,
595 "This function will merge the window's best size into the window's
596 minimum size, giving priority to the min size components, and returns
599 %pythoncode { GetBestFittingSize = wx._deprecated(GetEffectiveMinSize, 'Use `GetEffectiveMinSize` instead.') }
602 def GetAdjustedBestSize(self):
603 s = self.GetBestSize()
604 return wx.Size(max(s.width, self.GetMinWidth()),
605 max(s.height, self.GetMinHeight()))
606 GetAdjustedBestSize = wx._deprecated(GetAdjustedBestSize, 'Use `GetEffectiveMinSize` instead.')
612 void , Center( int direction = wxBOTH ),
613 "Centers the window. The parameter specifies the direction for
614 cetering, and may be wx.HORIZONTAL, wx.VERTICAL or wx.BOTH. It may
615 also include wx.CENTER_ON_SCREEN flag if you want to center the window
616 on the entire screen and not on its parent window. If it is a
617 top-level window and has no parent then it will always be centered
618 relative to the screen.", "");
619 %pythoncode { Centre = Center }
623 void , CenterOnParent(int dir = wxBOTH),
624 "Center with respect to the the parent window", "");
625 %pythoncode { CentreOnParent = CenterOnParent }
630 virtual void , Fit(),
631 "Sizes the window so that it fits around its subwindows. This function
632 won't do anything if there are no subwindows and will only really work
633 correctly if sizers are used for the subwindows layout. Also, if the
634 window has exactly one subwindow it is better (faster and the result
635 is more precise as Fit adds some margin to account for fuzziness of
636 its calculations) to call window.SetClientSize(child.GetSize())
637 instead of calling Fit.", "");
641 virtual void , FitInside(),
642 "Similar to Fit, but sizes the interior (virtual) size of a
643 window. Mainly useful with scrolled windows to reset scrollbars after
644 sizing changes that do not trigger a size event, and/or scrolled
645 windows without an interior sizer. This function similarly won't do
646 anything if there are no subwindows.", "");
651 "Allows specification of minimum and maximum window sizes, and window
652 size increments. If a pair of values is not set (or set to -1), the
653 default values will be used. If this function is called, the user
654 will not be able to size the window outside the given bounds (if it is
655 a top-level window.) Sizers will also inspect the minimum window size
656 and will use that value if set when calculating layout.
658 The resizing increments are only significant under Motif or Xt.", "
660 :see: `GetMinSize`, `GetMaxSize`, `SetMinSize`, `SetMaxSize`
662 virtual void SetSizeHints( int minW, int minH,
663 int maxW = -1, int maxH = -1,
664 int incW = -1, int incH = -1 );
665 %Rename(SetSizeHintsSz, void, SetSizeHints( const wxSize& minSize,
666 const wxSize& maxSize=wxDefaultSize,
667 const wxSize& incSize=wxDefaultSize));
670 DocStr(SetVirtualSizeHints,
671 "Allows specification of minimum and maximum virtual window sizes. If a
672 pair of values is not set (or set to -1), the default values will be
673 used. If this function is called, the user will not be able to size
674 the virtual area of the window outside the given bounds.", "");
675 virtual void SetVirtualSizeHints( int minW, int minH,
676 int maxW = -1, int maxH = -1 );
677 %Rename(SetVirtualSizeHintsSz, void, SetVirtualSizeHints(
678 const wxSize& minSize, const wxSize& maxSize=wxDefaultSize));
683 virtual wxSize , GetMaxSize() const,
687 virtual wxSize , GetMinSize() const,
691 virtual void , SetMinSize(const wxSize& minSize),
692 "A more convenient method than `SetSizeHints` for setting just the
696 virtual void , SetMaxSize(const wxSize& maxSize),
697 "A more convenient method than `SetSizeHints` for setting just the
703 virtual int , GetMinWidth() const,
707 virtual int , GetMinHeight() const,
711 int , GetMaxWidth() const,
715 int , GetMaxHeight() const,
720 DocStr(SetVirtualSize,
721 "Set the the virtual size of a window in pixels. For most windows this
722 is just the client area of the window, but for some like scrolled
723 windows it is more or less independent of the screen window size.", "");
724 void SetVirtualSize(const wxSize& size );
725 %Rename(SetVirtualSizeWH, void, SetVirtualSize( int w, int h ));
728 DocStr(GetVirtualSize,
729 "Get the the virtual size of the window in pixels. For most windows
730 this is just the client area of the window, but for some like scrolled
731 windows it is more or less independent of the screen window size.", "");
732 wxSize GetVirtualSize() const;
734 void, GetVirtualSize( int *OUTPUT, int *OUTPUT ) const,
735 "GetVirtualSizeTuple() -> (width, height)",
736 GetVirtualSizeTuple);
740 virtual wxSize , GetWindowBorderSize() const,
741 "Return the size of the left/right and top/bottom borders.", "");
744 // TODO: using directors?
745 // // Override these methods for windows that have a virtual size
746 // // independent of their client size. eg. the virtual area of a
747 // // wxScrolledWindow. Default is to alias VirtualSize to ClientSize.
748 // virtual void DoSetVirtualSize( int x, int y );
749 // virtual wxSize DoGetVirtualSize() const; // { return m_virtualSize; }
753 virtual wxSize , GetBestVirtualSize() const,
754 "Return the largest of ClientSize and BestSize (as determined by a
755 sizer, interior children, or other means)", "");
759 // void SetScrollHelper( wxScrollHelper *sh );
760 // wxScrollHelper *GetScrollHelper();
767 virtual bool , Show( bool show = true ),
768 "Shows or hides the window. You may need to call Raise for a top level
769 window if you want to bring it to top, although this is not needed if
770 Show is called immediately after the frame creation. Returns True if
771 the window has been shown or hidden or False if nothing was done
772 because it already was in the requested state.", "");
776 "Equivalent to calling Show(False).", "");
780 virtual bool , Enable( bool enable = true ),
781 "Enable or disable the window for user input. Note that when a parent
782 window is disabled, all of its children are disabled as well and they
783 are reenabled again when the parent is. Returns true if the window
784 has been enabled or disabled, false if nothing was done, i.e. if the
785 window had already been in the specified state.", "");
789 "Disables the window, same as Enable(false).", "");
793 bool , IsShown() const,
794 "Returns true if the window is shown, false if it has been hidden.", "");
797 bool , IsEnabled() const,
798 "Returns true if the window is enabled for input, false otherwise.
799 This method takes into account the enabled state of parent windows up
800 to the top-level window.", "");
803 bool , IsThisEnabled() const,
804 "Returns the internal enabled state independent of the parent(s) state,
805 i.e. the state in which the window would be if all of its parents are
806 enabled. Use `IsEnabled` to get the effective window state.", "");
810 virtual bool , IsShownOnScreen() const,
811 "Returns ``True`` if the window is physically visible on the screen,
812 i.e. it is shown and all its parents up to the toplevel window are
813 shown as well.", "");
819 virtual void , SetWindowStyleFlag( long style ),
820 "Sets the style of the window. Please note that some styles cannot be
821 changed after the window creation and that Refresh() might need to be
822 called after changing the others for the change to take place
826 virtual long , GetWindowStyleFlag() const,
827 "Gets the window style that was passed to the constructor or Create
830 %pythoncode { SetWindowStyle = SetWindowStyleFlag; GetWindowStyle = GetWindowStyleFlag }
834 bool , HasFlag(int flag) const,
835 "Test if the given style is set for this window.", "");
839 virtual bool , IsRetained() const,
840 "Returns true if the window is retained, false otherwise. Retained
841 windows are only available on X platforms.", "");
845 bool , ToggleWindowStyle(int flag),
846 "Turn the flag on if it had been turned off before and vice versa,
847 returns True if the flag is turned on by this function call.", "");
852 virtual void , SetExtraStyle(long exStyle),
853 "Sets the extra style bits for the window. Extra styles are the less
854 often used style bits which can't be set with the constructor or with
855 SetWindowStyleFlag()", "");
858 long , GetExtraStyle() const,
859 "Returns the extra style bits for the window.", "");
862 bool , HasExtraStyle(int exFlag) const,
863 "Returns ``True`` if the given extra flag is set.", "");
867 virtual void , MakeModal(bool modal = true),
868 "Disables all other windows in the application so that the user can
869 only interact with this window. Passing False will reverse this
875 virtual void , SetThemeEnabled(bool enableTheme),
876 "This function tells a window if it should use the system's \"theme\"
877 code to draw the windows' background instead if its own background
878 drawing code. This will only have an effect on platforms that support
879 the notion of themes in user defined windows. One such platform is
880 GTK+ where windows can have (very colourful) backgrounds defined by a
881 user's selected theme.
883 Dialogs, notebook pages and the status bar have this flag set to true
884 by default so that the default look and feel is simulated best.", "");
887 virtual bool , GetThemeEnabled() const,
888 "Return the themeEnabled flag.", "");
891 // TODO with directors
892 // // controls by default inherit the colours of their parents, if a
893 // // particular control class doesn't want to do it, it can override
894 // // ShouldInheritColours() to return False
895 // virtual bool ShouldInheritColours() const;
901 // focus and keyboard handling
902 // ---------------------------
906 virtual void , SetFocus(),
907 "Set's the focus to this window, allowing it to receive keyboard input.", "");
910 virtual void , SetFocusFromKbd(),
911 "Set focus to this window as the result of a keyboard action. Normally
912 only called internally.", "");
917 static wxWindow *, FindFocus(),
918 "Returns the window or control that currently has the keyboard focus,
923 virtual bool , AcceptsFocus() const,
924 "Can this window have focus?", "");
928 bool , CanAcceptFocus() const,
929 "Can this window have focus right now?", "");
934 virtual bool , AcceptsFocusFromKeyboard() const,
935 "Can this window be given focus by keyboard navigation? if not, the
936 only way to give it focus (provided it accepts it at all) is to click
942 bool , CanAcceptFocusFromKeyboard() const,
943 "Can this window be assigned focus from keyboard right now?", "");
947 virtual void , SetCanFocus(bool canFocus),
953 virtual bool , NavigateIn(int flags = wxNavigationKeyEvent::IsForward),
954 "NavigateIn(self, int flags=NavigationKeyEvent.IsForward) -> bool",
955 "Navigates inside this window.", "");
959 virtual bool , Navigate(int flags = wxNavigationKeyEvent::IsForward),
960 "Navigate(self, int flags=NavigationKeyEvent.IsForward) -> bool",
961 "Does keyboard navigation starting from this window to another. This is
962 equivalient to self.GetParent().NavigateIn().", "
964 :param flags: A combination of the ``IsForward`` or ``IsBackward``
965 and the ``WinChange`` values in the `wx.NavigationKeyEvent`
966 class, which determine if the navigation should be in forward
967 or reverse order, and if it should be able to cross parent
968 window boundaries, such as between notebook pages or MDI child
969 frames. Typically the status of the Shift key (for forward or
970 backward) or the Control key (for WinChange) would be used to
971 determine how to set the flags.
973 One situation in which you may wish to call this method is from a text
974 control custom keypress handler to do the default navigation behaviour
975 for the tab key, since the standard default behaviour for a multiline
976 text control with the wx.TE_PROCESS_TAB style is to insert a tab and
977 not navigate to the next control.");
982 void , MoveAfterInTabOrder(wxWindow *win),
983 "Moves this window in the tab navigation order after the specified
984 sibling window. This means that when the user presses the TAB key on
985 that other window, the focus switches to this window.
987 The default tab order is the same as creation order. This function
988 and `MoveBeforeInTabOrder` allow to change it after creating all the
994 void , MoveBeforeInTabOrder(wxWindow *win),
995 "Same as `MoveAfterInTabOrder` except that it inserts this window just
996 before win instead of putting it right after it.", "");
1001 // parent/children relations
1002 // -------------------------
1006 "Returns an object containing a list of the window's children. The
1007 object provides a Python sequence-like interface over the internal
1008 list maintained by the window..", "");
1009 wxWindowList& GetChildren();
1013 wxWindow *, GetParent() const,
1014 "Returns the parent window of this window, or None if there isn't one.", "");
1017 wxWindow *, GetGrandParent() const,
1018 "Returns the parent of the parent of this window, or None if there
1023 DocDeclStr(wxWindow *, GetTopLevelParent(),
1024 "Returns the first frame or dialog in this window's parental hierarchy.", "")
1026 return wxGetTopLevelParent(self);
1032 virtual bool , IsTopLevel() const,
1033 "Returns true if the given window is a top-level one. Currently all
1034 frames and dialogs are always considered to be top-level windows (even
1035 if they have a parent window).", "");
1038 // change the real parent of this window, return True if the parent
1039 // was changed, False otherwise (error or newParent == oldParent)
1041 virtual bool , Reparent( wxWindow *newParent ),
1042 "Reparents the window, i.e the window will be removed from its current
1043 parent window (e.g. a non-standard toolbar in a wxFrame) and then
1044 re-inserted into another. Available on Windows and GTK. Returns True
1045 if the parent was changed, False otherwise (error or newParent ==
1050 virtual void , AddChild( wxWindow *child ),
1051 "Adds a child window. This is called automatically by window creation
1052 functions so should not be required by the application programmer.", "");
1055 virtual void , RemoveChild( wxWindow *child ),
1056 "Removes a child window. This is called automatically by window
1057 deletion functions so should not be required by the application
1061 DocStr(SetDoubleBuffered,
1062 "Currently wxGTK2 only.", "");
1064 void SetDoubleBuffered(bool on);
1067 void SetDoubleBuffered(bool on) {}
1072 // looking for windows
1073 // -------------------
1076 wxWindow *, FindWindow( long winid ),
1077 "Find a chld of this window by window ID", "",
1081 wxWindow *, FindWindow( const wxString& name ),
1082 "Find a child of this window by name", "",
1087 // event handler stuff
1088 // -------------------
1091 wxEvtHandler *, GetEventHandler() const,
1092 "Returns the event handler for this window. By default, the window is
1093 its own event handler.", "");
1097 void , SetEventHandler( wxEvtHandler *handler ),
1098 "Sets the event handler for this window. An event handler is an object
1099 that is capable of processing the events sent to a window. (In other
1100 words, is able to dispatch the events to handler function.) By
1101 default, the window is its own event handler, but an application may
1102 wish to substitute another, for example to allow central
1103 implementation of event-handling for a variety of different window
1106 It is usually better to use `wx.Window.PushEventHandler` since this sets
1107 up a chain of event handlers, where an event not handled by one event
1108 handler is handed off to the next one in the chain.", "");
1112 void , PushEventHandler( wxEvtHandler *handler ),
1113 "Pushes this event handler onto the event handler stack for the window.
1114 An event handler is an object that is capable of processing the events
1115 sent to a window. (In other words, is able to dispatch the events to a
1116 handler function.) By default, the window is its own event handler,
1117 but an application may wish to substitute another, for example to
1118 allow central implementation of event-handling for a variety of
1119 different window classes.
1121 wx.Window.PushEventHandler allows an application to set up a chain of
1122 event handlers, where an event not handled by one event handler is
1123 handed to the next one in the chain. Use `wx.Window.PopEventHandler`
1124 to remove the event handler. Ownership of the handler is *not* given
1125 to the window, so you should be sure to pop the handler before the
1126 window is destroyed and either let PopEventHandler destroy it, or call
1127 its Destroy method yourself.", "");
1131 wxEvtHandler *, PopEventHandler( bool deleteHandler = false ),
1132 "Removes and returns the top-most event handler on the event handler
1133 stack. If deleteHandler is True then the wx.EvtHandler object will be
1134 destroyed after it is popped, and ``None`` will be returned instead.", "");
1138 bool , RemoveEventHandler(wxEvtHandler *handler),
1139 "Find the given handler in the event handler chain and remove (but not
1140 delete) it from the event handler chain, returns True if it was found
1141 and False otherwise (this also results in an assert failure so this
1142 function should only be called when the handler is supposed to be
1151 // a window may have an associated validator which is used to control
1154 virtual void , SetValidator( const wxValidator &validator ),
1155 "Deletes the current validator (if any) and sets the window validator,
1156 having called wx.Validator.Clone to create a new validator of this
1160 virtual wxValidator *, GetValidator(),
1161 "Returns a pointer to the current validator for the window, or None if
1162 there is none.", "");
1166 virtual bool , Validate(),
1167 "Validates the current values of the child controls using their
1168 validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY extra
1169 style flag set, the method will also call Validate() of all child
1170 windows. Returns false if any of the validations failed.", "");
1174 virtual bool , TransferDataToWindow(),
1175 "Transfers values to child controls from data areas specified by their
1176 validators. If the window has wx.WS_EX_VALIDATE_RECURSIVELY extra
1177 style flag set, the method will also call TransferDataToWindow() of
1178 all child windows.", "");
1181 virtual bool , TransferDataFromWindow(),
1182 "Transfers values from child controls to data areas specified by their
1183 validators. Returns false if a transfer failed. If the window has
1184 wx.WS_EX_VALIDATE_RECURSIVELY extra style flag set, the method will
1185 also call TransferDataFromWindow() of all child windows.", "");
1189 virtual void , InitDialog(),
1190 "Sends an EVT_INIT_DIALOG event, whose handler usually transfers data
1191 to the dialog via validators.", "");
1200 virtual void , SetAcceleratorTable( const wxAcceleratorTable& accel ),
1201 "Sets the accelerator table for this window.", "");
1204 wxAcceleratorTable *, GetAcceleratorTable(),
1205 "Gets the accelerator table for this window.", "");
1211 // hot keys (system wide accelerators)
1212 // -----------------------------------
1214 DocStr(RegisterHotKey,
1215 "Registers a system wide hotkey. Every time the user presses the hotkey
1216 registered here, this window will receive a hotkey event. It will
1217 receive the event even if the application is in the background and
1218 does not have the input focus because the user is working with some
1219 other application. To bind an event handler function to this hotkey
1220 use EVT_HOTKEY with an id equal to hotkeyId. Returns True if the
1221 hotkey was registered successfully.", "");
1222 bool RegisterHotKey(int hotkeyId, int modifiers, int keycode) {
1224 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
1231 DocStr(UnregisterHotKey,
1232 "Unregisters a system wide hotkey.", "");
1233 bool UnregisterHotKey(int hotkeyId) {
1235 return self->UnregisterHotKey(hotkeyId);
1244 // "dialog units" translations
1245 // ---------------------------
1247 DocStr(ConvertDialogToPixels,
1248 "Converts a point or size from dialog units to pixels. Dialog units
1249 are used for maintaining a dialog's proportions even if the font
1250 changes. For the x dimension, the dialog units are multiplied by the
1251 average character width and then divided by 4. For the y dimension,
1252 the dialog units are multiplied by the average character height and
1253 then divided by 8.", "");
1254 %Rename(ConvertDialogPointToPixels, wxPoint, ConvertDialogToPixels(const wxPoint& pt));
1255 %Rename(ConvertDialogSizeToPixels, wxSize, ConvertDialogToPixels(const wxSize& sz));
1256 %Rename(DLG_PNT, wxPoint, ConvertDialogToPixels(const wxPoint& pt));
1257 %Rename(DLG_SZE, wxSize, ConvertDialogToPixels(const wxSize& sz));
1260 DocStr(ConvertPixelPointToDialog,
1261 "Converts a point or size from pixels to dialog units. Dialog units
1262 are used for maintaining a dialog's proportions even if the font
1263 changes. For the x dimension, the dialog units are multiplied by the
1264 average character width and then divided by 4. For the y dimension,
1265 the dialog units are multiplied by the average character height and
1266 then divided by 8.", "");
1267 %Rename(ConvertPixelPointToDialog, wxPoint, ConvertPixelsToDialog(const wxPoint& pt));
1268 %Rename(ConvertPixelSizeToDialog, wxSize, ConvertPixelsToDialog(const wxSize& sz));
1276 virtual void , WarpPointer(int x, int y),
1277 "Moves the pointer to the given position on the window.
1279 NOTE: This function is not supported under Mac because Apple Human
1280 Interface Guidelines forbid moving the mouse cursor programmatically.", "");
1284 void , CaptureMouse(),
1285 "Directs all mouse input to this window. Call wx.Window.ReleaseMouse to
1286 release the capture.
1288 Note that wxWindows maintains the stack of windows having captured the
1289 mouse and when the mouse is released the capture returns to the window
1290 which had had captured it previously and it is only really released if
1291 there were no previous window. In particular, this means that you must
1292 release the mouse as many times as you capture it, unless the window
1293 receives the `wx.MouseCaptureLostEvent` event.
1295 Any application which captures the mouse in the beginning of some
1296 operation *must* handle `wx.MouseCaptureLostEvent` and cancel this
1297 operation when it receives the event. The event handler must not
1298 recapture mouse.", "");
1301 void , ReleaseMouse(),
1302 "Releases mouse input captured with wx.Window.CaptureMouse.", "");
1306 static wxWindow *, GetCapture(),
1307 "Returns the window which currently captures the mouse or None", "");
1311 virtual bool , HasCapture() const,
1312 "Returns true if this window has the current mouse capture.", "");
1318 // painting the window
1319 // -------------------
1322 virtual void , Refresh( bool eraseBackground = true,
1323 const wxRect *rect = NULL ),
1324 "Mark the specified rectangle (or the whole window) as \"dirty\" so it
1325 will be repainted. Causes an EVT_PAINT event to be generated and sent
1326 to the window.", "");
1330 void , RefreshRect(const wxRect& rect, bool eraseBackground = true),
1331 "Redraws the contents of the given rectangle: the area inside it will
1332 be repainted. This is the same as Refresh but has a nicer syntax.", "");
1336 virtual void , Update(),
1337 "Calling this method immediately repaints the invalidated area of the
1338 window instead of waiting for the EVT_PAINT event to happen, (normally
1339 this would usually only happen when the flow of control returns to the
1340 event loop.) Notice that this function doesn't refresh the window and
1341 does nothing if the window has been already repainted. Use `Refresh`
1342 first if you want to immediately redraw the window (or some portion of
1343 it) unconditionally.", "");
1347 virtual void , ClearBackground(),
1348 "Clears the window by filling it with the current background
1349 colour. Does not cause an erase background event to be generated.", "");
1354 virtual void , Freeze(),
1355 "Freezes the window or, in other words, prevents any updates from
1356 taking place on screen, the window is not redrawn at all. Thaw must be
1357 called to reenable window redrawing. Calls to Freeze/Thaw may be
1358 nested, with the actual Thaw being delayed until all the nesting has
1361 This method is useful for visual appearance optimization (for example,
1362 it is a good idea to use it before inserting large amount of text into
1363 a wxTextCtrl under wxGTK) but is not implemented on all platforms nor
1364 for all controls so it is mostly just a hint to wxWindows and not a
1365 mandatory directive.", "");
1369 virtual bool , IsFrozen() const,
1370 "Returns ``True`` if the window has been frozen and not thawed yet.
1372 :see: `Freeze` and `Thaw`", "");
1377 virtual void , Thaw(),
1378 "Reenables window updating after a previous call to Freeze. Calls to
1379 Freeze/Thaw may be nested, so Thaw must be called the same number of
1380 times that Freeze was before the window will be updated.", "");
1384 virtual void , PrepareDC( wxDC & dc ),
1385 "Call this function to prepare the device context for drawing a
1386 scrolled image. It sets the device origin according to the current
1387 scroll position.", "");
1390 virtual bool , IsDoubleBuffered() const,
1391 "Returns ``True`` if the window contents is double-buffered by the
1392 system, i.e. if any drawing done on the window is really done on a
1393 temporary backing surface and transferred to the screen all at once
1398 wxRegion& , GetUpdateRegion(),
1399 "Returns the region specifying which parts of the window have been
1400 damaged. Should only be called within an EVT_PAINT handler.", "");
1404 wxRect , GetUpdateClientRect() const,
1405 "Get the update rectangle region bounding box in client coords.", "");
1409 "Returns true if the given point or rectangle area has been exposed
1410 since the last repaint. Call this in an paint event handler to
1411 optimize redrawing by only redrawing those areas, which have been
1413 bool IsExposed( int x, int y, int w=1, int h=1 ) const;
1414 %Rename(IsExposedPoint, bool, IsExposed( const wxPoint& pt ) const);
1415 %Rename(IsExposedRect, bool, IsExposed( const wxRect& rect ) const);
1419 // colours, fonts and cursors
1420 // --------------------------
1424 virtual wxVisualAttributes , GetDefaultAttributes() const,
1425 "Get the default attributes for an instance of this class. This is
1426 useful if you want to use the same font or colour in your own control
1427 as in a standard control -- which is a much better idea than hard
1428 coding specific colours or fonts which might look completely out of
1429 place on the user's system, especially if it uses themes.", "");
1433 static wxVisualAttributes ,
1434 GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL),
1435 "Get the default attributes for this class. This is useful if you want
1436 to use the same font or colour in your own control as in a standard
1437 control -- which is a much better idea than hard coding specific
1438 colours or fonts which might look completely out of place on the
1439 user's system, especially if it uses themes.
1441 The variant parameter is only relevant under Mac currently and is
1442 ignore under other platforms. Under Mac, it will change the size of
1443 the returned font. See `wx.Window.SetWindowVariant` for more about
1448 virtual bool , SetBackgroundColour( const wxColour &colour ),
1449 "Sets the background colour of the window. Returns True if the colour
1450 was changed. The background colour is usually painted by the default
1451 EVT_ERASE_BACKGROUND event handler function under Windows and
1452 automatically under GTK. Using `wx.NullColour` will reset the window
1453 to the default background colour.
1455 Note that setting the background colour may not cause an immediate
1456 refresh, so you may wish to call `ClearBackground` or `Refresh` after
1457 calling this function.
1459 Using this function will disable attempts to use themes for this
1460 window, if the system supports them. Use with care since usually the
1461 themes represent the appearance chosen by the user to be used for all
1462 applications on the system.", "");
1465 void , SetOwnBackgroundColour(const wxColour& colour),
1471 virtual bool , SetForegroundColour( const wxColour &colour ),
1472 "Sets the foreground colour of the window. Returns True is the colour
1473 was changed. The interpretation of foreground colour is dependent on
1474 the window class; it may be the text colour or other colour, or it may
1475 not be used at all.", "");
1478 void , SetOwnForegroundColour(const wxColour& colour),
1484 wxColour , GetBackgroundColour() const,
1485 "Returns the background colour of the window.", "");
1488 wxColour , GetForegroundColour() const,
1489 "Returns the foreground colour of the window. The interpretation of
1490 foreground colour is dependent on the window class; it may be the text
1491 colour or other colour, or it may not be used at all.", "");
1494 bool , InheritsBackgroundColour() const,
1498 bool , UseBgCol() const,
1503 // // if the window shouldn't inherit its colour from the parent, override
1504 // // this function to return true
1506 // // this is currently only used by wxMSW and wxUniv but should be useful for
1507 // // the other ports too
1508 // virtual bool ProvidesBackground() const;
1511 // Set/get the background style.
1512 // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM
1514 virtual bool , SetBackgroundStyle(wxBackgroundStyle style),
1515 "Returns the background style of the window. The background style
1516 indicates how the background of the window is drawn.
1518 ====================== ========================================
1519 wx.BG_STYLE_SYSTEM The background colour or pattern should
1520 be determined by the system
1521 wx.BG_STYLE_COLOUR The background should be a solid colour
1522 wx.BG_STYLE_CUSTOM The background will be implemented by the
1524 ====================== ========================================
1526 On GTK+, use of wx.BG_STYLE_CUSTOM allows the flicker-free drawing of
1527 a custom background, such as a tiled bitmap. Currently the style has
1528 no effect on other platforms.
1530 :see: `GetBackgroundStyle`, `SetBackgroundColour`", "");
1533 virtual wxBackgroundStyle , GetBackgroundStyle() const,
1534 "Returns the background style of the window.
1536 :see: `SetBackgroundStyle`", "");
1540 bool , HasTransparentBackground(),
1541 "Returns True if this window's background is transparent (as, for
1542 example, for `wx.StaticText`) and should show the parent window's
1545 This method is mostly used internally by the library itself and you
1546 normally shouldn't have to call it. You may, however, have to override
1547 it in your custom control classes to ensure that background is painted
1552 virtual bool , SetCursor( const wxCursor &cursor ),
1553 "Sets the window's cursor. Notice that the window cursor also sets it
1554 for the children of the window implicitly.
1556 The cursor may be wx.NullCursor in which case the window cursor will
1557 be reset back to default.", "");
1560 wxCursor , GetCursor(),
1561 "Return the cursor associated with this window.", "");
1566 virtual bool , SetFont( const wxFont &font ),
1567 "Sets the font for this window.", "");
1570 void , SetOwnFont(const wxFont& font),
1577 "Returns the default font used for this window.", "");
1581 %disownarg( wxCaret *caret );
1583 void , SetCaret(wxCaret *caret),
1584 "Sets the caret associated with the window.", "");
1585 %cleardisown( wxCaret *caret );
1588 wxCaret *, GetCaret() const,
1589 "Returns the caret associated with the window.", "");
1594 virtual int , GetCharHeight() const,
1595 "Get the (average) character size for the current font.", "");
1598 virtual int , GetCharWidth() const,
1599 "Get the (average) character size for the current font.", "");
1604 void, GetTextExtent(const wxString& string, int *OUTPUT, int *OUTPUT),
1605 "GetTextExtent(String string) -> (width, height)",
1606 "Get the width and height of the text using the current font.", "");
1608 void, GetTextExtent(const wxString& string,
1609 int *OUTPUT, int *OUTPUT, int *OUTPUT, int* OUTPUT,
1610 const wxFont* font = NULL),
1611 "GetFullTextExtent(String string, Font font=None) ->\n (width, height, descent, externalLeading)",
1612 "Get the width, height, decent and leading of the text using the
1613 current or specified font.", "",
1618 // client <-> screen coords
1619 // ------------------------
1621 %apply int * INOUT { int* x, int* y };
1623 // translate to/from screen/client coordinates
1625 void , ClientToScreen( int *x, int *y ) const,
1626 "ClientToScreenXY(int x, int y) -> (x,y)",
1627 "Converts to screen coordinates from coordinates relative to this window.", "",
1631 void , ScreenToClient( int *x, int *y ) const,
1632 "ScreenToClientXY(int x, int y) -> (x,y)",
1633 "Converts from screen to client window coordinates.", "",
1638 wxPoint , ClientToScreen(const wxPoint& pt) const,
1639 "Converts to screen coordinates from coordinates relative to this window.", "");
1642 wxPoint , ScreenToClient(const wxPoint& pt) const,
1643 "Converts from screen to client window coordinates.", "");
1648 wxHitTest , HitTest(wxCoord x, wxCoord y) const,
1649 "Test where the given (in client coords) point lies", "",
1653 wxHitTest , HitTest(const wxPoint& pt) const,
1654 "Test where the given (in client coords) point lies", "");
1662 %nokwargs GetBorder;
1664 wxBorder , GetBorder(long flags) const,
1665 "Get the window border style from the given flags: this is different
1666 from simply doing flags & wxBORDER_MASK because it uses
1667 GetDefaultBorder() to translate wxBORDER_DEFAULT to something
1672 wxBorder , GetBorder() const,
1673 "Get border for the flags of this window", "");
1679 virtual void , UpdateWindowUI(long flags = wxUPDATE_UI_NONE),
1680 "This function sends EVT_UPDATE_UI events to the window. The particular
1681 implementation depends on the window; for example a wx.ToolBar will
1682 send an update UI event for each toolbar button, and a wx.Frame will
1683 send an update UI event for each menubar menu item. You can call this
1684 function from your application to ensure that your UI is up-to-date at
1685 a particular point in time (as far as your EVT_UPDATE_UI handlers are
1686 concerned). This may be necessary if you have called
1687 `wx.UpdateUIEvent.SetMode` or `wx.UpdateUIEvent.SetUpdateInterval` to
1688 limit the overhead that wxWindows incurs by sending update UI events
1691 The flags should be a bitlist of one or more of the following values:
1693 ===================== ==============================
1694 wx.UPDATE_UI_NONE No particular value
1695 wx.UPDATE_UI_RECURSE Call the function for descendants
1696 wx.UPDATE_UI_FROMIDLE Invoked from OnIdle
1697 ===================== ==============================
1699 If you are calling this function from an OnIdle function, make sure
1700 you pass the wx.UPDATE_UI_FROMIDLE flag, since this tells the window
1701 to only update the UI elements that need to be updated in idle
1702 time. Some windows update their elements only when necessary, for
1703 example when a menu is about to be shown. The following is an example
1704 of how to call UpdateWindowUI from an idle function::
1706 def OnIdle(self, evt):
1707 if wx.UpdateUIEvent.CanUpdate(self):
1708 self.UpdateWindowUI(wx.UPDATE_UI_FROMIDLE);
1712 // TODO: using directors?
1713 // // do the window-specific processing after processing the update event
1714 // virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;
1718 "Pops up the given menu at the specified coordinates, relative to this window,
1719 and returns control when the user has dismissed the menu. If a menu item is
1720 selected, the corresponding menu event is generated and will be processed as
1721 usual. If the default position is given then the current position of the
1722 mouse cursor will be used.", "");
1723 %Rename(PopupMenuXY, bool, PopupMenu(wxMenu *menu, int x=-1, int y=-1));
1724 bool PopupMenu(wxMenu *menu, const wxPoint& pos=wxDefaultPosition);
1728 virtual bool , HasMultiplePages() const,
1734 "Returns the platform-specific handle (as a long integer) of the
1735 physical window. Currently on wxMac it returns the handle of the
1736 toplevel parent of the window.", "");
1738 return wxPyGetWinHandle(self);
1744 "Associate the window with a new native handle", "");
1746 void AssociateHandle(long handle) {
1747 self->AssociateHandle((WXWidget)handle);
1753 virtual void , DissociateHandle(),
1754 "Dissociate the current native handle from the window", "");
1759 // A way to do the native draw first... Too bad it isn't in wxGTK too.
1760 void OnPaint(wxPaintEvent& event);
1770 bool , HasScrollbar(int orient) const,
1771 "Does the window have the scrollbar for this orientation?", "");
1774 // configure the window scrollbars
1776 virtual void , SetScrollbar( int orientation,
1780 bool refresh = true ),
1781 "Sets the scrollbar properties of a built-in scrollbar.",
1783 :param orientation: Determines the scrollbar whose page size is to
1784 be set. May be wx.HORIZONTAL or wx.VERTICAL.
1786 :param position: The position of the scrollbar in scroll units.
1788 :param thumbSize: The size of the thumb, or visible portion of the
1789 scrollbar, in scroll units.
1791 :param range: The maximum position of the scrollbar.
1793 :param refresh: True to redraw the scrollbar, false otherwise.
1797 virtual void , SetScrollPos( int orientation, int pos, bool refresh = true ),
1798 "Sets the position of one of the built-in scrollbars.", "");
1801 virtual int , GetScrollPos( int orientation ) const,
1802 "Returns the built-in scrollbar position.", "");
1805 virtual int , GetScrollThumb( int orientation ) const,
1806 "Returns the built-in scrollbar thumb size.", "");
1809 virtual int , GetScrollRange( int orientation ) const,
1810 "Returns the built-in scrollbar range.", "");
1816 virtual void , ScrollWindow( int dx, int dy,
1817 const wxRect* rect = NULL ),
1818 "Physically scrolls the pixels in the window and move child windows
1819 accordingly. Use this function to optimise your scrolling
1820 implementations, to minimise the area that must be redrawn. Note that
1821 it is rarely required to call this function from a user program.","
1823 :param dx: Amount to scroll horizontally.
1825 :param dy: Amount to scroll vertically.
1827 :param rect: Rectangle to invalidate. If this is None, the whole
1828 window is invalidated. If you pass a rectangle corresponding
1829 to the area of the window exposed by the scroll, your
1830 painting handler can optimize painting by checking for the
1831 invalidated region.");
1835 virtual bool , ScrollLines(int lines),
1836 "If the platform and window class supports it, scrolls the window by
1837 the given number of lines down, if lines is positive, or up if lines
1838 is negative. Returns True if the window was scrolled, False if it was
1839 already on top/bottom and nothing was done.", "");
1842 virtual bool , ScrollPages(int pages),
1843 "If the platform and window class supports it, scrolls the window by
1844 the given number of pages down, if pages is positive, or up if pages
1845 is negative. Returns True if the window was scrolled, False if it was
1846 already on top/bottom and nothing was done.", "");
1851 "This is just a wrapper for ScrollLines(-1).", "");
1855 "This is just a wrapper for ScrollLines(1).", "");
1859 "This is just a wrapper for ScrollPages(-1).", "");
1863 "This is just a wrapper for ScrollPages(1).", "");
1868 // context-sensitive help
1869 // ----------------------
1872 void , SetHelpText(const wxString& text),
1873 "Sets the help text to be used as context-sensitive help for this
1874 window. Note that the text is actually stored by the current
1875 `wx.HelpProvider` implementation, and not in the window object itself.", "");
1879 void , SetHelpTextForId(const wxString& text),
1880 "Associate this help text with all windows with the same id as this
1885 virtual wxString , GetHelpTextAtPoint(const wxPoint& pt,
1886 wxHelpEvent::Origin origin) const,
1887 "Get the help string associated with the given position in this window.
1889 Notice that pt may be invalid if event origin is keyboard or unknown
1890 and this method should return the global window help text then
1895 wxString , GetHelpText() const,
1896 "Gets the help text to be used as context-sensitive help for this
1897 window. Note that the text is actually stored by the current
1898 `wx.HelpProvider` implementation, and not in the window object itself.", "");
1907 "Attach a tooltip to the window.", "");
1908 %Rename(SetToolTipString, void, SetToolTip( const wxString &tip ));
1910 %disownarg( wxToolTip *tip );
1911 void SetToolTip( wxToolTip *tip );
1912 %cleardisown( wxToolTip *tip );
1915 wxToolTip* , GetToolTip() const,
1916 "get the associated tooltip or None if none", "");
1918 // LINK ERROR --> wxString GetToolTipText() const;
1927 %disownarg( wxPyDropTarget *dropTarget );
1929 virtual void , SetDropTarget( wxPyDropTarget *dropTarget ),
1930 "Associates a drop target with this window. If the window already has
1931 a drop target, it is deleted.", "");
1932 %cleardisown( wxPyDropTarget *dropTarget );
1936 virtual wxPyDropTarget *, GetDropTarget() const,
1937 "Returns the associated drop target, which may be None.", "");
1940 DocStr(DragAcceptFiles,
1941 "Enables or disables eligibility for drop file events, EVT_DROP_FILES.
1942 Only functional on Windows.", "");
1944 void DragAcceptFiles(bool accept);
1947 void DragAcceptFiles(bool accept) {}
1953 // constraints and sizers
1954 // ----------------------
1956 %disownarg(wxLayoutConstraints*);
1958 void , SetConstraints( wxLayoutConstraints *constraints ),
1959 "Sets the window to have the given layout constraints. If an existing
1960 layout constraints object is already owned by the window, it will be
1961 deleted. Pass None to disassociate and delete the window's current
1964 You must call SetAutoLayout to tell a window to use the constraints
1965 automatically in its default EVT_SIZE handler; otherwise, you must
1966 handle EVT_SIZE yourself and call Layout() explicitly. When setting
1967 both a wx.LayoutConstraints and a wx.Sizer, only the sizer will have
1971 wxLayoutConstraints *, GetConstraints() const,
1972 "Returns a pointer to the window's layout constraints, or None if there
1974 %cleardisown(wxLayoutConstraints*);
1978 void , SetAutoLayout( bool autoLayout ),
1979 "Determines whether the Layout function will be called automatically
1980 when the window is resized. lease note that this only happens for the
1981 windows usually used to contain children, namely `wx.Panel` and
1982 `wx.TopLevelWindow` (and the classes deriving from them).
1984 This method is called implicitly by `SetSizer` but if you use
1985 `SetConstraints` you should call it manually or otherwise the window
1986 layout won't be correctly updated when its size changes.", "");
1989 bool , GetAutoLayout() const,
1990 "Returns the current autoLayout setting", "");
1994 virtual bool , Layout(),
1995 "Invokes the constraint-based layout algorithm or the sizer-based
1996 algorithm for this window. See SetAutoLayout: when auto layout is on,
1997 this function gets called automatically by the default EVT_SIZE
1998 handler when the window is resized.", "");
2001 %disownarg( wxSizer *sizer );
2003 void , SetSizer(wxSizer *sizer, bool deleteOld = true ),
2004 "Sets the window to have the given layout sizer. The window will then
2005 own the object, and will take care of its deletion. If an existing
2006 layout sizer object is already owned by the window, it will be deleted
2007 if the deleteOld parameter is true. Note that this function will also
2008 call SetAutoLayout implicitly with a True parameter if the sizer is
2009 non-None, and False otherwise.", "");
2012 void , SetSizerAndFit( wxSizer *sizer, bool deleteOld = true ),
2013 "The same as SetSizer, except it also sets the size hints for the
2014 window based on the sizer's minimum size.", "");
2015 %cleardisown( wxSizer *sizer );
2019 wxSizer *, GetSizer() const,
2020 "Return the sizer associated with the window by a previous call to
2021 SetSizer or None if there isn't one.", "");
2024 // Track if this window is a member of a sizer
2026 void , SetContainingSizer(wxSizer* sizer),
2027 "This normally does not need to be called by application code. It is
2028 called internally when a window is added to a sizer, and is used so
2029 the window can remove itself from the sizer when it is destroyed.", "");
2032 wxSizer *, GetContainingSizer() const,
2033 "Return the sizer that this window is a member of, if any, otherwise None.", "");
2039 // ----------------------
2040 #if wxUSE_ACCESSIBILITY
2041 // Override to create a specific accessible object.
2042 virtual wxAccessible* CreateAccessible();
2044 // Sets the accessible object.
2045 void SetAccessible(wxAccessible* accessible) ;
2047 // Returns the accessible object.
2048 wxAccessible* GetAccessible() { return m_accessible; };
2050 // Returns the accessible object, creating if necessary.
2051 wxAccessible* GetOrCreateAccessible() ;
2058 virtual void , InheritAttributes(),
2059 "This function is (or should be, in case of custom controls) called
2060 during window creation to intelligently set up the window visual
2061 attributes, that is the font and the foreground and background
2064 By 'intelligently' the following is meant: by default, all windows use
2065 their own default attributes. However if some of the parent's
2066 attributes are explicitly changed (that is, using SetFont and not
2067 SetOwnFont) and if the corresponding attribute hadn't been
2068 explicitly set for this window itself, then this window takes the same
2069 value as used by the parent. In addition, if the window overrides
2070 ShouldInheritColours to return false, the colours will not be changed
2071 no matter what and only the font might.
2073 This rather complicated logic is necessary in order to accommodate the
2074 different usage scenarios. The most common one is when all default
2075 attributes are used and in this case, nothing should be inherited as
2076 in modern GUIs different controls use different fonts (and colours)
2077 than their siblings so they can't inherit the same value from the
2078 parent. However it was also deemed desirable to allow to simply change
2079 the attributes of all children at once by just changing the font or
2080 colour of their common parent, hence in this case we do inherit the
2085 // TODO: Virtualize this with directors
2087 virtual bool , ShouldInheritColours() const,
2088 "Return true from here to allow the colours of this window to be
2089 changed by InheritAttributes, returning false forbids inheriting them
2090 from the parent window.
2092 The base class version returns false, but this method is overridden in
2093 wxControl where it returns true.", "");
2098 virtual bool , CanSetTransparent(),
2099 "Returns ``True`` if the platform supports setting the transparency for
2100 this window. Note that this method will err on the side of caution,
2101 so it is possible that this will return ``False`` when it is in fact
2102 possible to set the transparency.
2104 NOTE: On X-windows systems the X server must have the composite
2105 extension loaded, and there must be a composite manager program (such
2106 as xcompmgr) running.", "");
2109 virtual bool , SetTransparent(byte alpha),
2110 "Attempt to set the transparency of this window to the ``alpha`` value,
2111 returns True on success. The ``alpha`` value is an integer in the
2112 range of 0 to 255, where 0 is fully transparent and 255 is fully
2118 def PostCreate(self, pre):
2120 Phase 3 of the 2-phase create <wink!>
2121 Call this method after precreating the window with the 2-phase create method.
2123 self.this = pre.this
2124 self.thisown = pre.thisown
2126 if hasattr(self, '_setOORInfo'):
2128 self._setOORInfo(self)
2131 if hasattr(self, '_setCallbackInfo'):
2133 self._setCallbackInfo(self, pre.__class__)
2139 def SendSizeEvent(self):
2140 self.GetEventHandler().ProcessEvent(wx.SizeEvent((-1,-1)))
2144 %property(AcceleratorTable, GetAcceleratorTable, SetAcceleratorTable, doc="See `GetAcceleratorTable` and `SetAcceleratorTable`");
2145 %property(AutoLayout, GetAutoLayout, SetAutoLayout, doc="See `GetAutoLayout` and `SetAutoLayout`");
2146 %property(BackgroundColour, GetBackgroundColour, SetBackgroundColour, doc="See `GetBackgroundColour` and `SetBackgroundColour`");
2147 %property(BackgroundStyle, GetBackgroundStyle, SetBackgroundStyle, doc="See `GetBackgroundStyle` and `SetBackgroundStyle`");
2148 %property(EffectiveMinSize, GetEffectiveMinSize, doc="See `GetEffectiveMinSize`");
2149 %property(BestSize, GetBestSize, doc="See `GetBestSize`");
2150 %property(BestVirtualSize, GetBestVirtualSize, doc="See `GetBestVirtualSize`");
2151 %property(Border, GetBorder, doc="See `GetBorder`");
2152 %property(Caret, GetCaret, SetCaret, doc="See `GetCaret` and `SetCaret`");
2153 %property(CharHeight, GetCharHeight, doc="See `GetCharHeight`");
2154 %property(CharWidth, GetCharWidth, doc="See `GetCharWidth`");
2155 %property(Children, GetChildren, doc="See `GetChildren`");
2156 %property(ClientAreaOrigin, GetClientAreaOrigin, doc="See `GetClientAreaOrigin`");
2157 %property(ClientRect, GetClientRect, SetClientRect, doc="See `GetClientRect` and `SetClientRect`");
2158 %property(ClientSize, GetClientSize, SetClientSize, doc="See `GetClientSize` and `SetClientSize`");
2159 %property(Constraints, GetConstraints, SetConstraints, doc="See `GetConstraints` and `SetConstraints`");
2160 %property(ContainingSizer, GetContainingSizer, SetContainingSizer, doc="See `GetContainingSizer` and `SetContainingSizer`");
2161 %property(Cursor, GetCursor, SetCursor, doc="See `GetCursor` and `SetCursor`");
2162 %property(DefaultAttributes, GetDefaultAttributes, doc="See `GetDefaultAttributes`");
2163 %property(DropTarget, GetDropTarget, SetDropTarget, doc="See `GetDropTarget` and `SetDropTarget`");
2164 %property(EventHandler, GetEventHandler, SetEventHandler, doc="See `GetEventHandler` and `SetEventHandler`");
2165 %property(ExtraStyle, GetExtraStyle, SetExtraStyle, doc="See `GetExtraStyle` and `SetExtraStyle`");
2166 %property(Font, GetFont, SetFont, doc="See `GetFont` and `SetFont`");
2167 %property(ForegroundColour, GetForegroundColour, SetForegroundColour, doc="See `GetForegroundColour` and `SetForegroundColour`");
2168 %property(GrandParent, GetGrandParent, doc="See `GetGrandParent`");
2169 %property(TopLevelParent, GetTopLevelParent, doc="See `GetTopLevelParent`");
2170 %property(Handle, GetHandle, doc="See `GetHandle`");
2171 %property(HelpText, GetHelpText, SetHelpText, doc="See `GetHelpText` and `SetHelpText`");
2172 %property(Id, GetId, SetId, doc="See `GetId` and `SetId`");
2173 %property(Label, GetLabel, SetLabel, doc="See `GetLabel` and `SetLabel`");
2174 %property(LayoutDirection, GetLayoutDirection, SetLayoutDirection, doc="See `GetLayoutDirection` and `SetLayoutDirection`");
2175 %property(MaxHeight, GetMaxHeight, doc="See `GetMaxHeight`");
2176 %property(MaxSize, GetMaxSize, SetMaxSize, doc="See `GetMaxSize` and `SetMaxSize`");
2177 %property(MaxWidth, GetMaxWidth, doc="See `GetMaxWidth`");
2178 %property(MinHeight, GetMinHeight, doc="See `GetMinHeight`");
2179 %property(MinSize, GetMinSize, SetMinSize, doc="See `GetMinSize` and `SetMinSize`");
2180 %property(MinWidth, GetMinWidth, doc="See `GetMinWidth`");
2181 %property(Name, GetName, SetName, doc="See `GetName` and `SetName`");
2182 %property(Parent, GetParent, doc="See `GetParent`");
2183 %property(Position, GetPosition, SetPosition, doc="See `GetPosition` and `SetPosition`");
2184 %property(Rect, GetRect, SetRect, doc="See `GetRect` and `SetRect`");
2185 %property(ScreenPosition, GetScreenPosition, doc="See `GetScreenPosition`");
2186 %property(ScreenRect, GetScreenRect, doc="See `GetScreenRect`");
2187 %property(Size, GetSize, SetSize, doc="See `GetSize` and `SetSize`");
2188 %property(Sizer, GetSizer, SetSizer, doc="See `GetSizer` and `SetSizer`");
2189 %property(ThemeEnabled, GetThemeEnabled, SetThemeEnabled, doc="See `GetThemeEnabled` and `SetThemeEnabled`");
2190 %property(ToolTip, GetToolTip, SetToolTip, doc="See `GetToolTip` and `SetToolTip`");
2191 %property(UpdateClientRect, GetUpdateClientRect, doc="See `GetUpdateClientRect`");
2192 %property(UpdateRegion, GetUpdateRegion, doc="See `GetUpdateRegion`");
2193 %property(Validator, GetValidator, SetValidator, doc="See `GetValidator` and `SetValidator`");
2194 %property(VirtualSize, GetVirtualSize, SetVirtualSize, doc="See `GetVirtualSize` and `SetVirtualSize`");
2195 %property(WindowStyle, GetWindowStyle, SetWindowStyle, doc="See `GetWindowStyle` and `SetWindowStyle`");
2196 %property(WindowStyleFlag, GetWindowStyleFlag, SetWindowStyleFlag, doc="See `GetWindowStyleFlag` and `SetWindowStyleFlag`");
2197 %property(WindowVariant, GetWindowVariant, SetWindowVariant, doc="See `GetWindowVariant` and `SetWindowVariant`");
2199 %property(Shown, IsShown, Show, doc="See `IsShown` and `Show`");
2200 %property(Enabled, IsEnabled, Enable, doc="See `IsEnabled` and `Enable`");
2201 %property(TopLevel, IsTopLevel, doc="See `IsTopLevel`");
2211 def DLG_PNT(win, point_or_x, y=None):
2213 Convenience function for converting a Point or (x,y) in
2214 dialog units to pixel units.
2217 return win.ConvertDialogPointToPixels(point_or_x)
2219 return win.ConvertDialogPointToPixels(wx.Point(point_or_x, y))
2221 def DLG_SZE(win, size_width, height=None):
2223 Convenience function for converting a Size or (w,h) in
2224 dialog units to pixel units.
2227 return win.ConvertDialogSizeToPixels(size_width)
2229 return win.ConvertDialogSizeToPixels(wx.Size(size_width, height))
2235 // Unfortunatly the names of these new static methods clash with the
2236 // names wxPython has been using forever for the overloaded
2237 // wxWindow::FindWindow, so instead of swigging them as statics create
2238 // standalone functions for them.
2241 DocStr(wxFindWindowById,
2242 "Find the first window in the application with the given id. If parent
2243 is None, the search will start from all top-level frames and dialog
2244 boxes; if non-None, the search will be limited to the given window
2245 hierarchy. The search is recursive in both cases.", "");
2247 DocStr(wxFindWindowByName,
2248 "Find a window by its name (as given in a window constructor or Create
2249 function call). If parent is None, the search will start from all
2250 top-level frames and dialog boxes; if non-None, the search will be
2251 limited to the given window hierarchy. The search is recursive in both
2254 If no window with such name is found, wx.FindWindowByLabel is called.", "");
2256 DocStr(wxFindWindowByLabel,
2257 "Find a window by its label. Depending on the type of window, the label
2258 may be a window title or panel item label. If parent is None, the
2259 search will start from all top-level frames and dialog boxes; if
2260 non-None, the search will be limited to the given window
2261 hierarchy. The search is recursive in both cases.", "");
2264 MustHaveApp(wxFindWindowById);
2265 MustHaveApp(wxFindWindowByName);
2266 MustHaveApp(wxFindWindowByLabel);
2269 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2270 return wxWindow::FindWindowById(id, parent);
2273 wxWindow* wxFindWindowByName( const wxString& name,
2274 const wxWindow *parent = NULL ) {
2275 return wxWindow::FindWindowByName(name, parent);
2278 wxWindow* wxFindWindowByLabel( const wxString& label,
2279 const wxWindow *parent = NULL ) {
2280 return wxWindow::FindWindowByLabel(label, parent);
2288 #include <wx/msw/private.h> // to get wxGetWindowId
2292 MustHaveApp(wxWindow_FromHWND);
2295 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2297 WXHWND hWnd = (WXHWND)_hWnd;
2298 long id = wxGetWindowId(hWnd);
2299 wxWindow* win = new wxWindow;
2301 parent->AddChild(win);
2302 win->SetEventHandler(win);
2305 win->SubclassWin(hWnd);
2306 win->AdoptAttributesFromHWND();
2307 win->SetupColours();
2310 wxPyRaiseNotImplemented();
2316 //---------------------------------------------------------------------------
2318 DocStr(GetTopLevelWindows,
2319 "Returns a list-like object of the the application's top-level windows, (frames,
2320 dialogs, etc.)", "");
2322 wxWindowList& GetTopLevelWindows() {
2323 return wxTopLevelWindows;
2327 //---------------------------------------------------------------------------
2328 //---------------------------------------------------------------------------
projects / wxWidgets.git / blob