#define wxUSE_MENUS_NATIVE wxUSE_MENUS
#endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
+
+// Define this macro if the corresponding operating system handles the state
+// of children windows automatically when the parent is enabled/disabled.
+// Otherwise wx itself must ensure that when the parent is disabled its
+// children are disabled too, and their initial state is restored when the
+// parent is enabled back.
+#if defined(__WXMSW__) || defined(__WXPM__)
+ // must do everything ourselves
+ #undef wxHAS_NATIVE_ENABLED_MANAGEMENT
+#else
+ #define wxHAS_NATIVE_ENABLED_MANAGEMENT
+#endif
+
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
void SetInitialSize(const wxSize& size=wxDefaultSize);
wxDEPRECATED( void SetBestFittingSize(const wxSize& size=wxDefaultSize) ); // replaced by SetInitialSize
-
+
// the generic centre function - centers the window on parent by`
// default or on screen if it doesn't have parent or
// wxCENTER_ON_SCREEN flag is given
// and it is therefore overridden in wxTLW to do that.
// In wxWindow(Base), it has (unfortunately) been abused
// to mean the same as SetMinSize() and SetMaxSize().
-
+
virtual void SetSizeHints( int minW, int minH,
int maxW = wxDefaultCoord, int maxH = wxDefaultCoord,
int incW = wxDefaultCoord, int incH = wxDefaultCoord )
}
- // Call these to override what GetBestSize() returns. This
+ // Call these to override what GetBestSize() returns. This
// method is only virtual because it is overriden in wxTLW
// as a different API for SetSizeHints().
virtual void SetMinSize(const wxSize& minSize) { m_minWidth = minSize.x; m_minHeight = minSize.y; }
virtual void SetMaxSize(const wxSize& maxSize) { m_maxWidth = maxSize.x; m_maxHeight = maxSize.y; }
// Override these methods to impose restrictions on min/max size.
- // The easier way is to call SetMinSize() and SetMaxSize() which
+ // The easier way is to call SetMinSize() and SetMaxSize() which
// will have the same effect. Doing both is non-sense.
virtual wxSize GetMinSize() const { return wxSize(m_minWidth, m_minHeight); }
virtual wxSize GetMaxSize() const { return wxSize(m_maxWidth, m_maxHeight); }
bool Disable() { return Enable(false); }
virtual bool IsShown() const { return m_isShown; }
- virtual bool IsEnabled() const { return m_isEnabled; }
+ // returns true if the window is really enabled and false otherwise,
+ // whether because it had been explicitly disabled itself or because
+ // its parent is currently disabled -- then this method returns false
+ // whatever is the intrinsic state of this window, use IsThisEnabled(0
+ // to retrieve it. In other words, this relation always holds:
+ //
+ // IsEnabled() == IsThisEnabled() && parent.IsEnabled()
+ //
+ bool IsEnabled() const;
+
+ // returns the internal window state independently of the parent(s)
+ // state, i.e. the state in which the window would be if all its
+ // parents were enabled (use IsEnabled() above to get the effective
+ // window state)
+ bool IsThisEnabled() const { return m_isEnabled; }
// returns true if the window is visible, i.e. IsShown() returns true
// if called on it and all its parents up to the first TLW
void SetWindowStyle( long style ) { SetWindowStyleFlag(style); }
long GetWindowStyle() const { return GetWindowStyleFlag(); }
+ // check if the flag is set
bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; }
virtual bool IsRetained() const { return HasFlag(wxRETAINED); }
+ // turn the flag on if it had been turned off before and vice versa,
+ // return true if the flag is currently turned on
+ bool ToggleWindowStyle(int flag);
+
// extra style: the less often used style bits which can't be set with
// SetWindowStyleFlag()
virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; }
long GetExtraStyle() const { return m_exStyle; }
+ bool HasExtraStyle(int exFlag) const { return (m_exStyle & exFlag) != 0; }
+
// make the window modal (all other windows unresponsive)
virtual void MakeModal(bool modal = true);
static wxWindow *DoFindFocus() /* = 0: implement in derived classes */;
- // can this window have focus?
- virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
+ // can this window have focus in principle?
+ //
+ // the difference between AcceptsFocus[FromKeyboard]() and CanAcceptFocus
+ // [FromKeyboard]() is that the former functions are meant to be
+ // overridden in the derived classes to simply return false if the
+ // control can't have focus, while the latter are meant to be used by
+ // this class clients and take into account the current window state
+ virtual bool AcceptsFocus() const { return true; }
+
+ // can this window or one of its children accept focus?
+ //
+ // usually it's the same as AcceptsFocus() but is overridden for
+ // container windows
+ virtual bool AcceptsFocusRecursively() const { return AcceptsFocus(); }
// can this window be given focus by keyboard navigation? if not, the
// only way to give it focus (provided it accepts it at all) is to
// click it
virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }
- // navigates in the specified direction by sending a wxNavigationKeyEvent
- virtual bool Navigate(int flags = wxNavigationKeyEvent::IsForward);
+
+ // this is mostly a helper for the various functions using it below
+ bool CanBeFocused() const { return IsShown() && IsEnabled(); }
+
+ // can this window itself have focus?
+ bool IsFocusable() const { return AcceptsFocus() && CanBeFocused(); }
+
+ // can this window have focus right now?
+ //
+ // if this method returns true, it means that calling SetFocus() will
+ // put focus either to this window or one of its children, if you need
+ // to know whether this window accepts focus itself, use IsFocusable()
+ bool CanAcceptFocus() const
+ { return AcceptsFocusRecursively() && CanBeFocused(); }
+
+ // can this window be assigned focus from keyboard right now?
+ bool CanAcceptFocusFromKeyboard() const
+ { return AcceptsFocusFromKeyboard() && CanBeFocused(); }
+
+ // call this when the return value of AcceptsFocus() changes
+ virtual void SetCanFocus(bool WXUNUSED(canFocus)) { }
+
+ // navigates inside this window
+ bool NavigateIn(int flags = wxNavigationKeyEvent::IsForward)
+ { return DoNavigateIn(flags); }
+
+ // navigates in the specified direction from this window, this is
+ // equivalent to GetParent()->NavigateIn()
+ bool Navigate(int flags = wxNavigationKeyEvent::IsForward)
+ { return m_parent && ((wxWindowBase *)m_parent)->DoNavigateIn(flags); }
// move this window just before/after the specified one in tab order
// (the other window must be our sibling!)
virtual void AddChild( wxWindowBase *child );
virtual void RemoveChild( wxWindowBase *child );
+ // returns true if the child is in the client area of the window, i.e. is
+ // not scrollbar, toolbar etc.
+ virtual bool IsClientAreaChild(const wxWindow *WXUNUSED(child)) const
+ { return true; }
+
// looking for windows
// -------------------
const wxFont *theFont = (const wxFont *) NULL)
const = 0;
+ wxSize GetTextExtent(const wxString& string) const
+ {
+ wxCoord w, h;
+ GetTextExtent(string, &w, &h);
+ return wxSize(w, h);
+ }
+
// client <-> screen coords
// ------------------------
void SetAccessible(wxAccessible* accessible) ;
// Returns the accessible object.
- wxAccessible* GetAccessible() { return m_accessible; };
+ wxAccessible* GetAccessible() { return m_accessible; }
// Returns the accessible object, creating if necessary.
wxAccessible* GetOrCreateAccessible() ;
// behaviour in the most common case
virtual bool ShouldInheritColours() const { return false; }
+ // returns true if the window can be positioned outside of parent's client
+ // area (normal windows can't, but e.g. menubar or statusbar can):
+ virtual bool CanBeOutsideClientArea() const { return false; }
+
protected:
// event handling specific to wxWindow
virtual bool TryValidator(wxEvent& event);
};
virtual void DoMoveInTabOrder(wxWindow *win, MoveKind move);
+ // implementation of Navigate() and NavigateIn()
+ virtual bool DoNavigateIn(int flags);
+
+
#if wxUSE_CONSTRAINTS
// satisfy the constraints for the windows but don't set the window sizes
void SatisfyConstraints();
virtual wxWindow *GetMainWindowOfCompositeControl()
{ return (wxWindow*)this; }
+ // this method should be implemented to use operating system specific code
+ // to really enable/disable the widget, it will only be called when we
+ // really need to enable/disable window and so no additional checks on the
+ // widgets state are necessary
+ virtual void DoEnable(bool WXUNUSED(enable)) { }
+
+ // called when the on-screen widget state changes and provides an
+ // an opportunity for the widget to update its visual state (colours,
+ // fonts, anything else) as necessary
+ virtual void OnEnabled(bool WXUNUSED(enabled)) { }
+
+
// the window id - a number which uniquely identifies a window among
// its siblings unless it is wxID_ANY
wxWindowID m_windowId;
static void NotifyCaptureLost();
private:
+ // recursively call our own and our children OnEnabled() when the
+ // enabled/disabled status changed because a parent window had been
+ // enabled/disabled
+ void NotifyWindowOnEnableChange(bool enabled);
+
+
// contains the last id generated by NewControlId
static int ms_lastControlId;
projects / wxWidgets.git / blobdiff