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