src/msw/checkbox.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/msw/checkbox.cpp
// Purpose:     wxCheckBox
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_CHECKBOX

#include "wx/checkbox.h"

#ifndef WX_PRECOMP
    #include "wx/brush.h"
    #include "wx/dcscreen.h"
    #include "wx/settings.h"
#endif

#include "wx/msw/uxtheme.h"
#include "wx/msw/private.h"

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

#ifndef BST_UNCHECKED
    #define BST_UNCHECKED 0x0000
#endif

#ifndef BST_CHECKED
    #define BST_CHECKED 0x0001
#endif

#ifndef BST_INDETERMINATE
    #define BST_INDETERMINATE 0x0002
#endif

#ifndef DFCS_HOT
    #define DFCS_HOT 0x1000
#endif

#ifndef DT_HIDEPREFIX
    #define DT_HIDEPREFIX 0x00100000
#endif

#ifndef BP_CHECKBOX
    #define BP_CHECKBOX 3
#endif

// these values are defined in tmschema.h (except the first one)
enum
{
    CBS_INVALID,
    CBS_UNCHECKEDNORMAL,
    CBS_UNCHECKEDHOT,
    CBS_UNCHECKEDPRESSED,
    CBS_UNCHECKEDDISABLED,
    CBS_CHECKEDNORMAL,
    CBS_CHECKEDHOT,
    CBS_CHECKEDPRESSED,
    CBS_CHECKEDDISABLED,
    CBS_MIXEDNORMAL,
    CBS_MIXEDHOT,
    CBS_MIXEDPRESSED,
    CBS_MIXEDDISABLED
};

// these are our own
enum
{
    CBS_HOT_OFFSET = 1,
    CBS_PRESSED_OFFSET = 2,
    CBS_DISABLED_OFFSET = 3
};

// ============================================================================
// implementation
// ============================================================================

#if wxUSE_EXTENDED_RTTI
WX_DEFINE_FLAGS( wxCheckBoxStyle )

wxBEGIN_FLAGS( wxCheckBoxStyle )
    // new style border flags, we put them first to
    // use them for streaming out
    wxFLAGS_MEMBER(wxBORDER_SIMPLE)
    wxFLAGS_MEMBER(wxBORDER_SUNKEN)
    wxFLAGS_MEMBER(wxBORDER_DOUBLE)
    wxFLAGS_MEMBER(wxBORDER_RAISED)
    wxFLAGS_MEMBER(wxBORDER_STATIC)
    wxFLAGS_MEMBER(wxBORDER_NONE)

    // old style border flags
    wxFLAGS_MEMBER(wxSIMPLE_BORDER)
    wxFLAGS_MEMBER(wxSUNKEN_BORDER)
    wxFLAGS_MEMBER(wxDOUBLE_BORDER)
    wxFLAGS_MEMBER(wxRAISED_BORDER)
    wxFLAGS_MEMBER(wxSTATIC_BORDER)
    wxFLAGS_MEMBER(wxNO_BORDER)

    // standard window styles
    wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
    wxFLAGS_MEMBER(wxCLIP_CHILDREN)
    wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
    wxFLAGS_MEMBER(wxWANTS_CHARS)
    wxFLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE)
    wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
    wxFLAGS_MEMBER(wxVSCROLL)
    wxFLAGS_MEMBER(wxHSCROLL)

wxEND_FLAGS( wxCheckBoxStyle )

IMPLEMENT_DYNAMIC_CLASS_XTI(wxCheckBox, wxControl,"wx/checkbox.h")

wxBEGIN_PROPERTIES_TABLE(wxCheckBox)
    wxEVENT_PROPERTY( Click , wxEVT_COMMAND_CHECKBOX_CLICKED , wxCommandEvent )

    wxPROPERTY( Font , wxFont , SetFont , GetFont , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
    wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
    wxPROPERTY( Value ,bool, SetValue, GetValue, EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
    wxPROPERTY_FLAGS( WindowStyle , wxCheckBoxStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
wxEND_PROPERTIES_TABLE()

wxBEGIN_HANDLERS_TABLE(wxCheckBox)
wxEND_HANDLERS_TABLE()

wxCONSTRUCTOR_6( wxCheckBox , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle )
#else
IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
#endif


// ----------------------------------------------------------------------------
// wxCheckBox creation
// ----------------------------------------------------------------------------

void wxCheckBox::Init()
{
    m_state = wxCHK_UNCHECKED;
    m_isPressed =
    m_isHot = false;
}

bool wxCheckBox::Create(wxWindow *parent,
                        wxWindowID id,
                        const wxString& label,
                        const wxPoint& pos,
                        const wxSize& size, long style,
                        const wxValidator& validator,
                        const wxString& name)
{
    Init();

    if ( !CreateControl(parent, id, pos, size, style, validator, name) )
        return false;

    long msStyle = WS_TABSTOP;

    if ( style & wxCHK_3STATE )
    {
        msStyle |= BS_3STATE;
    }
    else
    {
        wxASSERT_MSG( !Is3rdStateAllowedForUser(),
            wxT("Using wxCH_ALLOW_3RD_STATE_FOR_USER")
            wxT(" style flag for a 2-state checkbox is useless") );
        msStyle |= BS_CHECKBOX;
    }

    if ( style & wxALIGN_RIGHT )
    {
        msStyle |= BS_LEFTTEXT | BS_RIGHT;
    }

    return MSWCreateControl(wxT("BUTTON"), msStyle, pos, size, label, 0);
}

// ----------------------------------------------------------------------------
// wxCheckBox geometry
// ----------------------------------------------------------------------------

wxSize wxCheckBox::DoGetBestSize() const
{
    static int s_checkSize = 0;

    if ( !s_checkSize )
    {
        wxScreenDC dc;
        dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));

        s_checkSize = dc.GetCharHeight();
    }

    wxString str = wxGetWindowText(GetHWND());

    int wCheckbox, hCheckbox;
    if ( !str.empty() )
    {
        GetTextExtent(wxStripMenuCodes(str), &wCheckbox, &hCheckbox);
        wCheckbox += s_checkSize + GetCharWidth();

        if ( hCheckbox < s_checkSize )
            hCheckbox = s_checkSize;
    }
    else
    {
        wCheckbox = s_checkSize;
        hCheckbox = s_checkSize;
    }
#ifdef __WXWINCE__
    hCheckbox += 1;
#endif

    wxSize best(wCheckbox, hCheckbox);
    CacheBestSize(best);
    return best;
}

// ----------------------------------------------------------------------------
// wxCheckBox operations
// ----------------------------------------------------------------------------

void wxCheckBox::SetValue(bool val)
{
    Set3StateValue(val ? wxCHK_CHECKED : wxCHK_UNCHECKED);
}

bool wxCheckBox::GetValue() const
{
    return Get3StateValue() != wxCHK_UNCHECKED;
}

void wxCheckBox::Command(wxCommandEvent& event)
{
    int state = event.GetInt();
    wxCHECK_RET( (state == wxCHK_UNCHECKED) || (state == wxCHK_CHECKED)
        || (state == wxCHK_UNDETERMINED),
        wxT("event.GetInt() returned an invalid checkbox state") );

    Set3StateValue((wxCheckBoxState) state);
    ProcessCommand(event);
}

wxCOMPILE_TIME_ASSERT(wxCHK_UNCHECKED == BST_UNCHECKED
    && wxCHK_CHECKED == BST_CHECKED
    && wxCHK_UNDETERMINED == BST_INDETERMINATE, EnumValuesIncorrect);

void wxCheckBox::DoSet3StateValue(wxCheckBoxState state)
{
    m_state = state;
    if ( !IsOwnerDrawn() )
        ::SendMessage(GetHwnd(), BM_SETCHECK, (WPARAM) state, 0);
    else // owner drawn buttons don't react to this message
        Refresh();
}

wxCheckBoxState wxCheckBox::DoGet3StateValue() const
{
    return m_state;
}

bool wxCheckBox::MSWCommand(WXUINT cmd, WXWORD WXUNUSED(id))
{
    if ( cmd != BN_CLICKED && cmd != BN_DBLCLK )
        return false;

    // first update the value so that user event handler gets the new checkbox
    // value

    // ownerdrawn buttons don't manage their state themselves unlike usual
    // auto checkboxes so do it ourselves in any case
    wxCheckBoxState state;
    if ( Is3rdStateAllowedForUser() )
    {
        state = (wxCheckBoxState)((m_state + 1) % 3);
    }
    else // 2 state checkbox (at least from users point of view)
    {
        // note that wxCHK_UNDETERMINED also becomes unchecked when clicked
        state = m_state == wxCHK_UNCHECKED ? wxCHK_CHECKED : wxCHK_UNCHECKED;
    }

    DoSet3StateValue(state);


    // generate the event
    wxCommandEvent event(wxEVT_COMMAND_CHECKBOX_CLICKED, m_windowId);

    event.SetInt(state);
    event.SetEventObject(this);
    ProcessCommand(event);

    return true;
}

// ----------------------------------------------------------------------------
// owner drawn checkboxes stuff
// ----------------------------------------------------------------------------

bool wxCheckBox::SetForegroundColour(const wxColour& colour)
{
    if ( !wxCheckBoxBase::SetForegroundColour(colour) )
        return false;

    // the only way to change the checkbox foreground colour under Windows XP
    // is to owner draw it
    if ( wxUxThemeEngine::GetIfActive() )
        MakeOwnerDrawn(colour.Ok());

    return true;
}

bool wxCheckBox::IsOwnerDrawn() const
{
    return
        (::GetWindowLong(GetHwnd(), GWL_STYLE) & BS_OWNERDRAW) == BS_OWNERDRAW;
}

void wxCheckBox::MakeOwnerDrawn(bool ownerDrawn)
{
    long style = ::GetWindowLong(GetHwnd(), GWL_STYLE);

    // note that BS_CHECKBOX & BS_OWNERDRAW != 0 so we can't operate on
    // them as on independent style bits
    if ( ownerDrawn )
    {
        style &= ~(BS_CHECKBOX | BS_3STATE);
        style |= BS_OWNERDRAW;

        Connect(wxEVT_ENTER_WINDOW,
                wxMouseEventHandler(wxCheckBox::OnMouseEnterOrLeave));
        Connect(wxEVT_LEAVE_WINDOW,
                wxMouseEventHandler(wxCheckBox::OnMouseEnterOrLeave));
        Connect(wxEVT_LEFT_DOWN, wxMouseEventHandler(wxCheckBox::OnMouseLeft));
        Connect(wxEVT_LEFT_UP, wxMouseEventHandler(wxCheckBox::OnMouseLeft));
        Connect(wxEVT_SET_FOCUS, wxFocusEventHandler(wxCheckBox::OnFocus));
        Connect(wxEVT_KILL_FOCUS, wxFocusEventHandler(wxCheckBox::OnFocus));
    }
    else // reset to default colour
    {
        style &= ~BS_OWNERDRAW;
        style |= HasFlag(wxCHK_3STATE) ? BS_3STATE : BS_CHECKBOX;

        Disconnect(wxEVT_ENTER_WINDOW,
                   wxMouseEventHandler(wxCheckBox::OnMouseEnterOrLeave));
        Disconnect(wxEVT_LEAVE_WINDOW,
                   wxMouseEventHandler(wxCheckBox::OnMouseEnterOrLeave));
        Disconnect(wxEVT_LEFT_DOWN, wxMouseEventHandler(wxCheckBox::OnMouseLeft));
        Disconnect(wxEVT_LEFT_UP, wxMouseEventHandler(wxCheckBox::OnMouseLeft));
        Disconnect(wxEVT_SET_FOCUS, wxFocusEventHandler(wxCheckBox::OnFocus));
        Disconnect(wxEVT_KILL_FOCUS, wxFocusEventHandler(wxCheckBox::OnFocus));
    }

    ::SetWindowLong(GetHwnd(), GWL_STYLE, style);

    if ( !ownerDrawn )
    {
        // ensure that controls state is consistent with internal state
        DoSet3StateValue(m_state);
    }
}

void wxCheckBox::OnMouseEnterOrLeave(wxMouseEvent& event)
{
    m_isHot = event.GetEventType() == wxEVT_ENTER_WINDOW;
    if ( !m_isHot )
        m_isPressed = false;

    Refresh();

    event.Skip();
}

void wxCheckBox::OnMouseLeft(wxMouseEvent& event)
{
    // TODO: we should capture the mouse here to be notified about left up
    //       event but this interferes with BN_CLICKED generation so if we
    //       want to do this we'd need to generate them ourselves
    m_isPressed = event.GetEventType() == wxEVT_LEFT_DOWN;
    Refresh();

    event.Skip();
}

void wxCheckBox::OnFocus(wxFocusEvent& event)
{
    Refresh();

    event.Skip();
}

bool wxCheckBox::MSWOnDraw(WXDRAWITEMSTRUCT *item)
{
    DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)item;

    if ( !IsOwnerDrawn() || dis->CtlType != ODT_BUTTON )
        return wxCheckBoxBase::MSWOnDraw(item);

    // calculate the rectangles for the check mark itself and the label
    HDC hdc = dis->hDC;
    RECT& rect = dis->rcItem;
    RECT rectCheck,
         rectLabel;
    rectCheck.top =
    rectLabel.top = rect.top;
    rectCheck.bottom =
    rectLabel.bottom = rect.bottom;
    const int checkSize = GetBestSize().y;
    const int MARGIN = 3;

    const bool isRightAligned = HasFlag(wxALIGN_RIGHT);
    if ( isRightAligned )
    {
        rectCheck.right = rect.right;
        rectCheck.left = rectCheck.right - checkSize;

        rectLabel.right = rectCheck.left - MARGIN;
        rectLabel.left = rect.left;
    }
    else // normal, left-aligned checkbox
    {
        rectCheck.left = rect.left;
        rectCheck.right = rectCheck.left + checkSize;

        rectLabel.left = rectCheck.right + MARGIN;
        rectLabel.right = rect.right;
    }

    // show we draw a focus rect?
    const bool isFocused = m_isPressed || FindFocus() == this;


    // draw the checkbox itself: note that this should really, really be in
    // wxRendererNative but unfortunately we can't add a new virtual function
    // to it without breaking backwards compatibility

    // classic Win32 version -- this can be useful when we move this into
    // wxRendererNative
#if defined(__WXWINCE__) || !wxUSE_UXTHEME
    UINT state = DFCS_BUTTONCHECK;
    if ( !IsEnabled() )
        state |= DFCS_INACTIVE;
    switch ( Get3StateValue() )
    {
        case wxCHK_CHECKED:
            state |= DFCS_CHECKED;
            break;

        case wxCHK_UNDETERMINED:
            state |= DFCS_PUSHED;
            break;

        default:
            wxFAIL_MSG( _T("unexpected Get3StateValue() return value") );
            // fall through

        case wxCHK_UNCHECKED:
            // no extra styles needed
            break;
    }

    if ( wxFindWindowAtPoint(wxGetMousePosition()) == this )
        state |= DFCS_HOT;

    if ( !::DrawFrameControl(hdc, &rectCheck, DFC_BUTTON, state) )
    {
        wxLogLastError(_T("DrawFrameControl(DFC_BUTTON)"));
    }
#else // XP version
    wxUxThemeEngine *themeEngine = wxUxThemeEngine::GetIfActive();
    if ( !themeEngine )
        return false;

    wxUxThemeHandle theme(this, L"BUTTON");
    if ( !theme )
        return false;

    int state;
    switch ( Get3StateValue() )
    {
        case wxCHK_CHECKED:
            state = CBS_CHECKEDNORMAL;
            break;

        case wxCHK_UNDETERMINED:
            state = CBS_MIXEDNORMAL;
            break;

        default:
            wxFAIL_MSG( _T("unexpected Get3StateValue() return value") );
            // fall through

        case wxCHK_UNCHECKED:
            state = CBS_UNCHECKEDNORMAL;
            break;
    }

    if ( !IsEnabled() )
        state += CBS_DISABLED_OFFSET;
    else if ( m_isPressed )
        state += CBS_PRESSED_OFFSET;
    else if ( m_isHot )
        state += CBS_HOT_OFFSET;

    HRESULT hr = themeEngine->DrawThemeBackground
                              (
                                theme,
                                hdc,
                                BP_CHECKBOX,
                                state,
                                &rectCheck,
                                NULL
                              );
    if ( FAILED(hr) )
    {
        wxLogApiError(_T("DrawThemeBackground(BP_CHECKBOX)"), hr);
    }
#endif // 0/1

    // draw the text
    const wxString& label = GetLabel();

    // first we need to measure it
    UINT fmt = DT_NOCLIP;

    // drawing underlying doesn't look well with focus rect (and the native
    // control doesn't do it)
    if ( isFocused )
        fmt |= DT_HIDEPREFIX;
    if ( isRightAligned )
        fmt |= DT_RIGHT;
    // TODO: also use DT_HIDEPREFIX if the system is configured so

    // we need to get the label real size first if we have to draw a focus rect
    // around it
    if ( isFocused )
    {
        if ( !::DrawText(hdc, label, label.length(), &rectLabel,
                         fmt | DT_CALCRECT) )
        {
            wxLogLastError(_T("DrawText(DT_CALCRECT)"));
        }
    }

    if ( !IsEnabled() )
    {
        ::SetTextColor(hdc, ::GetSysColor(COLOR_GRAYTEXT));
    }

    if ( !::DrawText(hdc, label, label.length(), &rectLabel, fmt) )
    {
        wxLogLastError(_T("DrawText()"));
    }

    // finally draw the focus
    if ( isFocused )
    {
        rectLabel.left--;
        rectLabel.right++;
        if ( !::DrawFocusRect(hdc, &rectLabel) )
        {
            wxLogLastError(_T("DrawFocusRect()"));
        }
    }

    return true;
}

#endif // wxUSE_CHECKBOX
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/msw/checkbox.cpp
	3	// Purpose: wxCheckBox
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	#if wxUSE_CHECKBOX
	28
	29	#include "wx/checkbox.h"
	30
	31	#ifndef WX_PRECOMP
	32	#include "wx/brush.h"
	33	#include "wx/dcscreen.h"
	34	#include "wx/settings.h"
	35	#endif
	36
	37	#include "wx/msw/uxtheme.h"
	38	#include "wx/msw/private.h"
	39
	40	// ----------------------------------------------------------------------------
	41	// constants
	42	// ----------------------------------------------------------------------------
	43
	44	#ifndef BST_UNCHECKED
	45	#define BST_UNCHECKED 0x0000
	46	#endif
	47
	48	#ifndef BST_CHECKED
	49	#define BST_CHECKED 0x0001
	50	#endif
	51
	52	#ifndef BST_INDETERMINATE
	53	#define BST_INDETERMINATE 0x0002
	54	#endif
	55
	56	#ifndef DFCS_HOT
	57	#define DFCS_HOT 0x1000
	58	#endif
	59
	60	#ifndef DT_HIDEPREFIX
	61	#define DT_HIDEPREFIX 0x00100000
	62	#endif
	63
	64	#ifndef BP_CHECKBOX
	65	#define BP_CHECKBOX 3
	66	#endif
	67
	68	// these values are defined in tmschema.h (except the first one)
	69	enum
	70	{
	71	CBS_INVALID,
	72	CBS_UNCHECKEDNORMAL,
	73	CBS_UNCHECKEDHOT,
	74	CBS_UNCHECKEDPRESSED,
	75	CBS_UNCHECKEDDISABLED,
	76	CBS_CHECKEDNORMAL,
	77	CBS_CHECKEDHOT,
	78	CBS_CHECKEDPRESSED,
	79	CBS_CHECKEDDISABLED,
	80	CBS_MIXEDNORMAL,
	81	CBS_MIXEDHOT,
	82	CBS_MIXEDPRESSED,
	83	CBS_MIXEDDISABLED
	84	};
	85
	86	// these are our own
	87	enum
	88	{
	89	CBS_HOT_OFFSET = 1,
	90	CBS_PRESSED_OFFSET = 2,
	91	CBS_DISABLED_OFFSET = 3
	92	};
	93
	94	// ============================================================================
	95	// implementation
	96	// ============================================================================
	97
	98	#if wxUSE_EXTENDED_RTTI
	99	WX_DEFINE_FLAGS( wxCheckBoxStyle )
	100
	101	wxBEGIN_FLAGS( wxCheckBoxStyle )
	102	// new style border flags, we put them first to
	103	// use them for streaming out
	104	wxFLAGS_MEMBER(wxBORDER_SIMPLE)
	105	wxFLAGS_MEMBER(wxBORDER_SUNKEN)
	106	wxFLAGS_MEMBER(wxBORDER_DOUBLE)
	107	wxFLAGS_MEMBER(wxBORDER_RAISED)
	108	wxFLAGS_MEMBER(wxBORDER_STATIC)
	109	wxFLAGS_MEMBER(wxBORDER_NONE)
	110
	111	// old style border flags
	112	wxFLAGS_MEMBER(wxSIMPLE_BORDER)
	113	wxFLAGS_MEMBER(wxSUNKEN_BORDER)
	114	wxFLAGS_MEMBER(wxDOUBLE_BORDER)
	115	wxFLAGS_MEMBER(wxRAISED_BORDER)
	116	wxFLAGS_MEMBER(wxSTATIC_BORDER)
	117	wxFLAGS_MEMBER(wxNO_BORDER)
	118
	119	// standard window styles
	120	wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
	121	wxFLAGS_MEMBER(wxCLIP_CHILDREN)
	122	wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
	123	wxFLAGS_MEMBER(wxWANTS_CHARS)
	124	wxFLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE)
	125	wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
	126	wxFLAGS_MEMBER(wxVSCROLL)
	127	wxFLAGS_MEMBER(wxHSCROLL)
	128
	129	wxEND_FLAGS( wxCheckBoxStyle )
	130
	131	IMPLEMENT_DYNAMIC_CLASS_XTI(wxCheckBox, wxControl,"wx/checkbox.h")
	132
	133	wxBEGIN_PROPERTIES_TABLE(wxCheckBox)
	134	wxEVENT_PROPERTY( Click , wxEVT_COMMAND_CHECKBOX_CLICKED , wxCommandEvent )
	135
	136	wxPROPERTY( Font , wxFont , SetFont , GetFont , EMPTY_MACROVALUE , 0 /flags/ , wxT("Helpstring") , wxT("group"))
	137	wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxString() , 0 /flags/ , wxT("Helpstring") , wxT("group"))
	138	wxPROPERTY( Value ,bool, SetValue, GetValue, EMPTY_MACROVALUE, 0 /flags/ , wxT("Helpstring") , wxT("group"))
	139	wxPROPERTY_FLAGS( WindowStyle , wxCheckBoxStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE, 0 /flags/ , wxT("Helpstring") , wxT("group")) // style
	140	wxEND_PROPERTIES_TABLE()
	141
	142	wxBEGIN_HANDLERS_TABLE(wxCheckBox)
	143	wxEND_HANDLERS_TABLE()
	144
	145	wxCONSTRUCTOR_6( wxCheckBox , wxWindow* , Parent , wxWindowID , Id , wxString , Label , wxPoint , Position , wxSize , Size , long , WindowStyle )
	146	#else
	147	IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
	148	#endif
	149
	150
	151	// ----------------------------------------------------------------------------
	152	// wxCheckBox creation
	153	// ----------------------------------------------------------------------------
	154
	155	void wxCheckBox::Init()
	156	{
	157	m_state = wxCHK_UNCHECKED;
	158	m_isPressed =
	159	m_isHot = false;
	160	}
	161
	162	bool wxCheckBox::Create(wxWindow *parent,
	163	wxWindowID id,
	164	const wxString& label,
	165	const wxPoint& pos,
	166	const wxSize& size, long style,
	167	const wxValidator& validator,
	168	const wxString& name)
	169	{
	170	Init();
	171
	172	if ( !CreateControl(parent, id, pos, size, style, validator, name) )
	173	return false;
	174
	175	long msStyle = WS_TABSTOP;
	176
	177	if ( style & wxCHK_3STATE )
	178	{
	179	msStyle \|= BS_3STATE;
	180	}
	181	else
	182	{
	183	wxASSERT_MSG( !Is3rdStateAllowedForUser(),
	184	wxT("Using wxCH_ALLOW_3RD_STATE_FOR_USER")
	185	wxT(" style flag for a 2-state checkbox is useless") );
	186	msStyle \|= BS_CHECKBOX;
	187	}
	188
	189	if ( style & wxALIGN_RIGHT )
	190	{
	191	msStyle \|= BS_LEFTTEXT \| BS_RIGHT;
	192	}
	193
	194	return MSWCreateControl(wxT("BUTTON"), msStyle, pos, size, label, 0);
	195	}
	196
	197	// ----------------------------------------------------------------------------
	198	// wxCheckBox geometry
	199	// ----------------------------------------------------------------------------
	200
	201	wxSize wxCheckBox::DoGetBestSize() const
	202	{
	203	static int s_checkSize = 0;
	204
	205	if ( !s_checkSize )
	206	{
	207	wxScreenDC dc;
	208	dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
	209
	210	s_checkSize = dc.GetCharHeight();
	211	}
	212
	213	wxString str = wxGetWindowText(GetHWND());
	214
	215	int wCheckbox, hCheckbox;
	216	if ( !str.empty() )
	217	{
	218	GetTextExtent(wxStripMenuCodes(str), &wCheckbox, &hCheckbox);
	219	wCheckbox += s_checkSize + GetCharWidth();
	220
	221	if ( hCheckbox < s_checkSize )
	222	hCheckbox = s_checkSize;
	223	}
	224	else
	225	{
	226	wCheckbox = s_checkSize;
	227	hCheckbox = s_checkSize;
	228	}
	229	#ifdef __WXWINCE__
	230	hCheckbox += 1;
	231	#endif
	232
	233	wxSize best(wCheckbox, hCheckbox);
	234	CacheBestSize(best);
	235	return best;
	236	}
	237
	238	// ----------------------------------------------------------------------------
	239	// wxCheckBox operations
	240	// ----------------------------------------------------------------------------
	241
	242	void wxCheckBox::SetValue(bool val)
	243	{
	244	Set3StateValue(val ? wxCHK_CHECKED : wxCHK_UNCHECKED);
	245	}
	246
	247	bool wxCheckBox::GetValue() const
	248	{
	249	return Get3StateValue() != wxCHK_UNCHECKED;
	250	}
	251
	252	void wxCheckBox::Command(wxCommandEvent& event)
	253	{
	254	int state = event.GetInt();
	255	wxCHECK_RET( (state == wxCHK_UNCHECKED) \|\| (state == wxCHK_CHECKED)
	256	\|\| (state == wxCHK_UNDETERMINED),
	257	wxT("event.GetInt() returned an invalid checkbox state") );
	258
	259	Set3StateValue((wxCheckBoxState) state);
	260	ProcessCommand(event);
	261	}
	262
	263	wxCOMPILE_TIME_ASSERT(wxCHK_UNCHECKED == BST_UNCHECKED
	264	&& wxCHK_CHECKED == BST_CHECKED
	265	&& wxCHK_UNDETERMINED == BST_INDETERMINATE, EnumValuesIncorrect);
	266
	267	void wxCheckBox::DoSet3StateValue(wxCheckBoxState state)
	268	{
	269	m_state = state;
	270	if ( !IsOwnerDrawn() )
	271	::SendMessage(GetHwnd(), BM_SETCHECK, (WPARAM) state, 0);
	272	else // owner drawn buttons don't react to this message
	273	Refresh();
	274	}
	275
	276	wxCheckBoxState wxCheckBox::DoGet3StateValue() const
	277	{
	278	return m_state;
	279	}
	280
	281	bool wxCheckBox::MSWCommand(WXUINT cmd, WXWORD WXUNUSED(id))
	282	{
	283	if ( cmd != BN_CLICKED && cmd != BN_DBLCLK )
	284	return false;
	285
	286	// first update the value so that user event handler gets the new checkbox
	287	// value
	288
	289	// ownerdrawn buttons don't manage their state themselves unlike usual
	290	// auto checkboxes so do it ourselves in any case
	291	wxCheckBoxState state;
	292	if ( Is3rdStateAllowedForUser() )
	293	{
	294	state = (wxCheckBoxState)((m_state + 1) % 3);
	295	}
	296	else // 2 state checkbox (at least from users point of view)
	297	{
	298	// note that wxCHK_UNDETERMINED also becomes unchecked when clicked
	299	state = m_state == wxCHK_UNCHECKED ? wxCHK_CHECKED : wxCHK_UNCHECKED;
	300	}
	301
	302	DoSet3StateValue(state);
	303
	304
	305	// generate the event
	306	wxCommandEvent event(wxEVT_COMMAND_CHECKBOX_CLICKED, m_windowId);
	307
	308	event.SetInt(state);
	309	event.SetEventObject(this);
	310	ProcessCommand(event);
	311
	312	return true;
	313	}
	314
	315	// ----------------------------------------------------------------------------
	316	// owner drawn checkboxes stuff
	317	// ----------------------------------------------------------------------------
	318
	319	bool wxCheckBox::SetForegroundColour(const wxColour& colour)
	320	{
	321	if ( !wxCheckBoxBase::SetForegroundColour(colour) )
	322	return false;
	323
	324	// the only way to change the checkbox foreground colour under Windows XP
	325	// is to owner draw it
	326	if ( wxUxThemeEngine::GetIfActive() )
	327	MakeOwnerDrawn(colour.Ok());
	328
	329	return true;
	330	}
	331
	332	bool wxCheckBox::IsOwnerDrawn() const
	333	{
	334	return
	335	(::GetWindowLong(GetHwnd(), GWL_STYLE) & BS_OWNERDRAW) == BS_OWNERDRAW;
	336	}
	337
	338	void wxCheckBox::MakeOwnerDrawn(bool ownerDrawn)
	339	{
	340	long style = ::GetWindowLong(GetHwnd(), GWL_STYLE);
	341
	342	// note that BS_CHECKBOX & BS_OWNERDRAW != 0 so we can't operate on
	343	// them as on independent style bits
	344	if ( ownerDrawn )
	345	{
	346	style &= ~(BS_CHECKBOX \| BS_3STATE);
	347	style \|= BS_OWNERDRAW;
	348
	349	Connect(wxEVT_ENTER_WINDOW,
	350	wxMouseEventHandler(wxCheckBox::OnMouseEnterOrLeave));
	351	Connect(wxEVT_LEAVE_WINDOW,
	352	wxMouseEventHandler(wxCheckBox::OnMouseEnterOrLeave));
	353	Connect(wxEVT_LEFT_DOWN, wxMouseEventHandler(wxCheckBox::OnMouseLeft));
	354	Connect(wxEVT_LEFT_UP, wxMouseEventHandler(wxCheckBox::OnMouseLeft));
	355	Connect(wxEVT_SET_FOCUS, wxFocusEventHandler(wxCheckBox::OnFocus));
	356	Connect(wxEVT_KILL_FOCUS, wxFocusEventHandler(wxCheckBox::OnFocus));
	357	}
	358	else // reset to default colour
	359	{
	360	style &= ~BS_OWNERDRAW;
	361	style \|= HasFlag(wxCHK_3STATE) ? BS_3STATE : BS_CHECKBOX;
	362
	363	Disconnect(wxEVT_ENTER_WINDOW,
	364	wxMouseEventHandler(wxCheckBox::OnMouseEnterOrLeave));
	365	Disconnect(wxEVT_LEAVE_WINDOW,
	366	wxMouseEventHandler(wxCheckBox::OnMouseEnterOrLeave));
	367	Disconnect(wxEVT_LEFT_DOWN, wxMouseEventHandler(wxCheckBox::OnMouseLeft));
	368	Disconnect(wxEVT_LEFT_UP, wxMouseEventHandler(wxCheckBox::OnMouseLeft));
	369	Disconnect(wxEVT_SET_FOCUS, wxFocusEventHandler(wxCheckBox::OnFocus));
	370	Disconnect(wxEVT_KILL_FOCUS, wxFocusEventHandler(wxCheckBox::OnFocus));
	371	}
	372
	373	::SetWindowLong(GetHwnd(), GWL_STYLE, style);
	374
	375	if ( !ownerDrawn )
	376	{
	377	// ensure that controls state is consistent with internal state
	378	DoSet3StateValue(m_state);
	379	}
	380	}
	381
	382	void wxCheckBox::OnMouseEnterOrLeave(wxMouseEvent& event)
	383	{
	384	m_isHot = event.GetEventType() == wxEVT_ENTER_WINDOW;
	385	if ( !m_isHot )
	386	m_isPressed = false;
	387
	388	Refresh();
	389
	390	event.Skip();
	391	}
	392
	393	void wxCheckBox::OnMouseLeft(wxMouseEvent& event)
	394	{
	395	// TODO: we should capture the mouse here to be notified about left up
	396	// event but this interferes with BN_CLICKED generation so if we
	397	// want to do this we'd need to generate them ourselves
	398	m_isPressed = event.GetEventType() == wxEVT_LEFT_DOWN;
	399	Refresh();
	400
	401	event.Skip();
	402	}
	403
	404	void wxCheckBox::OnFocus(wxFocusEvent& event)
	405	{
	406	Refresh();
	407
	408	event.Skip();
	409	}
	410
	411	bool wxCheckBox::MSWOnDraw(WXDRAWITEMSTRUCT *item)
	412	{
	413	DRAWITEMSTRUCT dis = (DRAWITEMSTRUCT )item;
	414
	415	if ( !IsOwnerDrawn() \|\| dis->CtlType != ODT_BUTTON )
	416	return wxCheckBoxBase::MSWOnDraw(item);
	417
	418	// calculate the rectangles for the check mark itself and the label
	419	HDC hdc = dis->hDC;
	420	RECT& rect = dis->rcItem;
	421	RECT rectCheck,
	422	rectLabel;
	423	rectCheck.top =
	424	rectLabel.top = rect.top;
	425	rectCheck.bottom =
	426	rectLabel.bottom = rect.bottom;
	427	const int checkSize = GetBestSize().y;
	428	const int MARGIN = 3;
	429
	430	const bool isRightAligned = HasFlag(wxALIGN_RIGHT);
	431	if ( isRightAligned )
	432	{
	433	rectCheck.right = rect.right;
	434	rectCheck.left = rectCheck.right - checkSize;
	435
	436	rectLabel.right = rectCheck.left - MARGIN;
	437	rectLabel.left = rect.left;
	438	}
	439	else // normal, left-aligned checkbox
	440	{
	441	rectCheck.left = rect.left;
	442	rectCheck.right = rectCheck.left + checkSize;
	443
	444	rectLabel.left = rectCheck.right + MARGIN;
	445	rectLabel.right = rect.right;
	446	}
	447
	448	// show we draw a focus rect?
	449	const bool isFocused = m_isPressed \|\| FindFocus() == this;
	450
	451
	452	// draw the checkbox itself: note that this should really, really be in
	453	// wxRendererNative but unfortunately we can't add a new virtual function
	454	// to it without breaking backwards compatibility
	455
	456	// classic Win32 version -- this can be useful when we move this into
	457	// wxRendererNative
	458	#if defined(__WXWINCE__) \|\| !wxUSE_UXTHEME
	459	UINT state = DFCS_BUTTONCHECK;
	460	if ( !IsEnabled() )
	461	state \|= DFCS_INACTIVE;
	462	switch ( Get3StateValue() )
	463	{
	464	case wxCHK_CHECKED:
	465	state \|= DFCS_CHECKED;
	466	break;
	467
	468	case wxCHK_UNDETERMINED:
	469	state \|= DFCS_PUSHED;
	470	break;
	471
	472	default:
	473	wxFAIL_MSG( _T("unexpected Get3StateValue() return value") );
	474	// fall through
	475
	476	case wxCHK_UNCHECKED:
	477	// no extra styles needed
	478	break;
	479	}
	480
	481	if ( wxFindWindowAtPoint(wxGetMousePosition()) == this )
	482	state \|= DFCS_HOT;
	483
	484	if ( !::DrawFrameControl(hdc, &rectCheck, DFC_BUTTON, state) )
	485	{
	486	wxLogLastError(_T("DrawFrameControl(DFC_BUTTON)"));
	487	}
	488	#else // XP version
	489	wxUxThemeEngine *themeEngine = wxUxThemeEngine::GetIfActive();
	490	if ( !themeEngine )
	491	return false;
	492
	493	wxUxThemeHandle theme(this, L"BUTTON");
	494	if ( !theme )
	495	return false;
	496
	497	int state;
	498	switch ( Get3StateValue() )
	499	{
	500	case wxCHK_CHECKED:
	501	state = CBS_CHECKEDNORMAL;
	502	break;
	503
	504	case wxCHK_UNDETERMINED:
	505	state = CBS_MIXEDNORMAL;
	506	break;
	507
	508	default:
	509	wxFAIL_MSG( _T("unexpected Get3StateValue() return value") );
	510	// fall through
	511
	512	case wxCHK_UNCHECKED:
	513	state = CBS_UNCHECKEDNORMAL;
	514	break;
	515	}
	516
	517	if ( !IsEnabled() )
	518	state += CBS_DISABLED_OFFSET;
	519	else if ( m_isPressed )
	520	state += CBS_PRESSED_OFFSET;
	521	else if ( m_isHot )
	522	state += CBS_HOT_OFFSET;
	523
	524	HRESULT hr = themeEngine->DrawThemeBackground
	525	(
	526	theme,
	527	hdc,
	528	BP_CHECKBOX,
	529	state,
	530	&rectCheck,
	531	NULL
	532	);
	533	if ( FAILED(hr) )
	534	{
	535	wxLogApiError(_T("DrawThemeBackground(BP_CHECKBOX)"), hr);
	536	}
	537	#endif // 0/1
	538
	539	// draw the text
	540	const wxString& label = GetLabel();
	541
	542	// first we need to measure it
	543	UINT fmt = DT_NOCLIP;
	544
	545	// drawing underlying doesn't look well with focus rect (and the native
	546	// control doesn't do it)
	547	if ( isFocused )
	548	fmt \|= DT_HIDEPREFIX;
	549	if ( isRightAligned )
	550	fmt \|= DT_RIGHT;
	551	// TODO: also use DT_HIDEPREFIX if the system is configured so
	552
	553	// we need to get the label real size first if we have to draw a focus rect
	554	// around it
	555	if ( isFocused )
	556	{
	557	if ( !::DrawText(hdc, label, label.length(), &rectLabel,
	558	fmt \| DT_CALCRECT) )
	559	{
	560	wxLogLastError(_T("DrawText(DT_CALCRECT)"));
	561	}
	562	}
	563
	564	if ( !IsEnabled() )
	565	{
	566	::SetTextColor(hdc, ::GetSysColor(COLOR_GRAYTEXT));
	567	}
	568
	569	if ( !::DrawText(hdc, label, label.length(), &rectLabel, fmt) )
	570	{
	571	wxLogLastError(_T("DrawText()"));
	572	}
	573
	574	// finally draw the focus
	575	if ( isFocused )
	576	{
	577	rectLabel.left--;
	578	rectLabel.right++;
	579	if ( !::DrawFocusRect(hdc, &rectLabel) )
	580	{
	581	wxLogLastError(_T("DrawFocusRect()"));
	582	}
	583	}
	584
	585	return true;
	586	}
	587
	588	#endif // wxUSE_CHECKBOX