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     ::SetFocus((HWND)m_radioButtons[N]);
 336
 337     m_selectedButton = N;
 338 }
 339
 340 // Get single selection, for single choice list items
 341 int wxRadioBox::GetSelection() const
 342 {
 343     return m_selectedButton;
 344 }
 345
 346 // Find string for position
 347 wxString wxRadioBox::GetString(int item) const
 348 {
 349     wxCHECK_MSG( item >= 0 && item < m_noItems, wxEmptyString,
 350                  wxT("invalid radiobox index") );
 351
 352     return wxGetWindowText(m_radioButtons[item]);
 353 }
 354
 355 // ----------------------------------------------------------------------------
 356 // size calculations
 357 // ----------------------------------------------------------------------------
 358
 359 wxSize wxRadioBox::GetMaxButtonSize() const
 360 {
 361     // calculate the max button size
 362     int widthMax = 0,
 363         heightMax = 0;
 364     for ( int i = 0 ; i < m_noItems; i++ )
 365     {
 366         int width, height;
 367         if ( m_radioWidth[i] < 0 )
 368         {
 369             GetTextExtent(wxGetWindowText(m_radioButtons[i]), &width, &height);
 370
 371             // adjust the size to take into account the radio box itself
 372             // FIXME this is totally bogus!
 373             width += RADIO_SIZE;
 374             height *= 3;
 375             height /= 2;
 376         }
 377         else
 378         {
 379             width = m_radioWidth[i];
 380             height = m_radioHeight[i];
 381         }
 382
 383         if ( widthMax < width )
 384             widthMax = width;
 385         if ( heightMax < height )
 386             heightMax = height;
 387     }
 388
 389     return wxSize(widthMax, heightMax);
 390 }
 391
 392 wxSize wxRadioBox::GetTotalButtonSize(const wxSize& sizeBtn) const
 393 {
 394     // the radiobox should be big enough for its buttons
 395     int cx1, cy1;
 396     wxGetCharSize(m_hWnd, &cx1, &cy1, &GetFont());
 397
 398     int extraHeight = cy1;
 399
 400     /* We'll assume the adjustments below are OK for Win 3.1 too
 401 #if defined(CTL3D) && !CTL3D
 402     // Requires a bigger group box in plain Windows
 403     extraHeight *= 3;
 404     extraHeight /= 2;
 405 #endif
 406     */
 407
 408     int height = GetNumVer() * sizeBtn.y + cy1/2 + extraHeight;
 409     int width  = GetNumHor() * (sizeBtn.x + cx1) + cx1;
 410
 411     // Add extra space under the label, if it exists.
 412     if (!wxControl::GetLabel().IsEmpty())
 413         height += cy1/2;
 414
 415     // and also wide enough for its label
 416     int widthLabel;
 417     GetTextExtent(GetTitle(), &widthLabel, NULL);
 418     widthLabel += RADIO_SIZE; // FIXME this is bogus too
 419     if ( widthLabel > width )
 420         width = widthLabel;
 421
 422     return wxSize(width, height);
 423 }
 424
 425 wxSize wxRadioBox::DoGetBestSize() const
 426 {
 427     return GetTotalButtonSize(GetMaxButtonSize());
 428 }
 429
 430 // Restored old code.
 431 void wxRadioBox::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 432 {
 433     int currentX, currentY;
 434     GetPosition(&currentX, &currentY);
 435     int widthOld, heightOld;
 436     GetSize(&widthOld, &heightOld);
 437
 438     int xx = x;
 439     int yy = y;
 440
 441     if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 442         xx = currentX;
 443     if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 444         yy = currentY;
 445
 446 #if RADIOBTN_PARENT_IS_RADIOBOX
 447     int y_offset = 0;
 448     int x_offset = 0;
 449 #else
 450     int y_offset = yy;
 451     int x_offset = xx;
 452 #endif
 453
 454     int cx1, cy1;
 455     wxGetCharSize(m_hWnd, &cx1, &cy1, & GetFont());
 456
 457     // Attempt to have a look coherent with other platforms: We compute the
 458     // biggest toggle dim, then we align all items according this value.
 459     wxSize maxSize = GetMaxButtonSize();
 460     int maxWidth = maxSize.x,
 461         maxHeight = maxSize.y;
 462
 463     wxSize totSize = GetTotalButtonSize(maxSize);
 464     int totWidth = totSize.x,
 465         totHeight = totSize.y;
 466
 467     // only change our width/height if asked for
 468     if ( width == -1 )
 469     {
 470         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
 471             width = totWidth;
 472         else
 473             width = widthOld;
 474     }
 475
 476     if ( height == -1 )
 477     {
 478         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
 479             height = totHeight;
 480         else
 481             height = heightOld;
 482     }
 483
 484     ::MoveWindow(GetHwnd(), xx, yy, width, height, TRUE);
 485
 486     // Now position all the buttons: the current button will be put at
 487     // wxPoint(x_offset, y_offset) and the new row/column will start at
 488     // startX/startY. The size of all buttons will be the same wxSize(maxWidth,
 489     // maxHeight) except for the buttons in the last column which should extend
 490     // to the right border of radiobox and thus can be wider than this.
 491
 492     // Also, remember that wxRA_SPECIFY_COLS means that we arrange buttons in
 493     // left to right order and m_majorDim is the number of columns while
 494     // wxRA_SPECIFY_ROWS means that the buttons are arranged top to bottom and
 495     // m_majorDim is the number of rows.
 496
 497     x_offset += cx1;
 498     y_offset += cy1;
 499
 500     // Add extra space under the label, if it exists.
 501     if (!wxControl::GetLabel().IsEmpty())
 502         y_offset += cy1/2;
 503
 504     int startX = x_offset;
 505     int startY = y_offset;
 506
 507     for ( int i = 0; i < m_noItems; i++ )
 508     {
 509         // the last button in the row may be wider than the other ones as the
 510         // radiobox may be wider than the sum of the button widths (as it
 511         // happens, for example, when the radiobox label is very long)
 512         bool isLastInTheRow;
 513         if ( m_windowStyle & wxRA_SPECIFY_COLS )
 514         {
 515             // item is the last in its row if it is a multiple of the number of
 516             // columns or if it is just the last item
 517             int n = i + 1;
 518             isLastInTheRow = ((n % m_majorDim) == 0) || (n == m_noItems);
 519         }
 520         else // wxRA_SPECIFY_ROWS
 521         {
 522             // item is the last in the row if it is in the last columns
 523             isLastInTheRow = i >= (m_noItems/m_majorDim)*m_majorDim;
 524         }
 525
 526         // is this the start of new row/column?
 527         if ( i && (i % m_majorDim == 0) )
 528         {
 529             if ( m_windowStyle & wxRA_SPECIFY_ROWS )
 530             {
 531                 // start of new column
 532                 y_offset = startY;
 533                 x_offset += maxWidth + cx1;
 534             }
 535             else // start of new row
 536             {
 537                 x_offset = startX;
 538                 y_offset += maxHeight;
 539                 if (m_radioWidth[0]>0)
 540                     y_offset += cy1/2;
 541             }
 542         }
 543
 544         int widthBtn;
 545         if ( isLastInTheRow )
 546         {
 547             // make the button go to the end of radio box
 548             widthBtn = startX + width - x_offset - 2*cx1;
 549             if ( widthBtn < maxWidth )
 550                 widthBtn = maxWidth;
 551         }
 552         else
 553         {
 554             // normal button, always of the same size
 555             widthBtn = maxWidth;
 556         }
 557
 558         // VZ: make all buttons of the same, maximal size - like this they
 559         //     cover the radiobox entirely and the radiobox tooltips are always
 560         //     shown (otherwise they are not when the mouse pointer is in the
 561         //     radiobox part not belonging to any radiobutton)
 562         ::MoveWindow((HWND)m_radioButtons[i],
 563                      x_offset, y_offset, widthBtn, maxHeight,
 564                      TRUE);
 565
 566         // where do we put the next button?
 567         if ( m_windowStyle & wxRA_SPECIFY_ROWS )
 568         {
 569             // below this one
 570             y_offset += maxHeight;
 571             if (m_radioWidth[0]>0)
 572                 y_offset += cy1/2;
 573         }
 574         else
 575         {
 576             // to the right of this one
 577             x_offset += widthBtn + cx1;
 578         }
 579     }
 580 }
 581
 582 void wxRadioBox::GetSize(int *width, int *height) const
 583 {
 584     RECT rect;
 585     rect.left = -1; rect.right = -1; rect.top = -1; rect.bottom = -1;
 586
 587     if (m_hWnd)
 588         wxFindMaxSize(m_hWnd, &rect);
 589
 590     int i;
 591     for (i = 0; i < m_noItems; i++)
 592         wxFindMaxSize(m_radioButtons[i], &rect);
 593
 594     *width = rect.right - rect.left;
 595     *height = rect.bottom - rect.top;
 596 }
 597
 598 void wxRadioBox::GetPosition(int *x, int *y) const
 599 {
 600     wxWindow *parent = GetParent();
 601     RECT rect = { -1, -1, -1, -1 };
 602
 603     int i;
 604     for (i = 0; i < m_noItems; i++)
 605         wxFindMaxSize(m_radioButtons[i], &rect);
 606
 607     if (m_hWnd)
 608         wxFindMaxSize(m_hWnd, &rect);
 609
 610     // Since we now have the absolute screen coords, if there's a parent we
 611     // must subtract its top left corner
 612     POINT point;
 613     point.x = rect.left;
 614     point.y = rect.top;
 615     if (parent)
 616     {
 617         ::ScreenToClient((HWND) parent->GetHWND(), &point);
 618     }
 619
 620     // We may be faking the client origin. So a window that's really at (0, 30)
 621     // may appear (to wxWin apps) to be at (0, 0).
 622     if (GetParent())
 623     {
 624         wxPoint pt(GetParent()->GetClientAreaOrigin());
 625         point.x -= pt.x;
 626         point.y -= pt.y;
 627     }
 628
 629     *x = point.x;
 630     *y = point.y;
 631 }
 632
 633 void wxRadioBox::SetFocus()
 634 {
 635     if (m_noItems > 0)
 636     {
 637         if (m_selectedButton == -1)
 638             ::SetFocus((HWND) m_radioButtons[0]);
 639         else
 640             ::SetFocus((HWND) m_radioButtons[m_selectedButton]);
 641     }
 642
 643 }
 644
 645 bool wxRadioBox::Show(bool show)
 646 {
 647     if ( !wxControl::Show(show) )
 648         return FALSE;
 649
 650     int nCmdShow = show ? SW_SHOW : SW_HIDE;
 651     for ( int i = 0; i < m_noItems; i++ )
 652     {
 653         ::ShowWindow((HWND)m_radioButtons[i], nCmdShow);
 654     }
 655
 656     return TRUE;
 657 }
 658
 659 // Enable a specific button
 660 void wxRadioBox::Enable(int item, bool enable)
 661 {
 662     wxCHECK_RET( item >= 0 && item < m_noItems,
 663                  wxT("invalid item in wxRadioBox::Enable()") );
 664
 665     ::EnableWindow((HWND) m_radioButtons[item], enable);
 666 }
 667
 668 // Enable all controls
 669 bool wxRadioBox::Enable(bool enable)
 670 {
 671     if ( !wxControl::Enable(enable) )
 672         return FALSE;
 673
 674     for (int i = 0; i < m_noItems; i++)
 675         ::EnableWindow((HWND) m_radioButtons[i], enable);
 676
 677     return TRUE;
 678 }
 679
 680 // Show a specific button
 681 void wxRadioBox::Show(int item, bool show)
 682 {
 683     wxCHECK_RET( item >= 0 && item < m_noItems,
 684                  wxT("invalid item in wxRadioBox::Show()") );
 685
 686     ::ShowWindow((HWND)m_radioButtons[item], show ? SW_SHOW : SW_HIDE);
 687 }
 688
 689 bool wxRadioBox::ContainsHWND(WXHWND hWnd) const
 690 {
 691     size_t count = GetCount();
 692     for ( size_t i = 0; i < count; i++ )
 693     {
 694         if ( GetRadioButtons()[i] == hWnd )
 695             return TRUE;
 696     }
 697
 698     return FALSE;
 699 }
 700
 701 void wxRadioBox::Command(wxCommandEvent & event)
 702 {
 703     SetSelection (event.m_commandInt);
 704     ProcessCommand (event);
 705 }
 706
 707 // NB: if this code is changed, wxGetWindowForHWND() which relies on having the
 708 //     radiobox pointer in GWL_USERDATA for radio buttons must be updated too!
 709 void wxRadioBox::SubclassRadioButton(WXHWND hWndBtn)
 710 {
 711     // No GWL_USERDATA in Win16, so omit this subclassing.
 712 #ifdef __WIN32__
 713     HWND hwndBtn = (HWND)hWndBtn;
 714
 715     if ( !s_wndprocRadioBtn )
 716         s_wndprocRadioBtn = (WXFARPROC)::GetWindowLong(hwndBtn, GWL_WNDPROC);
 717
 718     ::SetWindowLong(hwndBtn, GWL_WNDPROC, (long)wxRadioBtnWndProc);
 719     ::SetWindowLong(hwndBtn, GWL_USERDATA, (long)this);
 720 #endif // __WIN32__
 721 }
 722
 723 void wxRadioBox::SendNotificationEvent()
 724 {
 725     wxCommandEvent event(wxEVT_COMMAND_RADIOBOX_SELECTED, m_windowId);
 726     event.SetInt( m_selectedButton );
 727     event.SetString( GetString(m_selectedButton) );
 728     event.SetEventObject( this );
 729     ProcessCommand(event);
 730 }
 731
 732 bool wxRadioBox::SetFont(const wxFont& font)
 733 {
 734     if ( !wxControl::SetFont(font) )
 735     {
 736         // nothing to do
 737         return FALSE;
 738     }
 739
 740     // also set the font of our radio buttons
 741     WXHFONT hfont = wxFont(font).GetResourceHandle();
 742     for ( int n = 0; n < m_noItems; n++ )
 743     {
 744         HWND hwndBtn = (HWND)m_radioButtons[n];
 745         ::SendMessage(hwndBtn, WM_SETFONT, (WPARAM)hfont, 0L);
 746
 747         // otherwise the buttons are not redrawn correctly
 748         ::InvalidateRect(hwndBtn, NULL, FALSE /* don't erase bg */);
 749     }
 750
 751     return TRUE;
 752 }
 753
 754 // ----------------------------------------------------------------------------
 755 // our window proc
 756 // ----------------------------------------------------------------------------
 757
 758 long wxRadioBox::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 759 {
 760     switch ( nMsg )
 761     {
 762 #ifdef __WIN32__
 763         case WM_CTLCOLORSTATIC:
 764             // set the colour of the radio buttons to be the same as ours
 765             {
 766                 HDC hdc = (HDC)wParam;
 767
 768                 const wxColour& colBack = GetBackgroundColour();
 769                 ::SetBkColor(hdc, wxColourToRGB(colBack));
 770                 ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour()));
 771
 772                 wxBrush *brush = wxTheBrushList->FindOrCreateBrush(colBack, wxSOLID);
 773
 774                 return (WXHBRUSH)brush->GetResourceHandle();
 775             }
 776 #endif // Win32
 777
 778         // VZ: this code breaks radiobox redrawing under Windows XP, don't use
 779         //     it. If you need to get messages from the static controls,
 780         //     create them as a child of another (non static) window
 781 #if 0
 782         // This is required for the radiobox to be sensitive to mouse input,
 783         // e.g. for Dialog Editor.
 784         case WM_NCHITTEST:
 785             {
 786                 int xPos = LOWORD(lParam);  // horizontal position of cursor
 787                 int yPos = HIWORD(lParam);  // vertical position of cursor
 788
 789                 ScreenToClient(&xPos, &yPos);
 790
 791                 // Make sure you can drag by the top of the groupbox, but let
 792                 // other (enclosed) controls get mouse events also
 793                 if (yPos < 10)
 794                     return (long)HTCLIENT;
 795             }
 796             break;
 797 #endif // 0
 798     }
 799
 800     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 801 }
 802
 803 WXHBRUSH wxRadioBox::OnCtlColor(WXHDC pDC, WXHWND WXUNUSED(pWnd), WXUINT WXUNUSED(nCtlColor),
 804 #if wxUSE_CTL3D
 805                                WXUINT message,
 806                                WXWPARAM wParam,
 807                                WXLPARAM lParam
 808 #else
 809                                WXUINT WXUNUSED(message),
 810                                WXWPARAM WXUNUSED(wParam),
 811                                WXLPARAM WXUNUSED(lParam)
 812 #endif
 813     )
 814 {
 815 #if wxUSE_CTL3D
 816     if ( m_useCtl3D )
 817     {
 818         HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
 819         return (WXHBRUSH) hbrush;
 820     }
 821 #endif // wxUSE_CTL3D
 822
 823     HDC hdc = (HDC)pDC;
 824     wxColour colBack = GetBackgroundColour();
 825
 826     if (!IsEnabled())
 827         colBack = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 828
 829     ::SetBkColor(hdc, wxColourToRGB(colBack));
 830     ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour()));
 831
 832     wxBrush *brush = wxTheBrushList->FindOrCreateBrush(colBack, wxSOLID);
 833
 834     return (WXHBRUSH)brush->GetResourceHandle();
 835 }
 836
 837
 838 // ---------------------------------------------------------------------------
 839 // window proc for radio buttons
 840 // ---------------------------------------------------------------------------
 841
 842 #ifdef __WIN32__
 843
 844 LRESULT APIENTRY _EXPORT wxRadioBtnWndProc(HWND hwnd,
 845                                            UINT message,
 846                                            WPARAM wParam,
 847                                            LPARAM lParam)
 848 {
 849     switch ( message )
 850     {
 851         case WM_GETDLGCODE:
 852             // we must tell IsDialogMessage()/our kbd processing code that we
 853             // want to process arrows ourselves because neither of them is
 854             // smart enough to handle arrows properly for us
 855             {
 856                 long lDlgCode = ::CallWindowProc(CASTWNDPROC s_wndprocRadioBtn, hwnd,
 857                                                  message, wParam, lParam);
 858
 859                 return lDlgCode | DLGC_WANTARROWS;
 860             }
 861
 862 #if wxUSE_TOOLTIPS
 863         case WM_NOTIFY:
 864             {
 865                 NMHDR* hdr = (NMHDR *)lParam;
 866                 if ( hdr->code == TTN_NEEDTEXT )
 867                 {
 868                     wxRadioBox *radiobox = (wxRadioBox *)
 869                         ::GetWindowLong(hwnd, GWL_USERDATA);
 870
 871                     wxCHECK_MSG( radiobox, 0,
 872                                  wxT("radio button without radio box?") );
 873
 874                     wxToolTip *tooltip = radiobox->GetToolTip();
 875                     if ( tooltip )
 876                     {
 877                         TOOLTIPTEXT *ttt = (TOOLTIPTEXT *)lParam;
 878                         ttt->lpszText = (wxChar *)tooltip->GetTip().c_str();
 879                     }
 880
 881                     // processed
 882                     return 0;
 883                 }
 884             }
 885             break;
 886 #endif // wxUSE_TOOLTIPS
 887
 888         case WM_KEYDOWN:
 889             {
 890                 wxRadioBox *radiobox = (wxRadioBox *)
 891                     ::GetWindowLong(hwnd, GWL_USERDATA);
 892
 893                 wxCHECK_MSG( radiobox, 0, wxT("radio button without radio box?") );
 894
 895                 bool processed = TRUE;
 896
 897                 wxDirection dir;
 898                 switch ( wParam )
 899                 {
 900                     case VK_UP:
 901                         dir = wxUP;
 902                         break;
 903
 904                     case VK_LEFT:
 905                         dir = wxLEFT;
 906                         break;
 907
 908                     case VK_DOWN:
 909                         dir = wxDOWN;
 910                         break;
 911
 912                     case VK_RIGHT:
 913                         dir = wxRIGHT;
 914                         break;
 915
 916                     default:
 917                         processed = FALSE;
 918
 919                         // just to suppress the compiler warning
 920                         dir = wxALL;
 921                 }
 922
 923                 if ( processed )
 924                 {
 925                     int selOld = radiobox->GetSelection();
 926                     int selNew = radiobox->GetNextItem
 927                                  (
 928                                   selOld,
 929                                   dir,
 930                                   radiobox->GetWindowStyle()
 931                                  );
 932
 933                     if ( selNew != selOld )
 934                     {
 935                         radiobox->SetSelection(selNew);
 936
 937                         // emulate the button click
 938                         radiobox->SendNotificationEvent();
 939
 940                         return 0;
 941                     }
 942                 }
 943             }
 944             break;
 945
 946 #ifdef __WIN32__
 947         case WM_HELP:
 948             {
 949                 wxRadioBox *radiobox = (wxRadioBox *)
 950                         ::GetWindowLong(hwnd, GWL_USERDATA);
 951
 952                 wxCHECK_MSG( radiobox, 0, wxT("radio button without radio box?") );
 953
 954                 bool processed = TRUE;
 955
 956                 // HELPINFO doesn't seem to be supported on WinCE.
 957 #ifndef __WXWINCE__
 958                 HELPINFO* info = (HELPINFO*) lParam;
 959                 // Don't yet process menu help events, just windows
 960                 if (info->iContextType == HELPINFO_WINDOW)
 961 #endif
 962                 {
 963                     wxWindow* subjectOfHelp = radiobox;
 964                     bool eventProcessed = FALSE;
 965                     while (subjectOfHelp && !eventProcessed)
 966                     {
 967                         wxHelpEvent helpEvent(wxEVT_HELP, subjectOfHelp->GetId(),
 968 #ifdef __WXWINCE__
 969                                               wxPoint(0, 0)
 970 #else
 971                                               wxPoint(info->MousePos.x, info->MousePos.y)
 972 #endif
 973                             ) ; // info->iCtrlId);
 974                         helpEvent.SetEventObject(radiobox);
 975                         eventProcessed = radiobox->GetEventHandler()->ProcessEvent(helpEvent);
 976
 977                         // Go up the window hierarchy until the event is handled (or not)
 978                         subjectOfHelp = subjectOfHelp->GetParent();
 979                     }
 980                     processed = eventProcessed;
 981                 }
 982 #ifndef __WXWINCE__
 983                 else if (info->iContextType == HELPINFO_MENUITEM)
 984                 {
 985                     wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId) ;
 986                     helpEvent.SetEventObject(radiobox);
 987                     processed = radiobox->GetEventHandler()->ProcessEvent(helpEvent);
 988                 }
 989                 else
 990                     processed = FALSE;
 991 #endif
 992                 if (processed)
 993                     return 0;
 994
 995                 break;
 996             }
 997 #endif // __WIN32__
 998     }
 999
1000     return ::CallWindowProc(CASTWNDPROC s_wndprocRadioBtn, hwnd, message, wParam, lParam);
1001 }
1002
1003 #endif // __WIN32__
1004
1005 #endif // wxUSE_RADIOBOX