src/msw/radiobox.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/radiobox.cpp
   3 // Purpose:     wxRadioBox implementation
   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_RADIOBOX
  28
  29 #include "wx/radiobox.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/bitmap.h"
  33     #include "wx/brush.h"
  34     #include "wx/settings.h"
  35     #include "wx/log.h"
  36 #endif
  37
  38 #include "wx/msw/subwin.h"
  39
  40 #if wxUSE_TOOLTIPS
  41     #include "wx/tooltip.h"
  42 #endif // wxUSE_TOOLTIPS
  43
  44 // TODO: wxCONSTRUCTOR
  45 #if 0 // wxUSE_EXTENDED_RTTI
  46 WX_DEFINE_FLAGS( wxRadioBoxStyle )
  47
  48 wxBEGIN_FLAGS( wxRadioBoxStyle )
  49     // new style border flags, we put them first to
  50     // use them for streaming out
  51     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  52     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  53     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  54     wxFLAGS_MEMBER(wxBORDER_RAISED)
  55     wxFLAGS_MEMBER(wxBORDER_STATIC)
  56     wxFLAGS_MEMBER(wxBORDER_NONE)
  57
  58     // old style border flags
  59     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  60     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  61     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  62     wxFLAGS_MEMBER(wxRAISED_BORDER)
  63     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  64     wxFLAGS_MEMBER(wxBORDER)
  65
  66     // standard window styles
  67     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  68     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  69     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
  70     wxFLAGS_MEMBER(wxWANTS_CHARS)
  71     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
  72     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
  73     wxFLAGS_MEMBER(wxVSCROLL)
  74     wxFLAGS_MEMBER(wxHSCROLL)
  75
  76     wxFLAGS_MEMBER(wxRA_SPECIFY_COLS)
  77     wxFLAGS_MEMBER(wxRA_HORIZONTAL)
  78     wxFLAGS_MEMBER(wxRA_SPECIFY_ROWS)
  79     wxFLAGS_MEMBER(wxRA_VERTICAL)
  80
  81 wxEND_FLAGS( wxRadioBoxStyle )
  82
  83 IMPLEMENT_DYNAMIC_CLASS_XTI(wxRadioBox, wxControl,"wx/radiobox.h")
  84
  85 wxBEGIN_PROPERTIES_TABLE(wxRadioBox)
  86     wxEVENT_PROPERTY( Select , wxEVT_COMMAND_RADIOBOX_SELECTED , wxCommandEvent )
  87     wxPROPERTY_FLAGS( WindowStyle , wxRadioBoxStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
  88 wxEND_PROPERTIES_TABLE()
  89
  90 #else
  91 IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
  92 #endif
  93
  94 /*
  95     selection
  96     content
  97         label
  98         dimension
  99         item
 100 */
 101
 102 // ---------------------------------------------------------------------------
 103 // private functions
 104 // ---------------------------------------------------------------------------
 105
 106 // wnd proc for radio buttons
 107 LRESULT APIENTRY _EXPORT wxRadioBtnWndProc(HWND hWnd,
 108                                            UINT message,
 109                                            WPARAM wParam,
 110                                            LPARAM lParam);
 111
 112 // ---------------------------------------------------------------------------
 113 // global vars
 114 // ---------------------------------------------------------------------------
 115
 116 // the pointer to standard radio button wnd proc
 117 static WXFARPROC s_wndprocRadioBtn = (WXFARPROC)NULL;
 118
 119 // ===========================================================================
 120 // implementation
 121 // ===========================================================================
 122
 123 // ---------------------------------------------------------------------------
 124 // wxRadioBox creation
 125 // ---------------------------------------------------------------------------
 126
 127 // Radio box item
 128 void wxRadioBox::Init()
 129 {
 130     m_selectedButton = wxNOT_FOUND;
 131     m_radioButtons = NULL;
 132     m_dummyHwnd = NULL;
 133     m_radioWidth = NULL;
 134     m_radioHeight = NULL;
 135 }
 136
 137 bool wxRadioBox::Create(wxWindow *parent,
 138                         wxWindowID id,
 139                         const wxString& title,
 140                         const wxPoint& pos,
 141                         const wxSize& size,
 142                         int n,
 143                         const wxString choices[],
 144                         int majorDim,
 145                         long style,
 146                         const wxValidator& val,
 147                         const wxString& name)
 148 {
 149     // common initialization
 150     if ( !wxStaticBox::Create(parent, id, title, pos, size, style, name) )
 151         return false;
 152
 153     // the code elsewhere in this file supposes that either wxRA_SPECIFY_COLS
 154     // or wxRA_SPECIFY_ROWS is set, ensure that this is indeed the case
 155     if ( !(style & (wxRA_SPECIFY_ROWS | wxRA_SPECIFY_COLS)) )
 156         style |= wxRA_SPECIFY_COLS;
 157
 158 #if wxUSE_VALIDATORS
 159     SetValidator(val);
 160 #else
 161     wxUnusedVar(val);
 162 #endif // wxUSE_VALIDATORS/!wxUSE_VALIDATORS
 163
 164     // We need an extra one to keep track of the 'dummy' item we
 165     // create to end the radio group, so it will be destroyed and
 166     // it's id will be released.  But we want it separate from the
 167     // other buttons since the wxSubwindows will operate on it as
 168     // well and we just want to ignore it until destroying it.
 169     // For instance, we don't want the bounding box of the radio
 170     // buttons to include the dummy button
 171     m_radioButtons = new wxSubwindows(n);
 172
 173     m_radioWidth = new int[n];
 174     m_radioHeight = new int[n];
 175
 176     for ( int i = 0; i < n; i++ )
 177     {
 178         m_radioWidth[i] =
 179         m_radioHeight[i] = wxDefaultCoord;
 180         long styleBtn = BS_AUTORADIOBUTTON | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
 181         if ( i == 0 )
 182             styleBtn |= WS_GROUP;
 183
 184         wxWindowIDRef subid = NewControlId();
 185
 186         HWND hwndBtn = ::CreateWindow(_T("BUTTON"),
 187                                       choices[i].wx_str(),
 188                                       styleBtn,
 189                                       0, 0, 0, 0,   // will be set in SetSize()
 190                                       GetHwndOf(parent),
 191                                       (HMENU)wxUIntToPtr(subid.GetValue()),
 192                                       wxGetInstance(),
 193                                       NULL);
 194
 195         if ( !hwndBtn )
 196         {
 197             wxLogLastError(wxT("CreateWindow(radio btn)"));
 198
 199             return false;
 200         }
 201
 202         // Keep track of the subwindow
 203         m_radioButtons->Set(i, hwndBtn, subid);
 204
 205         SubclassRadioButton((WXHWND)hwndBtn);
 206
 207         // Also, make it a subcontrol of this control
 208         m_subControls.Add(subid);
 209     }
 210
 211     // Create a dummy radio control to end the group.
 212     m_dummyId = NewControlId();
 213
 214     m_dummyHwnd = (WXHWND)::CreateWindow(_T("BUTTON"),
 215                          wxEmptyString,
 216                          WS_GROUP | BS_AUTORADIOBUTTON | WS_CHILD,
 217                          0, 0, 0, 0, GetHwndOf(parent),
 218                          (HMENU)wxUIntToPtr(m_dummyId.GetValue()),
 219                          wxGetInstance(), NULL);
 220
 221
 222     m_radioButtons->SetFont(GetFont());
 223
 224 #ifdef __WXWINCE__
 225     // Set the z-order correctly
 226     SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
 227 #endif
 228
 229     SetMajorDim(majorDim == 0 ? n : majorDim, style);
 230     SetSelection(0);
 231     SetSize(pos.x, pos.y, size.x, size.y);
 232
 233     // Now that we have items determine what is the best size and set it.
 234     SetInitialSize(size);
 235
 236     return true;
 237 }
 238
 239 bool wxRadioBox::Create(wxWindow *parent,
 240                         wxWindowID id,
 241                         const wxString& title,
 242                         const wxPoint& pos,
 243                         const wxSize& size,
 244                         const wxArrayString& choices,
 245                         int majorDim,
 246                         long style,
 247                         const wxValidator& val,
 248                         const wxString& name)
 249 {
 250     wxCArrayString chs(choices);
 251     return Create(parent, id, title, pos, size, chs.GetCount(),
 252                   chs.GetStrings(), majorDim, style, val, name);
 253 }
 254
 255 wxRadioBox::~wxRadioBox()
 256 {
 257     SendDestroyEvent();
 258
 259     delete m_radioButtons;
 260     if ( m_dummyHwnd )
 261         DestroyWindow((HWND)m_dummyHwnd);
 262     delete[] m_radioWidth;
 263     delete[] m_radioHeight;
 264 }
 265
 266 // NB: if this code is changed, wxGetWindowForHWND() which relies on having the
 267 //     radiobox pointer in GWL_USERDATA for radio buttons must be updated too!
 268 void wxRadioBox::SubclassRadioButton(WXHWND hWndBtn)
 269 {
 270     HWND hwndBtn = (HWND)hWndBtn;
 271
 272     if ( !s_wndprocRadioBtn )
 273         s_wndprocRadioBtn = (WXFARPROC)wxGetWindowProc(hwndBtn);
 274
 275     wxSetWindowProc(hwndBtn, wxRadioBtnWndProc);
 276     wxSetWindowUserData(hwndBtn, this);
 277 }
 278
 279 // ----------------------------------------------------------------------------
 280 // events generation
 281 // ----------------------------------------------------------------------------
 282
 283 bool wxRadioBox::MSWCommand(WXUINT cmd, WXWORD id_)
 284 {
 285     const int id = (signed short)id_;
 286
 287     if ( cmd == BN_CLICKED )
 288     {
 289         if (id == GetId())
 290             return true;
 291
 292         int selectedButton = wxNOT_FOUND;
 293
 294         const unsigned int count = GetCount();
 295         for ( unsigned int i = 0; i < count; i++ )
 296         {
 297             const HWND hwndBtn = (*m_radioButtons)[i];
 298             if ( id == wxGetWindowId(hwndBtn) )
 299             {
 300                 // we can get BN_CLICKED for a button which just became focused
 301                 // but it may not be checked, in which case we shouldn't
 302                 // generate a radiobox selection changed event for it
 303                 if ( ::SendMessage(hwndBtn, BM_GETCHECK, 0, 0) == BST_CHECKED )
 304                     selectedButton = i;
 305
 306                 break;
 307             }
 308         }
 309
 310         if ( selectedButton == wxNOT_FOUND )
 311         {
 312             // just ignore it - due to a hack with WM_NCHITTEST handling in our
 313             // wnd proc, we can receive dummy click messages when we click near
 314             // the radiobox edge (this is ugly but Julian wouldn't let me get
 315             // rid of this...)
 316             return false;
 317         }
 318
 319         if ( selectedButton != m_selectedButton )
 320         {
 321             m_selectedButton = selectedButton;
 322
 323             SendNotificationEvent();
 324         }
 325         //else: don't generate events when the selection doesn't change
 326
 327         return true;
 328     }
 329     else
 330         return false;
 331 }
 332
 333 void wxRadioBox::Command(wxCommandEvent & event)
 334 {
 335     SetSelection (event.GetInt());
 336     SetFocus();
 337     ProcessCommand(event);
 338 }
 339
 340 void wxRadioBox::SendNotificationEvent()
 341 {
 342     wxCommandEvent event(wxEVT_COMMAND_RADIOBOX_SELECTED, m_windowId);
 343     event.SetInt( m_selectedButton );
 344     event.SetString(GetString(m_selectedButton));
 345     event.SetEventObject( this );
 346     ProcessCommand(event);
 347 }
 348
 349 // ----------------------------------------------------------------------------
 350 // simple accessors
 351 // ----------------------------------------------------------------------------
 352
 353 unsigned int wxRadioBox::GetCount() const
 354 {
 355     return m_radioButtons ? m_radioButtons->GetCount() : 0u;
 356 }
 357
 358 void wxRadioBox::SetString(unsigned int item, const wxString& label)
 359 {
 360     wxCHECK_RET( IsValid(item), wxT("invalid radiobox index") );
 361
 362     m_radioWidth[item] =
 363     m_radioHeight[item] = wxDefaultCoord;
 364
 365     ::SetWindowText((*m_radioButtons)[item], label.c_str());
 366
 367     InvalidateBestSize();
 368 }
 369
 370 void wxRadioBox::SetSelection(int N)
 371 {
 372     wxCHECK_RET( IsValid(N), wxT("invalid radiobox index") );
 373
 374     // unselect the old button
 375     if ( m_selectedButton != wxNOT_FOUND )
 376         ::SendMessage((*m_radioButtons)[m_selectedButton], BM_SETCHECK, 0, 0L);
 377
 378     // and select the new one
 379     ::SendMessage((*m_radioButtons)[N], BM_SETCHECK, 1, 0L);
 380
 381     m_selectedButton = N;
 382 }
 383
 384 // Find string for position
 385 wxString wxRadioBox::GetString(unsigned int item) const
 386 {
 387     wxCHECK_MSG( IsValid(item), wxEmptyString,
 388                  wxT("invalid radiobox index") );
 389
 390     return wxGetWindowText((*m_radioButtons)[item]);
 391 }
 392
 393 void wxRadioBox::SetFocus()
 394 {
 395     if ( GetCount() > 0 )
 396     {
 397         ::SetFocus((*m_radioButtons)[m_selectedButton == wxNOT_FOUND
 398                                         ? 0
 399                                         : m_selectedButton]);
 400     }
 401 }
 402
 403 // Enable a specific button
 404 bool wxRadioBox::Enable(unsigned int item, bool enable)
 405 {
 406     wxCHECK_MSG( IsValid(item), false,
 407                  wxT("invalid item in wxRadioBox::Enable()") );
 408
 409     BOOL ret = ::EnableWindow((*m_radioButtons)[item], enable);
 410
 411     return (ret == 0) != enable;
 412 }
 413
 414 bool wxRadioBox::IsItemEnabled(unsigned int item) const
 415 {
 416     wxCHECK_MSG( IsValid(item), false,
 417                  wxT("invalid item in wxRadioBox::IsItemEnabled()") );
 418
 419     return ::IsWindowEnabled((*m_radioButtons)[item]) != 0;
 420 }
 421
 422 // Show a specific button
 423 bool wxRadioBox::Show(unsigned int item, bool show)
 424 {
 425     wxCHECK_MSG( IsValid(item), false,
 426                  wxT("invalid item in wxRadioBox::Show()") );
 427
 428     BOOL ret = ::ShowWindow((*m_radioButtons)[item], show ? SW_SHOW : SW_HIDE);
 429
 430     bool changed = (ret != 0) != show;
 431     if ( changed )
 432     {
 433         InvalidateBestSize();
 434     }
 435
 436     return changed;
 437 }
 438
 439 bool wxRadioBox::IsItemShown(unsigned int item) const
 440 {
 441     wxCHECK_MSG( IsValid(item), false,
 442                  wxT("invalid item in wxRadioBox::IsItemShown()") );
 443
 444     // don't use IsWindowVisible() here because it would return false if the
 445     // radiobox itself is hidden while we want to only return false if this
 446     // button specifically is hidden
 447     return (::GetWindowLong((*m_radioButtons)[item],
 448                             GWL_STYLE) & WS_VISIBLE) != 0;
 449 }
 450
 451 #if wxUSE_TOOLTIPS
 452
 453 bool wxRadioBox::HasToolTips() const
 454 {
 455     return wxStaticBox::HasToolTips() || wxRadioBoxBase::HasItemToolTips();
 456 }
 457
 458 void wxRadioBox::DoSetItemToolTip(unsigned int item, wxToolTip *tooltip)
 459 {
 460     // we have already checked for the item to be valid in wxRadioBoxBase
 461     const HWND hwndRbtn = (*m_radioButtons)[item];
 462     if ( tooltip != NULL )
 463         tooltip->Add(hwndRbtn);
 464     else // unset the tooltip
 465         wxToolTip::Remove(hwndRbtn);
 466 }
 467
 468 #endif // wxUSE_TOOLTIPS
 469
 470 bool wxRadioBox::Reparent(wxWindowBase *newParent)
 471 {
 472     if ( !wxStaticBox::Reparent(newParent) )
 473     {
 474         return false;
 475     }
 476
 477     HWND hwndParent = GetHwndOf(GetParent());
 478     for ( size_t item = 0; item < m_radioButtons->GetCount(); item++ )
 479     {
 480         ::SetParent((*m_radioButtons)[item], hwndParent);
 481     }
 482 #ifdef __WXWINCE__
 483     // put static box under the buttons in the Z-order
 484     SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
 485 #endif
 486     return true;
 487 }
 488
 489 WX_FORWARD_STD_METHODS_TO_SUBWINDOWS(wxRadioBox, wxStaticBox, m_radioButtons)
 490
 491 // ----------------------------------------------------------------------------
 492 // size calculations
 493 // ----------------------------------------------------------------------------
 494
 495 wxSize wxRadioBox::GetMaxButtonSize() const
 496 {
 497     // calculate the max button size
 498     int widthMax = 0,
 499         heightMax = 0;
 500     const unsigned int count = GetCount();
 501     for ( unsigned int i = 0 ; i < count; i++ )
 502     {
 503         int width, height;
 504         if ( m_radioWidth[i] < 0 )
 505         {
 506             GetTextExtent(wxGetWindowText((*m_radioButtons)[i]), &width, &height);
 507
 508             // adjust the size to take into account the radio box itself
 509             // FIXME this is totally bogus!
 510             width += RADIO_SIZE;
 511             height *= 3;
 512             height /= 2;
 513         }
 514         else
 515         {
 516             width = m_radioWidth[i];
 517             height = m_radioHeight[i];
 518         }
 519
 520         if ( widthMax < width )
 521             widthMax = width;
 522         if ( heightMax < height )
 523             heightMax = height;
 524     }
 525
 526     return wxSize(widthMax, heightMax);
 527 }
 528
 529 wxSize wxRadioBox::GetTotalButtonSize(const wxSize& sizeBtn) const
 530 {
 531     // the radiobox should be big enough for its buttons
 532     int cx1, cy1;
 533     wxGetCharSize(m_hWnd, &cx1, &cy1, GetFont());
 534
 535     int extraHeight = cy1;
 536
 537     int height = GetRowCount() * sizeBtn.y + cy1/2 + extraHeight;
 538     int width  = GetColumnCount() * (sizeBtn.x + cx1) + cx1;
 539
 540     // Add extra space under the label, if it exists.
 541     if (!wxControl::GetLabel().empty())
 542         height += cy1/2;
 543
 544     // and also wide enough for its label
 545     int widthLabel;
 546     GetTextExtent(GetLabelText(), &widthLabel, NULL);
 547     widthLabel += RADIO_SIZE; // FIXME this is bogus too
 548     if ( widthLabel > width )
 549         width = widthLabel;
 550
 551     return wxSize(width, height);
 552 }
 553
 554 wxSize wxRadioBox::DoGetBestSize() const
 555 {
 556     if ( !m_radioButtons )
 557     {
 558         // if we're not fully initialized yet, we can't meaningfully compute
 559         // our best size, we'll do it later
 560         return wxSize(1, 1);
 561     }
 562
 563     wxSize best = GetTotalButtonSize(GetMaxButtonSize());
 564     CacheBestSize(best);
 565     return best;
 566 }
 567
 568 // Restored old code.
 569 void wxRadioBox::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 570 {
 571     int currentX, currentY;
 572     GetPosition(&currentX, &currentY);
 573     int widthOld, heightOld;
 574     GetSize(&widthOld, &heightOld);
 575
 576     int xx = x;
 577     int yy = y;
 578
 579     if (x == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 580         xx = currentX;
 581     if (y == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 582         yy = currentY;
 583
 584     int y_offset = yy;
 585     int x_offset = xx;
 586
 587     int cx1, cy1;
 588     wxGetCharSize(m_hWnd, &cx1, &cy1, GetFont());
 589
 590     // Attempt to have a look coherent with other platforms: We compute the
 591     // biggest toggle dim, then we align all items according this value.
 592     wxSize maxSize = GetMaxButtonSize();
 593     int maxWidth = maxSize.x,
 594         maxHeight = maxSize.y;
 595
 596     wxSize totSize = GetTotalButtonSize(maxSize);
 597     int totWidth = totSize.x,
 598         totHeight = totSize.y;
 599
 600     // only change our width/height if asked for
 601     if ( width == wxDefaultCoord )
 602     {
 603         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
 604             width = totWidth;
 605         else
 606             width = widthOld;
 607     }
 608
 609     if ( height == wxDefaultCoord )
 610     {
 611         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
 612             height = totHeight;
 613         else
 614             height = heightOld;
 615     }
 616
 617     DoMoveWindow(xx, yy, width, height);
 618
 619     // Now position all the buttons: the current button will be put at
 620     // wxPoint(x_offset, y_offset) and the new row/column will start at
 621     // startX/startY. The size of all buttons will be the same wxSize(maxWidth,
 622     // maxHeight) except for the buttons in the last column which should extend
 623     // to the right border of radiobox and thus can be wider than this.
 624
 625     // Also, remember that wxRA_SPECIFY_COLS means that we arrange buttons in
 626     // left to right order and GetMajorDim() is the number of columns while
 627     // wxRA_SPECIFY_ROWS means that the buttons are arranged top to bottom and
 628     // GetMajorDim() is the number of rows.
 629
 630     x_offset += cx1;
 631     y_offset += cy1;
 632
 633     // Add extra space under the label, if it exists.
 634     if (!wxControl::GetLabel().empty())
 635         y_offset += cy1/2;
 636
 637     int startX = x_offset;
 638     int startY = y_offset;
 639
 640     const unsigned int count = GetCount();
 641     for (unsigned int i = 0; i < count; i++)
 642     {
 643         // the last button in the row may be wider than the other ones as the
 644         // radiobox may be wider than the sum of the button widths (as it
 645         // happens, for example, when the radiobox label is very long)
 646         bool isLastInTheRow;
 647         if ( m_windowStyle & wxRA_SPECIFY_COLS )
 648         {
 649             // item is the last in its row if it is a multiple of the number of
 650             // columns or if it is just the last item
 651             unsigned int n = i + 1;
 652             isLastInTheRow = ((n % GetMajorDim()) == 0) || (n == count);
 653         }
 654         else // wxRA_SPECIFY_ROWS
 655         {
 656             // item is the last in the row if it is in the last columns
 657             isLastInTheRow = i >= (count/GetMajorDim())*GetMajorDim();
 658         }
 659
 660         // is this the start of new row/column?
 661         if ( i && (i % GetMajorDim() == 0) )
 662         {
 663             if ( m_windowStyle & wxRA_SPECIFY_ROWS )
 664             {
 665                 // start of new column
 666                 y_offset = startY;
 667                 x_offset += maxWidth + cx1;
 668             }
 669             else // start of new row
 670             {
 671                 x_offset = startX;
 672                 y_offset += maxHeight;
 673                 if (m_radioWidth[0]>0)
 674                     y_offset += cy1/2;
 675             }
 676         }
 677
 678         int widthBtn;
 679         if ( isLastInTheRow )
 680         {
 681             // make the button go to the end of radio box
 682             widthBtn = startX + width - x_offset - 2*cx1;
 683             if ( widthBtn < maxWidth )
 684                 widthBtn = maxWidth;
 685         }
 686         else
 687         {
 688             // normal button, always of the same size
 689             widthBtn = maxWidth;
 690         }
 691
 692         // make all buttons of the same, maximal size - like this they cover
 693         // the radiobox entirely and the radiobox tooltips are always shown
 694         // (otherwise they are not when the mouse pointer is in the radiobox
 695         // part not belonging to any radiobutton)
 696         DoMoveSibling((*m_radioButtons)[i], x_offset, y_offset, widthBtn, maxHeight);
 697
 698         // where do we put the next button?
 699         if ( m_windowStyle & wxRA_SPECIFY_ROWS )
 700         {
 701             // below this one
 702             y_offset += maxHeight;
 703             if (m_radioWidth[0]>0)
 704                 y_offset += cy1/2;
 705         }
 706         else
 707         {
 708             // to the right of this one
 709             x_offset += widthBtn + cx1;
 710         }
 711     }
 712 }
 713
 714 int wxRadioBox::GetItemFromPoint(const wxPoint& pt) const
 715 {
 716     const unsigned int count = GetCount();
 717     for ( unsigned int i = 0; i < count; i++ )
 718     {
 719         RECT rect = wxGetWindowRect((*m_radioButtons)[i]);
 720
 721         if ( rect.left <= pt.x && pt.x < rect.right &&
 722                 rect.top  <= pt.y && pt.y < rect.bottom )
 723         {
 724             return i;
 725         }
 726     }
 727
 728     return wxNOT_FOUND;
 729 }
 730
 731 // ----------------------------------------------------------------------------
 732 // radio box drawing
 733 // ----------------------------------------------------------------------------
 734
 735 #ifndef __WXWINCE__
 736
 737 WXHRGN wxRadioBox::MSWGetRegionWithoutChildren()
 738 {
 739     RECT rc;
 740     ::GetWindowRect(GetHwnd(), &rc);
 741     HRGN hrgn = ::CreateRectRgn(rc.left, rc.top, rc.right + 1, rc.bottom + 1);
 742
 743     const unsigned int count = GetCount();
 744     for ( unsigned int i = 0; i < count; ++i )
 745     {
 746         // don't clip out hidden children
 747         if ( !IsItemShown(i) )
 748             continue;
 749
 750         ::GetWindowRect((*m_radioButtons)[i], &rc);
 751         AutoHRGN hrgnchild(::CreateRectRgnIndirect(&rc));
 752         ::CombineRgn(hrgn, hrgn, hrgnchild, RGN_DIFF);
 753     }
 754
 755     return (WXHRGN)hrgn;
 756 }
 757
 758 #endif // __WXWINCE__
 759
 760 // ---------------------------------------------------------------------------
 761 // window proc for radio buttons
 762 // ---------------------------------------------------------------------------
 763
 764 LRESULT APIENTRY _EXPORT wxRadioBtnWndProc(HWND hwnd,
 765                                            UINT message,
 766                                            WPARAM wParam,
 767                                            LPARAM lParam)
 768 {
 769     switch ( message )
 770     {
 771         case WM_GETDLGCODE:
 772             // we must tell IsDialogMessage()/our kbd processing code that we
 773             // want to process arrows ourselves because neither of them is
 774             // smart enough to handle arrows properly for us
 775             {
 776                 long lDlgCode = ::CallWindowProc(CASTWNDPROC s_wndprocRadioBtn, hwnd,
 777                                                  message, wParam, lParam);
 778
 779                 return lDlgCode | DLGC_WANTARROWS;
 780             }
 781
 782         case WM_KEYDOWN:
 783             {
 784                 wxRadioBox *radiobox = (wxRadioBox *)wxGetWindowUserData(hwnd);
 785
 786                 wxCHECK_MSG( radiobox, 0, wxT("radio button without radio box?") );
 787
 788                 bool processed = true;
 789
 790                 wxDirection dir;
 791                 switch ( wParam )
 792                 {
 793                     case VK_UP:
 794                         dir = wxUP;
 795                         break;
 796
 797                     case VK_LEFT:
 798                         dir = wxLEFT;
 799                         break;
 800
 801                     case VK_DOWN:
 802                         dir = wxDOWN;
 803                         break;
 804
 805                     case VK_RIGHT:
 806                         dir = wxRIGHT;
 807                         break;
 808
 809                     default:
 810                         processed = false;
 811
 812                         // just to suppress the compiler warning
 813                         dir = wxALL;
 814                 }
 815
 816                 if ( processed )
 817                 {
 818                     int selOld = radiobox->GetSelection();
 819                     int selNew = radiobox->GetNextItem
 820                                  (
 821                                   selOld,
 822                                   dir,
 823                                   radiobox->GetWindowStyle()
 824                                  );
 825
 826                     if ( selNew != selOld )
 827                     {
 828                         radiobox->SetSelection(selNew);
 829                         radiobox->SetFocus();
 830
 831                         // emulate the button click
 832                         radiobox->SendNotificationEvent();
 833
 834                         return 0;
 835                     }
 836                 }
 837             }
 838             break;
 839
 840         case WM_SETFOCUS:
 841         case WM_KILLFOCUS:
 842             {
 843                 wxRadioBox *radiobox = (wxRadioBox *)wxGetWindowUserData(hwnd);
 844
 845                 wxCHECK_MSG( radiobox, 0, wxT("radio button without radio box?") );
 846
 847                 // if we don't do this, no focus events are generated for the
 848                 // radiobox and, besides, we need to notify the parent about
 849                 // the focus change, otherwise the focus handling logic in
 850                 // wxControlContainer doesn't work
 851                 if ( message == WM_SETFOCUS )
 852                     radiobox->HandleSetFocus((WXHWND)wParam);
 853                 else
 854                     radiobox->HandleKillFocus((WXHWND)wParam);
 855             }
 856             break;
 857
 858 #ifndef __WXWINCE__
 859         case WM_HELP:
 860             {
 861                 wxRadioBox *radiobox = (wxRadioBox *)wxGetWindowUserData(hwnd);
 862
 863                 wxCHECK_MSG( radiobox, 0, wxT("radio button without radio box?") );
 864
 865                 bool processed = false;
 866
 867                 wxEvtHandler * const handler = radiobox->GetEventHandler();
 868
 869                 HELPINFO* info = (HELPINFO*) lParam;
 870                 if ( info->iContextType == HELPINFO_WINDOW )
 871                 {
 872                     for ( wxWindow* subjectOfHelp = radiobox;
 873                           subjectOfHelp;
 874                           subjectOfHelp = subjectOfHelp->GetParent() )
 875                     {
 876                         wxHelpEvent helpEvent(wxEVT_HELP,
 877                                               subjectOfHelp->GetId(),
 878                                               wxPoint(info->MousePos.x,
 879                                                       info->MousePos.y));
 880                         helpEvent.SetEventObject(radiobox);
 881                         if ( handler->ProcessEvent(helpEvent) )
 882                         {
 883                             processed = true;
 884                             break;
 885                         }
 886                     }
 887                 }
 888                 else if (info->iContextType == HELPINFO_MENUITEM)
 889                 {
 890                     wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId);
 891                     helpEvent.SetEventObject(radiobox);
 892                     processed = handler->ProcessEvent(helpEvent);
 893                 }
 894
 895                 if ( processed )
 896                     return 0;
 897             }
 898             break;
 899 #endif // !__WXWINCE__
 900     }
 901
 902     return ::CallWindowProc(CASTWNDPROC s_wndprocRadioBtn, hwnd, message, wParam, lParam);
 903 }
 904
 905 #endif // wxUSE_RADIOBOX