Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor: create src/univ/anybutton.cpp.

Browse Source 
Extract and pull the common functions from wxButton and wxToggleButton to
wxAnyButton in wxUniv too.

Also make wxToggleButton inherit from wxToggleButtonBase correctly

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@77759 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2014-09-23 17:38:47 +00:00
parent 16601713a4
commit 43c99ef613
12 changed files with 497 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files

294
src/univ/button.cpp
View File

@@ -32,40 +32,6 @@
#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"
// ----------------------------------------------------------------------------
// 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
// ----------------------------------------------------------------------------
@@ -163,118 +129,11 @@ wxSize wxButtonBase::GetDefaultSize()
return s_sizeBtn;
}
wxSize wxButton::DoGetBestClientSize() const
{
wxClientDC dc(wxConstCast(this, wxButton));
wxCoord width, height;
dc.GetMultiLineTextExtent(GetLabel(), &width, &height);
if ( m_bitmap.IsOk() )
{
// 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 wxButton::DoDraw(wxControlRenderer *renderer)
{
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;
}
// ----------------------------------------------------------------------------
// input processing
// ----------------------------------------------------------------------------
void wxButton::Press()
{
if ( !m_isPressed )
{
m_isPressed = true;
Refresh();
}
}
void wxButton::Release()
{
if ( m_isPressed )
{
m_isPressed = false;
Refresh();
}
}
void wxButton::Toggle()
{
if ( m_isPressed )
Release();
else
Press();
if ( !m_isPressed )
{
// releasing button after it had been pressed generates a click event
Click();
}
}
void wxButton::Click()
{
wxCommandEvent event(wxEVT_BUTTON, GetId());
@@ -282,32 +141,6 @@ void wxButton::Click()
Command(event);
}
bool wxButton::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;
}
/* static */
wxInputHandler *wxButton::GetStdInputHandler(wxInputHandler *handlerDef)
{
static wxStdButtonInputHandler s_handlerBtn(handlerDef);
return &s_handlerBtn;
}
// ----------------------------------------------------------------------------
// misc
// ----------------------------------------------------------------------------
@@ -337,132 +170,5 @@ wxWindow *wxButton::SetDefault()
return wxButtonBase::SetDefault();
}
// ============================================================================
// wxStdButtonInputHandler
// ============================================================================
wxStdButtonInputHandler::wxStdButtonInputHandler(wxInputHandler *handler)
: wxStdInputHandler(handler)
{
m_winCapture = NULL;
m_winHasMouse = false;
}
bool wxStdButtonInputHandler::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 wxStdButtonInputHandler::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 wxStdButtonInputHandler::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 wxStdButtonInputHandler::HandleFocus(wxInputConsumer * WXUNUSED(consumer),
const wxFocusEvent& WXUNUSED(event))
{
// buttons change appearance when they get/lose focus, so return true to
// refresh
return true;
}
bool wxStdButtonInputHandler::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(), wxButton)->IsDefault();
}
#endif // wxUSE_BUTTON