src/msw/checkbox.cpp

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