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