src/msw/radiobox.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #ifdef __GNUG__
  21     #pragma implementation "radiobox.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_RADIOBOX
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/bitmap.h"
  35     #include "wx/brush.h"
  36     #include "wx/radiobox.h"
  37     #include "wx/settings.h"
  38     #include "wx/log.h"
  39 #endif
  40
  41 #include "wx/msw/private.h"
  42
  43 #if wxUSE_TOOLTIPS
  44     #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__)
  45         #include <commctrl.h>
  46     #endif
  47     #include "wx/tooltip.h"
  48 #endif // wxUSE_TOOLTIPS
  49
  50 IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
  51
  52 // there are two possible ways to create the radio buttons: either as children
  53 // of the radiobox or as siblings of it - allow playing with both variants for
  54 // now, eventually we will choose the best one for our purposes
  55 //
  56 // two main problems are the keyboard navigation inside the radiobox (arrows
  57 // should switch between buttons, not pass focus to the next control) and the
  58 // tooltips - a tooltip is associated with the radiobox itself, not the
  59 // children...
  60 //
  61 // the problems with setting this to 1:
  62 // a) Alt-<mnemonic of radiobox> isn't handled properly by IsDialogMessage()
  63 //    because it sets focus to the next control accepting it which is not a
  64 //    radio button but a radiobox sibling in this case - the only solution to
  65 //    this would be to handle Alt-<mnemonic> ourselves
  66 // b) the problems with setting radiobox colours under Win98/2K were reported
  67 //    but I couldn't reproduce it so I have no idea about what causes it
  68 //
  69 // the problems with setting this to 0:
  70 // a) the tooltips are not shown for the radiobox - possible solution: make
  71 //    TTM_WINDOWFROMPOS handling code in msw/tooltip.cpp work (easier said than
  72 //    done because I don't know why it doesn't work)
  73 #define RADIOBTN_PARENT_IS_RADIOBOX 0
  74
  75 // ---------------------------------------------------------------------------
  76 // private functions
  77 // ---------------------------------------------------------------------------
  78
  79 // wnd proc for radio buttons
  80 #ifdef __WIN32__
  81 LRESULT APIENTRY _EXPORT wxRadioBtnWndProc(HWND hWnd,
  82                                            UINT message,
  83                                            WPARAM wParam,
  84                                            LPARAM lParam);
  85
  86 // ---------------------------------------------------------------------------
  87 // global vars
  88 // ---------------------------------------------------------------------------
  89
  90 // the pointer to standard radio button wnd proc
  91 static WXFARPROC s_wndprocRadioBtn = (WXFARPROC)NULL;
  92
  93 #endif // __WIN32__
  94
  95 // ===========================================================================
  96 // implementation
  97 // ===========================================================================
  98
  99 // ---------------------------------------------------------------------------
 100 // wxRadioBox
 101 // ---------------------------------------------------------------------------
 102
 103 int wxRadioBox::GetCount() const
 104 {
 105     return m_noItems;
 106 }
 107
 108 int wxRadioBox::GetColumnCount() const
 109 {
 110     return GetNumHor();
 111 }
 112
 113 int wxRadioBox::GetRowCount() const
 114 {
 115     return GetNumVer();
 116 }
 117
 118 // returns the number of rows
 119 int wxRadioBox::GetNumVer() const
 120 {
 121     if ( m_windowStyle & wxRA_SPECIFY_ROWS )
 122     {
 123         return m_majorDim;
 124     }
 125     else
 126     {
 127         return (m_noItems + m_majorDim - 1)/m_majorDim;
 128     }
 129 }
 130
 131 // returns the number of columns
 132 int wxRadioBox::GetNumHor() const
 133 {
 134     if ( m_windowStyle & wxRA_SPECIFY_ROWS )
 135     {
 136         return (m_noItems + m_majorDim - 1)/m_majorDim;
 137     }
 138     else
 139     {
 140         return m_majorDim;
 141     }
 142 }
 143
 144 bool wxRadioBox::MSWCommand(WXUINT cmd, WXWORD id)
 145 {
 146     if ( cmd == BN_CLICKED )
 147     {
 148         if (id == GetId())
 149             return TRUE;
 150
 151         int selectedButton = -1;
 152
 153         for ( int i = 0; i < m_noItems; i++ )
 154         {
 155             if ( id == wxGetWindowId(m_radioButtons[i]) )
 156             {
 157                 selectedButton = i;
 158
 159                 break;
 160             }
 161         }
 162
 163         if ( selectedButton == -1 )
 164         {
 165             // just ignore it - due to a hack with WM_NCHITTEST handling in our
 166             // wnd proc, we can receive dummy click messages when we click near
 167             // the radiobox edge (this is ugly but Julian wouldn't let me get
 168             // rid of this...)
 169             return FALSE;
 170         }
 171
 172         if ( selectedButton != m_selectedButton )
 173         {
 174             m_selectedButton = selectedButton;
 175
 176             SendNotificationEvent();
 177         }
 178         //else: don't generate events when the selection doesn't change
 179
 180         return TRUE;
 181     }
 182     else
 183         return FALSE;
 184 }
 185
 186 // Radio box item
 187 wxRadioBox::wxRadioBox()
 188 {
 189     m_selectedButton = -1;
 190     m_noItems = 0;
 191     m_noRowsOrCols = 0;
 192     m_radioButtons = NULL;
 193     m_majorDim = 0;
 194     m_radioWidth = NULL;
 195     m_radioHeight = NULL;
 196 }
 197
 198 bool wxRadioBox::Create(wxWindow *parent,
 199                         wxWindowID id,
 200                         const wxString& title,
 201                         const wxPoint& pos,
 202                         const wxSize& size,
 203                         int n,
 204                         const wxString choices[],
 205                         int majorDim,
 206                         long style,
 207                         const wxValidator& val,
 208                         const wxString& name)
 209 {
 210     // initialize members
 211     m_selectedButton = -1;
 212     m_noItems = 0;
 213
 214     m_majorDim = majorDim == 0 ? n : majorDim;
 215     m_noRowsOrCols = majorDim;
 216
 217     // common initialization
 218     if ( !CreateControl(parent, id, pos, size, style, val, name) )
 219         return FALSE;
 220
 221     // create the static box
 222     if ( !MSWCreateControl(wxT("BUTTON"), BS_GROUPBOX | WS_GROUP,
 223                            pos, size, title, 0) )
 224         return FALSE;
 225
 226     // and now create the buttons
 227     m_noItems = n;
 228 #if RADIOBTN_PARENT_IS_RADIOBOX
 229     HWND hwndParent = GetHwnd();
 230 #else
 231     HWND hwndParent = GetHwndOf(parent);
 232 #endif
 233
 234     // Some radio boxes test consecutive id.
 235     (void)NewControlId();
 236     m_radioButtons = new WXHWND[n];
 237     m_radioWidth = new int[n];
 238     m_radioHeight = new int[n];
 239
 240     WXHFONT hfont = 0;
 241     wxFont& font = GetFont();
 242     if ( font.Ok() )
 243     {
 244         hfont = font.GetResourceHandle();
 245     }
 246
 247     for ( int i = 0; i < n; i++ )
 248     {
 249         m_radioWidth[i] =
 250         m_radioHeight[i] = -1;
 251         long styleBtn = BS_AUTORADIOBUTTON | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
 252         if ( i == 0 && style == 0 )
 253             styleBtn |= WS_GROUP;
 254
 255         long newId = NewControlId();
 256
 257         HWND hwndBtn = ::CreateWindow(_T("BUTTON"),
 258                                       choices[i],
 259                                       styleBtn,
 260                                       0, 0, 0, 0,   // will be set in SetSize()
 261                                       hwndParent,
 262                                       (HMENU)newId,
 263                                       wxGetInstance(),
 264                                       NULL);
 265
 266         if ( !hwndBtn )
 267         {
 268             wxLogLastError(wxT("CreateWindow(radio btn)"));
 269
 270             return FALSE;
 271         }
 272
 273         m_radioButtons[i] = (WXHWND)hwndBtn;
 274
 275         SubclassRadioButton((WXHWND)hwndBtn);
 276
 277         if ( hfont )
 278         {
 279             ::SendMessage(hwndBtn, WM_SETFONT, (WPARAM)hfont, 0L);
 280         }
 281
 282         m_subControls.Add(newId);
 283     }
 284
 285     // Create a dummy radio control to end the group.
 286     (void)::CreateWindow(_T("BUTTON"),
 287                          wxEmptyString,
 288                          WS_GROUP | BS_AUTORADIOBUTTON | WS_CHILD,
 289                          0, 0, 0, 0, hwndParent,
 290                          (HMENU)NewControlId(), wxGetInstance(), NULL);
 291
 292     SetSelection(0);
 293
 294     SetSize(pos.x, pos.y, size.x, size.y);
 295
 296     return TRUE;
 297 }
 298
 299 wxRadioBox::~wxRadioBox()
 300 {
 301     m_isBeingDeleted = TRUE;
 302
 303     if (m_radioButtons)
 304     {
 305         int i;
 306         for (i = 0; i < m_noItems; i++)
 307             ::DestroyWindow((HWND)m_radioButtons[i]);
 308         delete[] m_radioButtons;
 309     }
 310
 311     if (m_radioWidth)
 312         delete[] m_radioWidth;
 313     if (m_radioHeight)
 314         delete[] m_radioHeight;
 315
 316 }
 317
 318 void wxRadioBox::SetString(int item, const wxString& label)
 319 {
 320     wxCHECK_RET( item >= 0 && item < m_noItems, wxT("invalid radiobox index") );
 321
 322     m_radioWidth[item] = m_radioHeight[item] = -1;
 323     SetWindowText((HWND)m_radioButtons[item], label.c_str());
 324 }
 325
 326 void wxRadioBox::SetSelection(int N)
 327 {
 328     wxCHECK_RET( (N >= 0) && (N < m_noItems), wxT("invalid radiobox index") );
 329
 330     // Following necessary for Win32s, because Win32s translate BM_SETCHECK
 331     if (m_selectedButton >= 0 && m_selectedButton < m_noItems)
 332         ::SendMessage((HWND) m_radioButtons[m_selectedButton], BM_SETCHECK, 0, 0L);
 333
 334     ::SendMessage((HWND)m_radioButtons[N], BM_SETCHECK, 1, 0L);
 335
 336     m_selectedButton = N;
 337 }
 338
 339 // Get single selection, for single choice list items
 340 int wxRadioBox::GetSelection() const
 341 {
 342     return m_selectedButton;
 343 }
 344
 345 // Find string for position
 346 wxString wxRadioBox::GetString(int item) const
 347 {
 348     wxCHECK_MSG( item >= 0 && item < m_noItems, wxEmptyString,
 349                  wxT("invalid radiobox index") );
 350
 351     return wxGetWindowText(m_radioButtons[item]);
 352 }
 353
 354 // ----------------------------------------------------------------------------
 355 // size calculations
 356 // ----------------------------------------------------------------------------
 357
 358 wxSize wxRadioBox::GetMaxButtonSize() const
 359 {
 360     // calculate the max button size
 361     int widthMax = 0,
 362         heightMax = 0;
 363     for ( int i = 0 ; i < m_noItems; i++ )
 364     {
 365         int width, height;
 366         if ( m_radioWidth[i] < 0 )
 367         {
 368             GetTextExtent(wxGetWindowText(m_radioButtons[i]), &width, &height);
 369
 370             // adjust the size to take into account the radio box itself
 371             // FIXME this is totally bogus!
 372             width += RADIO_SIZE;
 373             height *= 3;
 374             height /= 2;
 375         }
 376         else
 377         {
 378             width = m_radioWidth[i];
 379             height = m_radioHeight[i];
 380         }
 381
 382         if ( widthMax < width )
 383             widthMax = width;
 384         if ( heightMax < height )
 385             heightMax = height;
 386     }
 387
 388     return wxSize(widthMax, heightMax);
 389 }
 390
 391 wxSize wxRadioBox::GetTotalButtonSize(const wxSize& sizeBtn) const
 392 {
 393     // the radiobox should be big enough for its buttons
 394     int cx1, cy1;
 395     wxGetCharSize(m_hWnd, &cx1, &cy1, &GetFont());
 396
 397     int extraHeight = cy1;
 398
 399     /* We'll assume the adjustments below are OK for Win 3.1 too
 400 #if defined(CTL3D) && !CTL3D
 401     // Requires a bigger group box in plain Windows
 402     extraHeight *= 3;
 403     extraHeight /= 2;
 404 #endif
 405     */
 406
 407     int height = GetNumVer() * sizeBtn.y + cy1/2 + extraHeight;
 408     int width  = GetNumHor() * (sizeBtn.x + cx1) + cx1;
 409
 410     // Add extra space under the label, if it exists.
 411     if (!wxControl::GetLabel().IsEmpty())
 412         height += cy1/2;
 413
 414     // and also wide enough for its label
 415     int widthLabel;
 416     GetTextExtent(GetTitle(), &widthLabel, NULL);
 417     widthLabel += RADIO_SIZE; // FIXME this is bogus too
 418     if ( widthLabel > width )
 419         width = widthLabel;
 420
 421     return wxSize(width, height);
 422 }
 423
 424 wxSize wxRadioBox::DoGetBestSize() const
 425 {
 426     return GetTotalButtonSize(GetMaxButtonSize());
 427 }
 428
 429 // Restored old code.
 430 void wxRadioBox::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 431 {
 432     int currentX, currentY;
 433     GetPosition(&currentX, &currentY);
 434     int widthOld, heightOld;
 435     GetSize(&widthOld, &heightOld);
 436
 437     int xx = x;
 438     int yy = y;
 439
 440     if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 441         xx = currentX;
 442     if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 443         yy = currentY;
 444
 445 #if RADIOBTN_PARENT_IS_RADIOBOX
 446     int y_offset = 0;
 447     int x_offset = 0;
 448 #else
 449     int y_offset = yy;
 450     int x_offset = xx;
 451 #endif
 452
 453     int cx1, cy1;
 454     wxGetCharSize(m_hWnd, &cx1, &cy1, & GetFont());
 455
 456     // Attempt to have a look coherent with other platforms: We compute the
 457     // biggest toggle dim, then we align all items according this value.
 458     wxSize maxSize = GetMaxButtonSize();
 459     int maxWidth = maxSize.x,
 460         maxHeight = maxSize.y;
 461
 462     wxSize totSize = GetTotalButtonSize(maxSize);
 463     int totWidth = totSize.x,
 464         totHeight = totSize.y;
 465
 466     // only change our width/height if asked for
 467     if ( width == -1 )
 468     {
 469         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
 470             width = totWidth;
 471         else
 472             width = widthOld;
 473     }
 474
 475     if ( height == -1 )
 476     {
 477         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
 478             height = totHeight;
 479         else
 480             height = heightOld;
 481     }
 482
 483     ::MoveWindow(GetHwnd(), xx, yy, width, height, TRUE);
 484
 485     // Now position all the buttons: the current button will be put at
 486     // wxPoint(x_offset, y_offset) and the new row/column will start at
 487     // startX/startY. The size of all buttons will be the same wxSize(maxWidth,
 488     // maxHeight) except for the buttons in the last column which should extend
 489     // to the right border of radiobox and thus can be wider than this.
 490
 491     // Also, remember that wxRA_SPECIFY_COLS means that we arrange buttons in
 492     // left to right order and m_majorDim is the number of columns while
 493     // wxRA_SPECIFY_ROWS means that the buttons are arranged top to bottom and
 494     // m_majorDim is the number of rows.
 495
 496     x_offset += cx1;
 497     y_offset += cy1;
 498
 499     // Add extra space under the label, if it exists.
 500     if (!wxControl::GetLabel().IsEmpty())
 501         y_offset += cy1/2;
 502
 503     int startX = x_offset;
 504     int startY = y_offset;
 505
 506     for ( int i = 0; i < m_noItems; i++ )
 507     {
 508         // the last button in the row may be wider than the other ones as the
 509         // radiobox may be wider than the sum of the button widths (as it
 510         // happens, for example, when the radiobox label is very long)
 511         bool isLastInTheRow;
 512         if ( m_windowStyle & wxRA_SPECIFY_COLS )
 513         {
 514             // item is the last in its row if it is a multiple of the number of
 515             // columns or if it is just the last item
 516             int n = i + 1;
 517             isLastInTheRow = ((n % m_majorDim) == 0) || (n == m_noItems);
 518         }
 519         else // wxRA_SPECIFY_ROWS
 520         {
 521             // item is the last in the row if it is in the last columns
 522             isLastInTheRow = i >= (m_noItems/m_majorDim)*m_majorDim;
 523         }
 524
 525         // is this the start of new row/column?
 526         if ( i && (i % m_majorDim == 0) )
 527         {
 528             if ( m_windowStyle & wxRA_SPECIFY_ROWS )
 529             {
 530                 // start of new column
 531                 y_offset = startY;
 532                 x_offset += maxWidth + cx1;
 533             }
 534             else // start of new row
 535             {
 536                 x_offset = startX;
 537                 y_offset += maxHeight;
 538                 if (m_radioWidth[0]>0)
 539                     y_offset += cy1/2;
 540             }
 541         }
 542
 543         int widthBtn;
 544         if ( isLastInTheRow )
 545         {
 546             // make the button go to the end of radio box
 547             widthBtn = startX + width - x_offset - 2*cx1;
 548             if ( widthBtn < maxWidth )
 549                 widthBtn = maxWidth;
 550         }
 551         else
 552         {
 553             // normal button, always of the same size
 554             widthBtn = maxWidth;
 555         }
 556
 557         // VZ: make all buttons of the same, maximal size - like this they
 558         //     cover the radiobox entirely and the radiobox tooltips are always
 559         //     shown (otherwise they are not when the mouse pointer is in the
 560         //     radiobox part not belonging to any radiobutton)
 561         ::MoveWindow((HWND)m_radioButtons[i],
 562                      x_offset, y_offset, widthBtn, maxHeight,
 563                      TRUE);
 564
 565         // where do we put the next button?
 566         if ( m_windowStyle & wxRA_SPECIFY_ROWS )
 567         {
 568             // below this one
 569             y_offset += maxHeight;
 570             if (m_radioWidth[0]>0)
 571                 y_offset += cy1/2;
 572         }
 573         else
 574         {
 575             // to the right of this one
 576             x_offset += widthBtn + cx1;
 577         }
 578     }
 579 }
 580
 581 void wxRadioBox::GetSize(int *width, int *height) const
 582 {
 583     RECT rect;
 584     rect.left = -1; rect.right = -1; rect.top = -1; rect.bottom = -1;
 585
 586     if (m_hWnd)
 587         wxFindMaxSize(m_hWnd, &rect);
 588
 589     int i;
 590     for (i = 0; i < m_noItems; i++)
 591         wxFindMaxSize(m_radioButtons[i], &rect);
 592
 593     *width = rect.right - rect.left;
 594     *height = rect.bottom - rect.top;
 595 }
 596
 597 void wxRadioBox::GetPosition(int *x, int *y) const
 598 {
 599     wxWindow *parent = GetParent();
 600     RECT rect = { -1, -1, -1, -1 };
 601
 602     int i;
 603     for (i = 0; i < m_noItems; i++)
 604         wxFindMaxSize(m_radioButtons[i], &rect);
 605
 606     if (m_hWnd)
 607         wxFindMaxSize(m_hWnd, &rect);
 608
 609     // Since we now have the absolute screen coords, if there's a parent we
 610     // must subtract its top left corner
 611     POINT point;
 612     point.x = rect.left;
 613     point.y = rect.top;
 614     if (parent)
 615     {
 616         ::ScreenToClient((HWND) parent->GetHWND(), &point);
 617     }
 618
 619     // We may be faking the client origin. So a window that's really at (0, 30)
 620     // may appear (to wxWin apps) to be at (0, 0).
 621     if (GetParent())
 622     {
 623         wxPoint pt(GetParent()->GetClientAreaOrigin());
 624         point.x -= pt.x;
 625         point.y -= pt.y;
 626     }
 627
 628     *x = point.x;
 629     *y = point.y;
 630 }
 631
 632 void wxRadioBox::SetFocus()
 633 {
 634     if (m_noItems > 0)
 635     {
 636         ::SetFocus((HWND)m_radioButtons[m_selectedButton == -1
 637                                             ? 0
 638                                             : m_selectedButton]);
 639     }
 640
 641 }
 642
 643 bool wxRadioBox::Show(bool show)
 644 {
 645     if ( !wxControl::Show(show) )
 646         return FALSE;
 647
 648     int nCmdShow = show ? SW_SHOW : SW_HIDE;
 649     for ( int i = 0; i < m_noItems; i++ )
 650     {
 651         ::ShowWindow((HWND)m_radioButtons[i], nCmdShow);
 652     }
 653
 654     return TRUE;
 655 }
 656
 657 // Enable a specific button
 658 void wxRadioBox::Enable(int item, bool enable)
 659 {
 660     wxCHECK_RET( item >= 0 && item < m_noItems,
 661                  wxT("invalid item in wxRadioBox::Enable()") );
 662
 663     ::EnableWindow((HWND) m_radioButtons[item], enable);
 664 }
 665
 666 // Enable all controls
 667 bool wxRadioBox::Enable(bool enable)
 668 {
 669     if ( !wxControl::Enable(enable) )
 670         return FALSE;
 671
 672     for (int i = 0; i < m_noItems; i++)
 673         ::EnableWindow((HWND) m_radioButtons[i], enable);
 674
 675     return TRUE;
 676 }
 677
 678 // Show a specific button
 679 void wxRadioBox::Show(int item, bool show)
 680 {
 681     wxCHECK_RET( item >= 0 && item < m_noItems,
 682                  wxT("invalid item in wxRadioBox::Show()") );
 683
 684     ::ShowWindow((HWND)m_radioButtons[item], show ? SW_SHOW : SW_HIDE);
 685 }
 686
 687 bool wxRadioBox::ContainsHWND(WXHWND hWnd) const
 688 {
 689     size_t count = GetCount();
 690     for ( size_t i = 0; i < count; i++ )
 691     {
 692         if ( GetRadioButtons()[i] == hWnd )
 693             return TRUE;
 694     }
 695
 696     return FALSE;
 697 }
 698
 699 void wxRadioBox::Command(wxCommandEvent & event)
 700 {
 701     SetSelection (event.m_commandInt);
 702     SetFocus();
 703     ProcessCommand (event);
 704 }
 705
 706 // NB: if this code is changed, wxGetWindowForHWND() which relies on having the
 707 //     radiobox pointer in GWL_USERDATA for radio buttons must be updated too!
 708 void wxRadioBox::SubclassRadioButton(WXHWND hWndBtn)
 709 {
 710     HWND hwndBtn = (HWND)hWndBtn;
 711
 712     if ( !s_wndprocRadioBtn )
 713         s_wndprocRadioBtn = (WXFARPROC)::GetWindowLong(hwndBtn, GWL_WNDPROC);
 714
 715     ::SetWindowLong(hwndBtn, GWL_WNDPROC, (long)wxRadioBtnWndProc);
 716     ::SetWindowLong(hwndBtn, GWL_USERDATA, (long)this);
 717 }
 718
 719 void wxRadioBox::SendNotificationEvent()
 720 {
 721     wxCommandEvent event(wxEVT_COMMAND_RADIOBOX_SELECTED, m_windowId);
 722     event.SetInt( m_selectedButton );
 723     event.SetString( GetString(m_selectedButton) );
 724     event.SetEventObject( this );
 725     ProcessCommand(event);
 726 }
 727
 728 bool wxRadioBox::SetFont(const wxFont& font)
 729 {
 730     if ( !wxControl::SetFont(font) )
 731     {
 732         // nothing to do
 733         return FALSE;
 734     }
 735
 736     // also set the font of our radio buttons
 737     WXHFONT hfont = wxFont(font).GetResourceHandle();
 738     for ( int n = 0; n < m_noItems; n++ )
 739     {
 740         HWND hwndBtn = (HWND)m_radioButtons[n];
 741         ::SendMessage(hwndBtn, WM_SETFONT, (WPARAM)hfont, 0L);
 742
 743         // otherwise the buttons are not redrawn correctly
 744         ::InvalidateRect(hwndBtn, NULL, FALSE /* don't erase bg */);
 745     }
 746
 747     return TRUE;
 748 }
 749
 750 // ----------------------------------------------------------------------------
 751 // our window proc
 752 // ----------------------------------------------------------------------------
 753
 754 long wxRadioBox::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 755 {
 756     switch ( nMsg )
 757     {
 758 #ifdef __WIN32__
 759         case WM_CTLCOLORSTATIC:
 760             // set the colour of the radio buttons to be the same as ours
 761             {
 762                 HDC hdc = (HDC)wParam;
 763
 764                 const wxColour& colBack = GetBackgroundColour();
 765                 ::SetBkColor(hdc, wxColourToRGB(colBack));
 766                 ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour()));
 767
 768                 wxBrush *brush = wxTheBrushList->FindOrCreateBrush(colBack, wxSOLID);
 769
 770                 return (WXHBRUSH)brush->GetResourceHandle();
 771             }
 772 #endif // Win32
 773
 774         // VZ: this code breaks radiobox redrawing under Windows XP, don't use
 775         //     it. If you need to get messages from the static controls,
 776         //     create them as a child of another (non static) window
 777 #if 0
 778         // This is required for the radiobox to be sensitive to mouse input,
 779         // e.g. for Dialog Editor.
 780         case WM_NCHITTEST:
 781             {
 782                 int xPos = LOWORD(lParam);  // horizontal position of cursor
 783                 int yPos = HIWORD(lParam);  // vertical position of cursor
 784
 785                 ScreenToClient(&xPos, &yPos);
 786
 787                 // Make sure you can drag by the top of the groupbox, but let
 788                 // other (enclosed) controls get mouse events also
 789                 if (yPos < 10)
 790                     return (long)HTCLIENT;
 791             }
 792             break;
 793 #endif // 0
 794     }
 795
 796     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 797 }
 798
 799 WXHBRUSH wxRadioBox::OnCtlColor(WXHDC pDC, WXHWND WXUNUSED(pWnd), WXUINT WXUNUSED(nCtlColor),
 800 #if wxUSE_CTL3D
 801                                WXUINT message,
 802                                WXWPARAM wParam,
 803                                WXLPARAM lParam
 804 #else
 805                                WXUINT WXUNUSED(message),
 806                                WXWPARAM WXUNUSED(wParam),
 807                                WXLPARAM WXUNUSED(lParam)
 808 #endif
 809     )
 810 {
 811 #if wxUSE_CTL3D
 812     if ( m_useCtl3D )
 813     {
 814         HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
 815         return (WXHBRUSH) hbrush;
 816     }
 817 #endif // wxUSE_CTL3D
 818
 819     HDC hdc = (HDC)pDC;
 820     wxColour colBack = GetBackgroundColour();
 821
 822     if (!IsEnabled())
 823         colBack = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 824
 825     ::SetBkColor(hdc, wxColourToRGB(colBack));
 826     ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour()));
 827
 828     wxBrush *brush = wxTheBrushList->FindOrCreateBrush(colBack, wxSOLID);
 829
 830     return (WXHBRUSH)brush->GetResourceHandle();
 831 }
 832
 833
 834 // ---------------------------------------------------------------------------
 835 // window proc for radio buttons
 836 // ---------------------------------------------------------------------------
 837
 838 #ifdef __WIN32__
 839
 840 LRESULT APIENTRY _EXPORT wxRadioBtnWndProc(HWND hwnd,
 841                                            UINT message,
 842                                            WPARAM wParam,
 843                                            LPARAM lParam)
 844 {
 845     switch ( message )
 846     {
 847         case WM_GETDLGCODE:
 848             // we must tell IsDialogMessage()/our kbd processing code that we
 849             // want to process arrows ourselves because neither of them is
 850             // smart enough to handle arrows properly for us
 851             {
 852                 long lDlgCode = ::CallWindowProc(CASTWNDPROC s_wndprocRadioBtn, hwnd,
 853                                                  message, wParam, lParam);
 854
 855                 return lDlgCode | DLGC_WANTARROWS;
 856             }
 857
 858 #if wxUSE_TOOLTIPS
 859         case WM_NOTIFY:
 860             {
 861                 NMHDR* hdr = (NMHDR *)lParam;
 862                 if ( hdr->code == TTN_NEEDTEXT )
 863                 {
 864                     wxRadioBox *radiobox = (wxRadioBox *)
 865                         ::GetWindowLong(hwnd, GWL_USERDATA);
 866
 867                     wxCHECK_MSG( radiobox, 0,
 868                                  wxT("radio button without radio box?") );
 869
 870                     wxToolTip *tooltip = radiobox->GetToolTip();
 871                     if ( tooltip )
 872                     {
 873                         TOOLTIPTEXT *ttt = (TOOLTIPTEXT *)lParam;
 874                         ttt->lpszText = (wxChar *)tooltip->GetTip().c_str();
 875                     }
 876
 877                     // processed
 878                     return 0;
 879                 }
 880             }
 881             break;
 882 #endif // wxUSE_TOOLTIPS
 883
 884         case WM_KEYDOWN:
 885             {
 886                 wxRadioBox *radiobox = (wxRadioBox *)
 887                     ::GetWindowLong(hwnd, GWL_USERDATA);
 888
 889                 wxCHECK_MSG( radiobox, 0, wxT("radio button without radio box?") );
 890
 891                 bool processed = TRUE;
 892
 893                 wxDirection dir;
 894                 switch ( wParam )
 895                 {
 896                     case VK_UP:
 897                         dir = wxUP;
 898                         break;
 899
 900                     case VK_LEFT:
 901                         dir = wxLEFT;
 902                         break;
 903
 904                     case VK_DOWN:
 905                         dir = wxDOWN;
 906                         break;
 907
 908                     case VK_RIGHT:
 909                         dir = wxRIGHT;
 910                         break;
 911
 912                     default:
 913                         processed = FALSE;
 914
 915                         // just to suppress the compiler warning
 916                         dir = wxALL;
 917                 }
 918
 919                 if ( processed )
 920                 {
 921                     int selOld = radiobox->GetSelection();
 922                     int selNew = radiobox->GetNextItem
 923                                  (
 924                                   selOld,
 925                                   dir,
 926                                   radiobox->GetWindowStyle()
 927                                  );
 928
 929                     if ( selNew != selOld )
 930                     {
 931                         radiobox->SetSelection(selNew);
 932                         radiobox->SetFocus();
 933
 934                         // emulate the button click
 935                         radiobox->SendNotificationEvent();
 936
 937                         return 0;
 938                     }
 939                 }
 940             }
 941             break;
 942
 943 #ifdef __WIN32__
 944         case WM_HELP:
 945             {
 946                 wxRadioBox *radiobox = (wxRadioBox *)
 947                         ::GetWindowLong(hwnd, GWL_USERDATA);
 948
 949                 wxCHECK_MSG( radiobox, 0, wxT("radio button without radio box?") );
 950
 951                 bool processed = TRUE;
 952
 953                 // HELPINFO doesn't seem to be supported on WinCE.
 954 #ifndef __WXWINCE__
 955                 HELPINFO* info = (HELPINFO*) lParam;
 956                 // Don't yet process menu help events, just windows
 957                 if (info->iContextType == HELPINFO_WINDOW)
 958 #endif
 959                 {
 960                     wxWindow* subjectOfHelp = radiobox;
 961                     bool eventProcessed = FALSE;
 962                     while (subjectOfHelp && !eventProcessed)
 963                     {
 964                         wxHelpEvent helpEvent(wxEVT_HELP, subjectOfHelp->GetId(),
 965 #ifdef __WXWINCE__
 966                                               wxPoint(0, 0)
 967 #else
 968                                               wxPoint(info->MousePos.x, info->MousePos.y)
 969 #endif
 970                             ) ; // info->iCtrlId);
 971                         helpEvent.SetEventObject(radiobox);
 972                         eventProcessed = radiobox->GetEventHandler()->ProcessEvent(helpEvent);
 973
 974                         // Go up the window hierarchy until the event is handled (or not)
 975                         subjectOfHelp = subjectOfHelp->GetParent();
 976                     }
 977                     processed = eventProcessed;
 978                 }
 979 #ifndef __WXWINCE__
 980                 else if (info->iContextType == HELPINFO_MENUITEM)
 981                 {
 982                     wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId) ;
 983                     helpEvent.SetEventObject(radiobox);
 984                     processed = radiobox->GetEventHandler()->ProcessEvent(helpEvent);
 985                 }
 986                 else
 987                     processed = FALSE;
 988 #endif
 989                 if (processed)
 990                     return 0;
 991
 992                 break;
 993             }
 994 #endif // __WIN32__
 995     }
 996
 997     return ::CallWindowProc(CASTWNDPROC s_wndprocRadioBtn, hwnd, message, wParam, lParam);
 998 }
 999
1000 #endif // __WIN32__
1001
1002 #endif // wxUSE_RADIOBOX