]> git.saurik.com Git - wxWidgets.git/blob - src/msw/radiobox.cpp
Added net stuff, some fixes to gsock code for WinCE
[wxWidgets.git] / 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