derive univ toggle button from button

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@39320 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/univ/button.h

@@ -95,7 +95,7 @@ public:
     virtual bool IsDefault() const { return m_isDefault; }
 
     // wxButton actions
-    void Toggle();
+    virtual void Toggle();
     virtual void Press();
     virtual void Release();
     virtual void Click();

include/wx/univ/tglbtn.h

@@ -12,70 +12,20 @@
 #ifndef _WX_UNIV_TGLBTN_H_
 #define _WX_UNIV_TGLBTN_H_
 
-#include "wx/bitmap.h"
+#include "wx/button.h"
 
 extern WXDLLEXPORT_DATA(const wxChar) wxCheckBoxNameStr[];
 
-// ----------------------------------------------------------------------------
-// the actions supported by this control
-// ----------------------------------------------------------------------------
-
-#define wxACTION_BUTTON_TOGGLE  _T("toggle")    // press/release the button
-#define wxACTION_BUTTON_PRESS   _T("press")     // press the button
-#define wxACTION_BUTTON_RELEASE _T("release")   // release the button
-#define wxACTION_BUTTON_CLICK   _T("click")     // generate button click event
-
 // ----------------------------------------------------------------------------
 // wxToggleButton: a push button
 // ----------------------------------------------------------------------------
 
-class WXDLLIMPEXP_CORE wxToggleButton: public wxControl
+class WXDLLIMPEXP_CORE wxToggleButton: public wxButton
 {
 public:
-    wxToggleButton() { Init(); }
+    wxToggleButton();
-    wxToggleButton(wxWindow *parent,
-             wxWindowID id,
-             const wxBitmap& bitmap,
-             const wxString& label = wxEmptyString,
-             const wxPoint& pos = wxDefaultPosition,
-             const wxSize& size = wxDefaultSize,
-             long style = 0,
-             const wxValidator& validator = wxDefaultValidator,
-             const wxString& name = wxCheckBoxNameStr)
-    {
-        Init();
-
-        Create(parent, id, bitmap, label, pos, size, style, validator, name);
-    }
 
     wxToggleButton(wxWindow *parent,
-             wxWindowID id,
-             const wxString& label = wxEmptyString,
-             const wxPoint& pos = wxDefaultPosition,
-             const wxSize& size = wxDefaultSize,
-             long style = 0,
-             const wxValidator& validator = wxDefaultValidator,
-             const wxString& name = wxCheckBoxNameStr)
-    {
-        Init();
-
-        Create(parent, id, label, pos, size, style, validator, name);
-    }
-
-    bool Create(wxWindow *parent,
-                wxWindowID id,
-                const wxString& label = wxEmptyString,
-                const wxPoint& pos = wxDefaultPosition,
-                const wxSize& size = wxDefaultSize,
-                long style = 0,
-                const wxValidator& validator = wxDefaultValidator,
-                const wxString& name = wxCheckBoxNameStr)
-    {
-        return Create(parent, id, wxNullBitmap, label,
-                      pos, size, style, validator, name);
-    }
-    
-    bool Create(wxWindow *parent,
              wxWindowID id,
              const wxBitmap& bitmap,
              const wxString& label = wxEmptyString,
@@ -85,79 +35,36 @@ public:
              const wxValidator& validator = wxDefaultValidator,
              const wxString& name = wxCheckBoxNameStr);
 
-    virtual ~wxToggleButton();
+    wxToggleButton(wxWindow *parent,
+             wxWindowID id,
+             const wxString& label = wxEmptyString,
+             const wxPoint& pos = wxDefaultPosition,
+             const wxSize& size = wxDefaultSize,
+             long style = 0,
+             const wxValidator& validator = wxDefaultValidator,
+             const wxString& name = wxCheckBoxNameStr);
 
-    virtual void SetImageLabel(const wxBitmap& bitmap);
+    virtual ~wxToggleButton();
-    virtual void SetImageMargins(wxCoord x, wxCoord y);
 
     virtual bool IsPressed() const { return m_isPressed || m_value; }
 
     // wxToggleButton actions
-    void Toggle();
+    virtual void Toggle();
-    virtual void Press();
-    virtual void Release();
     virtual void Click();
 
     // Get/set the value
     void SetValue(bool state);
     bool GetValue() const { return m_value; }
 
-    // returns the default button size for this platform
-    static wxSize GetDefaultSize();
-
-    virtual bool PerformAction(const wxControlAction& action,
-                               long numArg = -1,
-                               const wxString& strArg = wxEmptyString);
-
-    virtual bool CanBeHighlighted() const { return true; }
-
 protected:
-    virtual wxSize DoGetBestClientSize() const;
-    
-    virtual bool DoDrawBackground(wxDC& dc);
-    virtual void DoDraw(wxControlRenderer *renderer);
-
-    // common part of all ctors
-    void Init();
-
-    // current state - is the user currently pressing the button
-    bool m_isPressed;
-    
     // the current value
     bool m_value;
 
-    // the (optional) image to show and the margins around it
-    wxBitmap m_bitmap;
-    wxCoord  m_marginBmpX,
-             m_marginBmpY;
-
 private:
+    // common part of all ctors
+    void Init();
+
     DECLARE_DYNAMIC_CLASS(wxToggleButton)
 };
-// wxStdToggleButtonInputHandler: translates SPACE and ENTER keys and the left mouse
-// click into button press/release actions
-// ----------------------------------------------------------------------------
-
-class WXDLLEXPORT wxStdToggleButtonInputHandler : public wxStdInputHandler
-{
-public:
-    wxStdToggleButtonInputHandler(wxInputHandler *inphand);
-
-    virtual bool HandleKey(wxInputConsumer *consumer,
-                           const wxKeyEvent& event,
-                           bool pressed);
-    virtual bool HandleMouse(wxInputConsumer *consumer,
-                             const wxMouseEvent& event);
-    virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
-    virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
-    virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
-
-private:
-    // the window (button) which has capture or NULL and the flag telling if
-    // the mouse is inside the button which captured it or not
-    wxWindow *m_winCapture;
-    bool      m_winHasMouse;
-};
 
 #endif // _WX_UNIV_TGLBTN_H_
-

src/univ/tglbtn.cpp

@@ -9,14 +9,6 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
@@ -27,215 +19,50 @@
 
 #include "wx/tglbtn.h"
 
-#ifndef WX_PRECOMP
-    #include "wx/dcclient.h"
-    #include "wx/dcscreen.h"
-    #include "wx/button.h"
-    #include "wx/validate.h"
-    #include "wx/settings.h"
-#endif
-
-#include "wx/univ/renderer.h"
-#include "wx/univ/inphand.h"
-#include "wx/univ/theme.h"
-#include "wx/univ/colschem.h"
-#include "wx/stockitem.h"
-
-// ----------------------------------------------------------------------------
-// constants
-// ----------------------------------------------------------------------------
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED)
 
-// default margins around the image
+IMPLEMENT_DYNAMIC_CLASS(wxToggleButton, wxButton)
-static const wxCoord DEFAULT_BTN_MARGIN_X = 0;  // We should give space for the border, at least.
-static const wxCoord DEFAULT_BTN_MARGIN_Y = 0;
 
-// ============================================================================
+wxToggleButton::wxToggleButton()
-// implementation
-// ============================================================================
-
-IMPLEMENT_DYNAMIC_CLASS(wxToggleButton, wxControl)
-
-// ----------------------------------------------------------------------------
-// creation
-// ----------------------------------------------------------------------------
-
-void wxToggleButton::Init()
 {
-    m_isPressed = false;
+    Init();
-    m_value = false;
 }
 
-bool wxToggleButton::Create(wxWindow *parent,
+wxToggleButton::wxToggleButton(wxWindow *parent,
                                wxWindowID id,
                                const wxBitmap& bitmap,
-                      const wxString &lbl,
+                               const wxString& label,
-                      const wxPoint &pos,
+                               const wxPoint& pos,
-                      const wxSize &size,
+                               const wxSize& size,
                                long style,
                                const wxValidator& validator,
-                      const wxString &name)
+                               const wxString& name)
 {
-    wxString label(lbl);
+    Init();
-    if (label.empty() && wxIsStockID(id))
+    Create(parent, id, bitmap, label, pos, size, style, validator, name);
-        label = wxGetStockLabel(id);
+}
 
-    long ctrl_style = style & ~wxBU_ALIGN_MASK;
+wxToggleButton::wxToggleButton(wxWindow *parent,
-
+                               wxWindowID id,
-    wxASSERT_MSG( (ctrl_style & wxALIGN_MASK) == 0,
+                               const wxString& label,
-                  _T("Some style conflicts with align flags") );
+                               const wxPoint& pos,
-
+                               const wxSize& size,
-    if((style & wxBU_RIGHT) == wxBU_RIGHT)
+                               long style,
-        ctrl_style |= wxALIGN_RIGHT;
+                               const wxValidator& validator,
-    else if((style & wxBU_LEFT) == wxBU_LEFT)
+                               const wxString& name)
-        ctrl_style |= wxALIGN_LEFT;
+{
-    else
+    Init();
-        ctrl_style |= wxALIGN_CENTRE_HORIZONTAL;
+    Create(parent, id, label, pos, size, style, validator, name);
-
-    if((style & wxBU_TOP) == wxBU_TOP)
-        ctrl_style |= wxALIGN_TOP;
-    else if((style & wxBU_BOTTOM) == wxBU_BOTTOM)
-        ctrl_style |= wxALIGN_BOTTOM;
-    else
-        ctrl_style |= wxALIGN_CENTRE_VERTICAL;
-
-    if ( !wxControl::Create(parent, id, pos, size, ctrl_style, validator, name) )
-        return false;
-
-    SetLabel(label);
-    SetImageLabel(bitmap);
-    // SetBestSize(size); -- called by SetImageLabel()
-
-    CreateInputHandler(wxINP_HANDLER_BUTTON);
-
-    return true;
 }
 
 wxToggleButton::~wxToggleButton()
 {
 }
 
-// ----------------------------------------------------------------------------
+void wxToggleButton::Init()
-// size management
-// ----------------------------------------------------------------------------
-
-/* static */
-wxSize wxToggleButton::GetDefaultSize()
 {
-    static wxSize s_sizeBtn;
-
-    if ( s_sizeBtn.x == 0 )
-    {
-        wxScreenDC dc;
-
-        // this corresponds more or less to wxMSW standard in Win32 theme (see
-        // wxWin32Renderer::AdjustSize())
-//        s_sizeBtn.x = 8*dc.GetCharWidth();
-//        s_sizeBtn.y = (11*dc.GetCharHeight())/10 + 2;
-        // Otto Wyss, Patch 664399
-        s_sizeBtn.x = dc.GetCharWidth()*10 + 2;
-        s_sizeBtn.y = dc.GetCharHeight()*11/10 + 2;
-    }
-
-    return s_sizeBtn;
-}
-
-wxSize wxToggleButton::DoGetBestClientSize() const
-{
-    wxClientDC dc(wxConstCast(this, wxToggleButton));
-    wxCoord width, height;
-    dc.GetMultiLineTextExtent(GetLabel(), &width, &height);
-
-    if ( m_bitmap.Ok() )
-    {
-        // allocate extra space for the bitmap
-        wxCoord heightBmp = m_bitmap.GetHeight() + 2*m_marginBmpY;
-        if ( height < heightBmp )
-            height = heightBmp;
-
-        width += m_bitmap.GetWidth() + 2*m_marginBmpX;
-    }
-
-    // The default size should not be adjusted, so the code is moved into the
-    // renderer. This is conceptual wrong but currently the only solution.
-    // (Otto Wyss, Patch 664399)
-
-/*
-    // for compatibility with other ports, the buttons default size is never
-    // less than the standard one, but not when display not PDAs.
-    if (wxSystemSettings::GetScreenType() > wxSYS_SCREEN_PDA)
-    {
-        if ( !(GetWindowStyle() & wxBU_EXACTFIT) )
-        {
-            wxSize szDef = GetDefaultSize();
-            if ( width < szDef.x )
-                width = szDef.x;
-        }
-    }
-*/
-    return wxSize(width, height);
-}
-
-// ----------------------------------------------------------------------------
-// drawing
-// ----------------------------------------------------------------------------
-
-void wxToggleButton::DoDraw(wxControlRenderer *renderer)
-{
-    if ( !(GetWindowStyle() & wxBORDER_NONE) )
-    {
-        renderer->DrawButtonBorder();
-    }
-
-    renderer->DrawLabel(m_bitmap, m_marginBmpX, m_marginBmpY);
-}
-
-bool wxToggleButton::DoDrawBackground(wxDC& dc)
-{
-    wxRect rect;
-    wxSize size = GetSize();
-    rect.width = size.x;
-    rect.height = size.y;
-
-    if ( GetBackgroundBitmap().Ok() )
-    {
-        // get the bitmap and the flags
-        int alignment;
-        wxStretch stretch;
-        wxBitmap bmp = GetBackgroundBitmap(&alignment, &stretch);
-        wxControlRenderer::DrawBitmap(dc, bmp, rect, alignment, stretch);
-    }
-    else
-    {
-        m_renderer->DrawButtonSurface(dc, wxTHEME_BG_COLOUR(this),
-                                      rect, GetStateFlags());
-    }
-
-    return true;
-}
-
-// ----------------------------------------------------------------------------
-// input processing
-// ----------------------------------------------------------------------------
-
-void wxToggleButton::Press()
-{
-    if ( !m_isPressed )
-    {
-        m_isPressed = true;
-
-        Refresh();
-    }
-}
-
-void wxToggleButton::Release()
-{
-    if ( m_isPressed )
-    {
     m_isPressed = false;
-
+    m_value = false;
-        Refresh();
-    }
 }
 
 void wxToggleButton::Toggle()
@@ -262,177 +89,10 @@ void wxToggleButton::Click()
     Command(event);
 }
 
-bool wxToggleButton::PerformAction(const wxControlAction& action,
-                             long numArg,
-                             const wxString& strArg)
-{
-    if ( action == wxACTION_BUTTON_TOGGLE )
-        Toggle();
-    else if ( action == wxACTION_BUTTON_CLICK )
-        Click();
-    else if ( action == wxACTION_BUTTON_PRESS )
-        Press();
-    else if ( action == wxACTION_BUTTON_RELEASE )
-        Release();
-    else
-        return wxControl::PerformAction(action, numArg, strArg);
-
-    return true;
-}
-
-// ----------------------------------------------------------------------------
-// misc
-// ----------------------------------------------------------------------------
-
-void wxToggleButton::SetImageLabel(const wxBitmap& bitmap)
-{
-    m_bitmap = bitmap;
-
-    SetImageMargins(DEFAULT_BTN_MARGIN_X, DEFAULT_BTN_MARGIN_Y);
-}
-
-void wxToggleButton::SetImageMargins(wxCoord x, wxCoord y)
-{
-    m_marginBmpX = x + 2;
-    m_marginBmpY = y + 2;
-
-    SetBestSize(wxDefaultSize);
-}
-
-// void SetValue(bool state)
-// Set the value of the toggle button.
 void wxToggleButton::SetValue(bool state)
 {
     m_value = state;
     Refresh();
 }
 
-// ============================================================================
-// wxStdButtonInputHandler
-// ============================================================================
-
-wxStdToggleButtonInputHandler::wxStdToggleButtonInputHandler(wxInputHandler *handler)
-                       : wxStdInputHandler(handler)
-{
-    m_winCapture = NULL;
-    m_winHasMouse = false;
-}
-
-bool wxStdToggleButtonInputHandler::HandleKey(wxInputConsumer *consumer,
-                                        const wxKeyEvent& event,
-                                        bool pressed)
-{
-    int keycode = event.GetKeyCode();
-    if ( keycode == WXK_SPACE || keycode == WXK_RETURN )
-    {
-        consumer->PerformAction(wxACTION_BUTTON_TOGGLE);
-
-        return true;
-    }
-
-    return wxStdInputHandler::HandleKey(consumer, event, pressed);
-}
-
-bool wxStdToggleButtonInputHandler::HandleMouse(wxInputConsumer *consumer,
-                                          const wxMouseEvent& event)
-{
-    // the button has 2 states: pressed and normal with the following
-    // transitions between them:
-    //
-    //      normal -> left down -> capture mouse and go to pressed state
-    //      pressed -> left up inside -> generate click -> go to normal
-    //                         outside ------------------>
-    //
-    // the other mouse buttons are ignored
-    if ( event.Button(1) )
-    {
-        if ( event.LeftDown() || event.LeftDClick() )
-        {
-            m_winCapture = consumer->GetInputWindow();
-            m_winCapture->CaptureMouse();
-            m_winHasMouse = true;
-
-            consumer->PerformAction(wxACTION_BUTTON_PRESS);
-
-            return true;
-        }
-        else if ( event.LeftUp() )
-        {
-            if ( m_winCapture )
-            {
-                m_winCapture->ReleaseMouse();
-                m_winCapture = NULL;
-            }
-
-            if ( m_winHasMouse )
-            {
-                // this will generate a click event
-                consumer->PerformAction(wxACTION_BUTTON_TOGGLE);
-
-                return true;
-            }
-            //else: the mouse was released outside the window, this doesn't
-            //      count as a click
-        }
-        //else: don't do anything special about the double click
-    }
-
-    return wxStdInputHandler::HandleMouse(consumer, event);
-}
-
-bool wxStdToggleButtonInputHandler::HandleMouseMove(wxInputConsumer *consumer,
-                                              const wxMouseEvent& event)
-{
-    // we only have to do something when the mouse leaves/enters the pressed
-    // button and don't care about the other ones
-    if ( event.GetEventObject() == m_winCapture )
-    {
-        // leaving the button should remove its pressed state
-        if ( event.Leaving() )
-        {
-            // remember that the mouse is now outside
-            m_winHasMouse = false;
-
-            // we do have a pressed button, so release it
-            consumer->GetInputWindow()->SetCurrent(false);
-            consumer->PerformAction(wxACTION_BUTTON_RELEASE);
-
-            return true;
-        }
-        // and entering it back should make it pressed again if it had been
-        // pressed
-        else if ( event.Entering() )
-        {
-            // the mouse is (back) inside the button
-            m_winHasMouse = true;
-
-            // we did have a pressed button which we released when leaving the
-            // window, press it again
-            consumer->GetInputWindow()->SetCurrent(true);
-            consumer->PerformAction(wxACTION_BUTTON_PRESS);
-
-            return true;
-        }
-    }
-
-    return wxStdInputHandler::HandleMouseMove(consumer, event);
-}
-
-bool wxStdToggleButtonInputHandler::HandleFocus(wxInputConsumer * WXUNUSED(consumer),
-                                          const wxFocusEvent& WXUNUSED(event))
-{
-    // buttons change appearance when they get/lose focus, so return true to
-    // refresh
-    return true;
-}
-
-bool wxStdToggleButtonInputHandler::HandleActivation(wxInputConsumer *consumer,
-                                               bool WXUNUSED(activated))
-{
-    // the default button changes appearance when the app is [de]activated, so
-    // return true to refresh
-    return wxStaticCast(consumer->GetInputWindow(), wxToggleButton)->IsDefault();
-}
-
 #endif // wxUSE_TOGGLEBTN
-