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

derive univ toggle button from button

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@39320 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Paul Cornett
2006-05-24 17:17:27 +00:00
parent d48d1eaeda
commit bd88c1fa96
3 changed files with 40 additions and 473 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/wx/univ/button.h
View File

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

113
include/wx/univ/tglbtn.h
View File

@@ -12,27 +12,19 @@
#ifndef _WX_UNIV_TGLBTN_H_ #ifndef _WX_UNIV_TGLBTN_H_
#define _WX_UNIV_TGLBTN_H_ #define _WX_UNIV_TGLBTN_H_
#include "wx/bitmap.h" #include "wx/button.h"
extern WXDLLEXPORT_DATA(const wxChar) wxCheckBoxNameStr[]; 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 // wxToggleButton: a push button
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxToggleButton: public wxControl class WXDLLIMPEXP_CORE wxToggleButton: public wxButton
{ {
public: public:
wxToggleButton() { Init(); } wxToggleButton();
wxToggleButton(wxWindow *parent, wxToggleButton(wxWindow *parent,
wxWindowID id, wxWindowID id,
const wxBitmap& bitmap, const wxBitmap& bitmap,
@@ -41,13 +33,8 @@ public:
const wxSize& size = wxDefaultSize, const wxSize& size = wxDefaultSize,
long style = 0, long style = 0,
const wxValidator& validator = wxDefaultValidator, const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr) const wxString& name = wxCheckBoxNameStr);
{
Init();
Create(parent, id, bitmap, label, pos, size, style, validator, name);
}
wxToggleButton(wxWindow *parent, wxToggleButton(wxWindow *parent,
wxWindowID id, wxWindowID id,
const wxString& label = wxEmptyString, const wxString& label = wxEmptyString,
@@ -55,109 +42,29 @@ public:
const wxSize& size = wxDefaultSize, const wxSize& size = wxDefaultSize,
long style = 0, long style = 0,
const wxValidator& validator = wxDefaultValidator, const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr) 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,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
virtual ~wxToggleButton(); virtual ~wxToggleButton();
virtual void SetImageLabel(const wxBitmap& bitmap);
virtual void SetImageMargins(wxCoord x, wxCoord y);
virtual bool IsPressed() const { return m_isPressed || m_value; } virtual bool IsPressed() const { return m_isPressed || m_value; }
// wxToggleButton actions // wxToggleButton actions
void Toggle(); virtual void Toggle();
virtual void Press();
virtual void Release();
virtual void Click(); virtual void Click();
// Get/set the value // Get/set the value
void SetValue(bool state); void SetValue(bool state);
bool GetValue() const { return m_value; } 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: 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 // the current value
bool m_value; bool m_value;
// the (optional) image to show and the margins around it
wxBitmap m_bitmap;
wxCoord m_marginBmpX,
m_marginBmpY;
private: private:
// common part of all ctors
void Init();
DECLARE_DYNAMIC_CLASS(wxToggleButton) 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_ #endif // _WX_UNIV_TGLBTN_H_

398
src/univ/tglbtn.cpp
View File

@@ -9,14 +9,6 @@
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
@@ -27,215 +19,50 @@
#include "wx/tglbtn.h" #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) 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, wxWindowID id,
const wxBitmap& bitmap, const wxBitmap& bitmap,
const wxString &lbl, const wxString& label,
const wxPoint &pos, const wxPoint& pos,
const wxSize &size, const wxSize& size,
long style, long style,
const wxValidator& validator, 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() wxToggleButton::~wxToggleButton()
{ {
} }
// ---------------------------------------------------------------------------- void wxToggleButton::Init()
// size management
// ----------------------------------------------------------------------------
/* static */
wxSize wxToggleButton::GetDefaultSize()
{ {
static wxSize s_sizeBtn; m_isPressed = false;
m_value = false;
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;
Refresh();
}
} }
void wxToggleButton::Toggle() void wxToggleButton::Toggle()
@@ -262,177 +89,10 @@ void wxToggleButton::Click()
Command(event); 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) void wxToggleButton::SetValue(bool state)
{ {
m_value = state; m_value = state;
Refresh(); 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 #endif // wxUSE_TOGGLEBTN