Applied #15375 to stop event-sending in generic wxSpinCtrl ctor (eco)

[wxWidgets.git] / src / univ / button.cpp

diff --git a/src/univ/button.cpp b/src/univ/button.cpp
index ee1ac0321c85e6c43f256e62f98f7db2fdd84a15..61203eab642292bab69d26cb129fbad6160f98bd 100644 (file)
--- a/src/univ/button.cpp
+++ b/src/univ/button.cpp
@@ -1,11 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        univ/button.cpp
+// Name:        src/univ/button.cpp

 // Purpose:     wxButton
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     14.08.00
 // Purpose:     wxButton
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     14.08.00

-// RCS-ID:      $Id$
-// Copyright:   (c) 2000 Vadim Zeitlin
+// Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -17,10 +16,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "univbutton.h"
-#endif
-

 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__


@@ -34,26 +29,55 @@
     #include "wx/dcscreen.h"
     #include "wx/button.h"
     #include "wx/validate.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"
 #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"
+
+// ----------------------------------------------------------------------------
+// wxStdButtonInputHandler: translates SPACE and ENTER keys and the left mouse
+// click into button press/release actions
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStdButtonInputHandler : public wxStdInputHandler
+{
+public:
+    wxStdButtonInputHandler(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;
+};

 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // default margins around the image
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // default margins around the image

-static const wxCoord DEFAULT_BTN_MARGIN_X = 0;
+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;
 
 // ============================================================================
 // implementation
 // ============================================================================
 
 static const wxCoord DEFAULT_BTN_MARGIN_Y = 0;
 
 // ============================================================================
 // implementation
 // ============================================================================
 

-IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
-

 // ----------------------------------------------------------------------------
 // creation
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // creation
 // ----------------------------------------------------------------------------


@@ -61,35 +85,53 @@ IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
 void wxButton::Init()
 {
     m_isPressed =
 void wxButton::Init()
 {
     m_isPressed =

-    m_isDefault = FALSE;
+    m_isDefault = false;

 }
 
 bool wxButton::Create(wxWindow *parent,
                       wxWindowID id,
                       const wxBitmap& bitmap,
 }
 
 bool wxButton::Create(wxWindow *parent,
                       wxWindowID id,
                       const wxBitmap& bitmap,

-                      const wxString &label,
+                      const wxString &lbl,

                       const wxPoint &pos,
                       const wxSize &size,
                       long style,
                       const wxValidator& validator,
                       const wxString &name)
 {
                       const wxPoint &pos,
                       const wxSize &size,
                       long style,
                       const wxValidator& validator,
                       const wxString &name)
 {

-    // center label by default
-    if ( !(style & wxALIGN_MASK) )
-    {
-        style |= wxALIGN_CENTRE_HORIZONTAL | wxALIGN_CENTRE_VERTICAL;
-    }
+    wxString label(lbl);
+    if (label.empty() && wxIsStockID(id))
+        label = wxGetStockLabel(id);

 
 

-    if ( !wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name) )
-        return FALSE;
+    long ctrl_style = style & ~wxBU_ALIGN_MASK;
+    ctrl_style = ctrl_style & ~wxALIGN_MASK;
+
+    if((style & wxBU_RIGHT) == wxBU_RIGHT)
+        ctrl_style |= wxALIGN_RIGHT;
+    else if((style & wxBU_LEFT) == wxBU_LEFT)
+        ctrl_style |= wxALIGN_LEFT;
+    else
+        ctrl_style |= wxALIGN_CENTRE_HORIZONTAL;
+
+    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);
 
     SetLabel(label);

-    SetImageLabel(bitmap);
-    // SetBestSize(size); -- called by SetImageLabel()
+
+    if (bitmap.IsOk())
+        SetBitmap(bitmap); // SetInitialSize called by SetBitmap()
+    else
+        SetInitialSize(size);

 
     CreateInputHandler(wxINP_HANDLER_BUTTON);
 
 
     CreateInputHandler(wxINP_HANDLER_BUTTON);
 

-    return TRUE;
+    return true;

 }
 
 wxButton::~wxButton()
 }
 
 wxButton::~wxButton()


@@ -111,8 +153,11 @@ wxSize wxButtonBase::GetDefaultSize()
 
         // this corresponds more or less to wxMSW standard in Win32 theme (see
         // wxWin32Renderer::AdjustSize())
 
         // 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;
+//        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;
     }
 
     return s_sizeBtn;


@@ -124,7 +169,7 @@ wxSize wxButton::DoGetBestClientSize() const
     wxCoord width, height;
     dc.GetMultiLineTextExtent(GetLabel(), &width, &height);
 
     wxCoord width, height;
     dc.GetMultiLineTextExtent(GetLabel(), &width, &height);
 

-    if ( m_bitmap.Ok() )
+    if ( m_bitmap.IsOk() )

     {
         // allocate extra space for the bitmap
         wxCoord heightBmp = m_bitmap.GetHeight() + 2*m_marginBmpY;
     {
         // allocate extra space for the bitmap
         wxCoord heightBmp = m_bitmap.GetHeight() + 2*m_marginBmpY;


@@ -134,12 +179,23 @@ wxSize wxButton::DoGetBestClientSize() const
         width += m_bitmap.GetWidth() + 2*m_marginBmpX;
     }
 
         width += m_bitmap.GetWidth() + 2*m_marginBmpX;
     }
 

-    // for compatibility with other ports, the buttons default size is never
-    // less than the standard one
-    wxSize szDef = GetDefaultSize();
-    if ( width < szDef.x )
-        width = szDef.x;
+    // 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);
 }
 
     return wxSize(width, height);
 }
 


@@ -149,8 +205,36 @@ wxSize wxButton::DoGetBestClientSize() const
 
 void wxButton::DoDraw(wxControlRenderer *renderer)
 {
 
 void wxButton::DoDraw(wxControlRenderer *renderer)
 {

-    renderer->DrawButtonBorder();
-    renderer->DrawLabel(m_bitmap, m_marginBmpX, m_marginBmpY);
+    if ( !(GetWindowStyle() & wxBORDER_NONE) )
+    {
+        renderer->DrawButtonBorder();
+    }
+
+    renderer->DrawButtonLabel(m_bitmap, m_marginBmpX, m_marginBmpY);
+}
+
+bool wxButton::DoDrawBackground(wxDC& dc)
+{
+    wxRect rect;
+    wxSize size = GetSize();
+    rect.width = size.x;
+    rect.height = size.y;
+
+    if ( GetBackgroundBitmap().IsOk() )
+    {
+        // 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;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -161,7 +245,7 @@ void wxButton::Press()
 {
     if ( !m_isPressed )
     {
 {
     if ( !m_isPressed )
     {

-        m_isPressed = TRUE;
+        m_isPressed = true;

 
         Refresh();
     }
 
         Refresh();
     }


@@ -171,7 +255,7 @@ void wxButton::Release()
 {
     if ( m_isPressed )
     {
 {
     if ( m_isPressed )
     {

-        m_isPressed = FALSE;
+        m_isPressed = false;

 
         Refresh();
     }
 
         Refresh();
     }


@@ -193,7 +277,7 @@ void wxButton::Toggle()
 
 void wxButton::Click()
 {
 
 void wxButton::Click()
 {

-    wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
+    wxCommandEvent event(wxEVT_BUTTON, GetId());

     InitCommandEvent(event);
     Command(event);
 }
     InitCommandEvent(event);
     Command(event);
 }


@@ -213,31 +297,44 @@ bool wxButton::PerformAction(const wxControlAction& action,
     else
         return wxControl::PerformAction(action, numArg, strArg);
 
     else
         return wxControl::PerformAction(action, numArg, strArg);
 

-    return TRUE;
+    return true;
+}
+
+/* static */
+wxInputHandler *wxButton::GetStdInputHandler(wxInputHandler *handlerDef)
+{
+    static wxStdButtonInputHandler s_handlerBtn(handlerDef);
+
+    return &s_handlerBtn;

 }
 
 // ----------------------------------------------------------------------------
 // misc
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // misc
 // ----------------------------------------------------------------------------
 

-void wxButton::SetImageLabel(const wxBitmap& bitmap)
+void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)

 {
 {

-    m_bitmap = bitmap;
+    // we support only one bitmap right now, although this wouldn't be
+    // difficult to change
+    if ( which == State_Normal )
+        m_bitmap = bitmap;

 
 

-    SetImageMargins(DEFAULT_BTN_MARGIN_X, DEFAULT_BTN_MARGIN_Y);
+    SetBitmapMargins(DEFAULT_BTN_MARGIN_X, DEFAULT_BTN_MARGIN_Y);

 }
 
 }
 

-void wxButton::SetImageMargins(wxCoord x, wxCoord y)
+void wxButton::DoSetBitmapMargins(wxCoord x, wxCoord y)

 {
 {

-    m_marginBmpX = x;
-    m_marginBmpY = y;
+    m_marginBmpX = x + 2;
+    m_marginBmpY = y + 2;

 
 

-    SetBestSize(wxDefaultSize);
+    SetInitialSize(wxDefaultSize);

 }
 
 }
 

-void wxButton::SetDefault()
+wxWindow *wxButton::SetDefault()

 {
 {

-    m_isDefault = TRUE;
+    m_isDefault = true;
+
+    return wxButtonBase::SetDefault();

 }
 
 // ============================================================================
 }
 
 // ============================================================================


@@ -248,25 +345,25 @@ wxStdButtonInputHandler::wxStdButtonInputHandler(wxInputHandler *handler)
                        : wxStdInputHandler(handler)
 {
     m_winCapture = NULL;
                        : wxStdInputHandler(handler)
 {
     m_winCapture = NULL;

-    m_winHasMouse = FALSE;
+    m_winHasMouse = false;

 }
 
 }
 

-bool wxStdButtonInputHandler::HandleKey(wxControl *control,
+bool wxStdButtonInputHandler::HandleKey(wxInputConsumer *consumer,

                                         const wxKeyEvent& event,
                                         bool pressed)
 {
     int keycode = event.GetKeyCode();
     if ( keycode == WXK_SPACE || keycode == WXK_RETURN )
     {
                                         const wxKeyEvent& event,
                                         bool pressed)
 {
     int keycode = event.GetKeyCode();
     if ( keycode == WXK_SPACE || keycode == WXK_RETURN )
     {

-        control->PerformAction(wxACTION_BUTTON_TOGGLE);
+        consumer->PerformAction(wxACTION_BUTTON_TOGGLE);

 
 

-        return TRUE;
+        return true;

     }
 
     }
 

-    return wxStdInputHandler::HandleKey(control, event, pressed);
+    return wxStdInputHandler::HandleKey(consumer, event, pressed);

 }
 
 }
 

-bool wxStdButtonInputHandler::HandleMouse(wxControl *control,
+bool wxStdButtonInputHandler::HandleMouse(wxInputConsumer *consumer,

                                           const wxMouseEvent& event)
 {
     // the button has 2 states: pressed and normal with the following
                                           const wxMouseEvent& event)
 {
     // the button has 2 states: pressed and normal with the following


@@ -279,17 +376,17 @@ bool wxStdButtonInputHandler::HandleMouse(wxControl *control,
     // the other mouse buttons are ignored
     if ( event.Button(1) )
     {
     // the other mouse buttons are ignored
     if ( event.Button(1) )
     {

-        if ( event.ButtonDown(1) )
+        if ( event.LeftDown() || event.LeftDClick() )

         {
         {

-            m_winCapture = control;
+            m_winCapture = consumer->GetInputWindow();

             m_winCapture->CaptureMouse();
             m_winCapture->CaptureMouse();

-            m_winHasMouse = TRUE;
+            m_winHasMouse = true;

 
 

-            control->PerformAction(wxACTION_BUTTON_PRESS);
+            consumer->PerformAction(wxACTION_BUTTON_PRESS);

 
 

-            return TRUE;
+            return true;

         }
         }

-        else // up
+        else if ( event.LeftUp() )

         {
             if ( m_winCapture )
             {
         {
             if ( m_winCapture )
             {


@@ -300,19 +397,20 @@ bool wxStdButtonInputHandler::HandleMouse(wxControl *control,
             if ( m_winHasMouse )
             {
                 // this will generate a click event
             if ( m_winHasMouse )
             {
                 // this will generate a click event

-                control->PerformAction(wxACTION_BUTTON_TOGGLE);
+                consumer->PerformAction(wxACTION_BUTTON_TOGGLE);

 
 

-                return TRUE;
+                return true;

             }
             //else: the mouse was released outside the window, this doesn't
             //      count as a click
         }
             }
             //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(control, event);
+    return wxStdInputHandler::HandleMouse(consumer, event);

 }
 
 }
 

-bool wxStdButtonInputHandler::HandleMouseMove(wxControl *control,
+bool wxStdButtonInputHandler::HandleMouseMove(wxInputConsumer *consumer,

                                               const wxMouseEvent& event)
 {
     // we only have to do something when the mouse leaves/enters the pressed
                                               const wxMouseEvent& event)
 {
     // we only have to do something when the mouse leaves/enters the pressed


@@ -323,47 +421,47 @@ bool wxStdButtonInputHandler::HandleMouseMove(wxControl *control,
         if ( event.Leaving() )
         {
             // remember that the mouse is now outside
         if ( event.Leaving() )
         {
             // remember that the mouse is now outside

-            m_winHasMouse = FALSE;
+            m_winHasMouse = false;

 
             // we do have a pressed button, so release it
 
             // we do have a pressed button, so release it

-            control->SetCurrent(FALSE);
-            control->PerformAction(wxACTION_BUTTON_RELEASE);
+            consumer->GetInputWindow()->SetCurrent(false);
+            consumer->PerformAction(wxACTION_BUTTON_RELEASE);

 
 

-            return TRUE;
+            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
         }
         // 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;
+            m_winHasMouse = true;

 
             // we did have a pressed button which we released when leaving the
             // window, press it again
 
             // we did have a pressed button which we released when leaving the
             // window, press it again

-            control->SetCurrent(TRUE);
-            control->PerformAction(wxACTION_BUTTON_PRESS);
+            consumer->GetInputWindow()->SetCurrent(true);
+            consumer->PerformAction(wxACTION_BUTTON_PRESS);

 
 

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 

-    return wxStdInputHandler::HandleMouseMove(control, event);
+    return wxStdInputHandler::HandleMouseMove(consumer, event);

 }
 
 }
 

-bool wxStdButtonInputHandler::HandleFocus(wxControl *control,
-                                          const wxFocusEvent& event)
+bool wxStdButtonInputHandler::HandleFocus(wxInputConsumer * WXUNUSED(consumer),
+                                          const wxFocusEvent& WXUNUSED(event))

 {
 {

-    // buttons change appearance when they get/lose focus, so return TRUE to
+    // buttons change appearance when they get/lose focus, so return true to

     // refresh
     // refresh

-    return TRUE;
+    return true;

 }
 
 }
 

-bool wxStdButtonInputHandler::HandleActivation(wxControl *control,
-                                               bool activated)
+bool wxStdButtonInputHandler::HandleActivation(wxInputConsumer *consumer,
+                                               bool WXUNUSED(activated))

 {
     // the default button changes appearance when the app is [de]activated, so
 {
     // the default button changes appearance when the app is [de]activated, so

-    // return TRUE to refresh
-    return wxStaticCast(control, wxButton)->IsDefault();
+    // return true to refresh
+    return wxStaticCast(consumer->GetInputWindow(), wxButton)->IsDefault();

 }
 
 #endif // wxUSE_BUTTON
 }
 
 #endif // wxUSE_BUTTON