]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: radiobox.cpp | |
3 | // Purpose: | |
4 | // Author: Robert Roebling | |
5 | // Id: $Id$ | |
6 | // Copyright: (c) 1998 Robert Roebling | |
7 | // Licence: wxWindows licence | |
8 | ///////////////////////////////////////////////////////////////////////////// | |
9 | ||
10 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) | |
11 | #pragma implementation "radiobox.h" | |
12 | #endif | |
13 | ||
14 | // For compilers that support precompilation, includes "wx.h". | |
15 | #include "wx/wxprec.h" | |
16 | ||
17 | #if wxUSE_RADIOBOX | |
18 | ||
19 | #include "wx/radiobox.h" | |
20 | ||
21 | #include "wx/dialog.h" | |
22 | #include "wx/frame.h" | |
23 | #include "wx/log.h" | |
24 | ||
25 | #include "wx/gtk/private.h" | |
26 | #include <gdk/gdkkeysyms.h> | |
27 | ||
28 | #include "wx/gtk/win_gtk.h" | |
29 | ||
30 | //----------------------------------------------------------------------------- | |
31 | // idle system | |
32 | //----------------------------------------------------------------------------- | |
33 | ||
34 | extern void wxapp_install_idle_handler(); | |
35 | extern bool g_isIdle; | |
36 | ||
37 | //----------------------------------------------------------------------------- | |
38 | // data | |
39 | //----------------------------------------------------------------------------- | |
40 | ||
41 | extern bool g_blockEventsOnDrag; | |
42 | extern wxWindowGTK *g_delayedFocus; | |
43 | ||
44 | //----------------------------------------------------------------------------- | |
45 | // "clicked" | |
46 | //----------------------------------------------------------------------------- | |
47 | ||
48 | static void gtk_radiobutton_clicked_callback( GtkToggleButton *button, wxRadioBox *rb ) | |
49 | { | |
50 | if (g_isIdle) wxapp_install_idle_handler(); | |
51 | ||
52 | if (!rb->m_hasVMT) return; | |
53 | if (g_blockEventsOnDrag) return; | |
54 | ||
55 | if (!button->active) return; | |
56 | ||
57 | wxCommandEvent event( wxEVT_COMMAND_RADIOBOX_SELECTED, rb->GetId() ); | |
58 | event.SetInt( rb->GetSelection() ); | |
59 | event.SetString( rb->GetStringSelection() ); | |
60 | event.SetEventObject( rb ); | |
61 | rb->GetEventHandler()->ProcessEvent(event); | |
62 | } | |
63 | ||
64 | //----------------------------------------------------------------------------- | |
65 | // "key_press_event" | |
66 | //----------------------------------------------------------------------------- | |
67 | ||
68 | static gint gtk_radiobox_keypress_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxRadioBox *rb ) | |
69 | { | |
70 | if (g_isIdle) | |
71 | wxapp_install_idle_handler(); | |
72 | ||
73 | if (!rb->m_hasVMT) return FALSE; | |
74 | if (g_blockEventsOnDrag) return FALSE; | |
75 | ||
76 | if ((gdk_event->keyval != GDK_Up) && | |
77 | (gdk_event->keyval != GDK_Down) && | |
78 | (gdk_event->keyval != GDK_Left) && | |
79 | (gdk_event->keyval != GDK_Right)) | |
80 | { | |
81 | return FALSE; | |
82 | } | |
83 | ||
84 | wxList::compatibility_iterator node = rb->m_boxes.Find( (wxObject*) widget ); | |
85 | if (!node) | |
86 | { | |
87 | return FALSE; | |
88 | } | |
89 | ||
90 | gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" ); | |
91 | ||
92 | if ((gdk_event->keyval == GDK_Up) || | |
93 | (gdk_event->keyval == GDK_Left)) | |
94 | { | |
95 | if (node == rb->m_boxes.GetFirst()) | |
96 | node = rb->m_boxes.GetLast(); | |
97 | else | |
98 | node = node->GetPrevious(); | |
99 | } | |
100 | else | |
101 | { | |
102 | if (node == rb->m_boxes.GetLast()) | |
103 | node = rb->m_boxes.GetFirst(); | |
104 | else | |
105 | node = node->GetNext(); | |
106 | } | |
107 | ||
108 | GtkWidget *button = (GtkWidget*) node->GetData(); | |
109 | ||
110 | gtk_widget_grab_focus( button ); | |
111 | ||
112 | return TRUE; | |
113 | } | |
114 | ||
115 | static gint gtk_radiobutton_focus_in( GtkWidget *widget, | |
116 | GdkEvent *WXUNUSED(event), | |
117 | wxRadioBox *win ) | |
118 | { | |
119 | if ( win->m_lostFocus ) | |
120 | { | |
121 | // no, we didn't really lose it | |
122 | win->m_lostFocus = FALSE; | |
123 | } | |
124 | else if ( !win->m_hasFocus ) | |
125 | { | |
126 | win->m_hasFocus = TRUE; | |
127 | ||
128 | wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() ); | |
129 | event.SetEventObject( win ); | |
130 | ||
131 | // never stop the signal emission, it seems to break the kbd handling | |
132 | // inside the radiobox | |
133 | (void)win->GetEventHandler()->ProcessEvent( event ); | |
134 | } | |
135 | ||
136 | return FALSE; | |
137 | } | |
138 | ||
139 | static gint gtk_radiobutton_focus_out( GtkWidget *widget, | |
140 | GdkEvent *WXUNUSED(event), | |
141 | wxRadioBox *win ) | |
142 | { | |
143 | // wxASSERT_MSG( win->m_hasFocus, _T("got focus out without any focus in?") ); | |
144 | // Replace with a warning, else we dump core a lot! | |
145 | // if (!win->m_hasFocus) | |
146 | // wxLogWarning(_T("Radiobox got focus out without any focus in.") ); | |
147 | ||
148 | // we might have lost the focus, but may be not - it may have just gone to | |
149 | // another button in the same radiobox, so we'll check for it in the next | |
150 | // idle iteration (leave m_hasFocus == TRUE for now) | |
151 | win->m_lostFocus = TRUE; | |
152 | ||
153 | return FALSE; | |
154 | } | |
155 | ||
156 | //----------------------------------------------------------------------------- | |
157 | // wxRadioBox | |
158 | //----------------------------------------------------------------------------- | |
159 | ||
160 | IMPLEMENT_DYNAMIC_CLASS(wxRadioBox,wxControl) | |
161 | ||
162 | void wxRadioBox::Init() | |
163 | { | |
164 | m_needParent = TRUE; | |
165 | m_acceptsFocus = TRUE; | |
166 | ||
167 | m_hasFocus = | |
168 | m_lostFocus = FALSE; | |
169 | } | |
170 | ||
171 | bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, | |
172 | const wxString& title, | |
173 | const wxPoint &pos, const wxSize &size, | |
174 | const wxArrayString& choices, int majorDim, | |
175 | long style, const wxValidator& validator, | |
176 | const wxString &name ) | |
177 | { | |
178 | wxCArrayString chs(choices); | |
179 | ||
180 | return Create( parent, id, title, pos, size, chs.GetCount(), | |
181 | chs.GetStrings(), majorDim, style, validator, name ); | |
182 | } | |
183 | ||
184 | bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title, | |
185 | const wxPoint &pos, const wxSize &size, | |
186 | int n, const wxString choices[], int majorDim, | |
187 | long style, const wxValidator& validator, | |
188 | const wxString &name ) | |
189 | { | |
190 | if (!PreCreation( parent, pos, size ) || | |
191 | !CreateBase( parent, id, pos, size, style, validator, name )) | |
192 | { | |
193 | wxFAIL_MSG( wxT("wxRadioBox creation failed") ); | |
194 | return FALSE; | |
195 | } | |
196 | ||
197 | m_widget = gtk_frame_new( wxGTK_CONV( title ) ); | |
198 | ||
199 | // majorDim may be 0 if all trailing parameters were omitted, so don't | |
200 | // assert here but just use the correct value for it | |
201 | m_majorDim = majorDim == 0 ? n : majorDim; | |
202 | ||
203 | GtkRadioButton *m_radio = (GtkRadioButton*) NULL; | |
204 | ||
205 | wxString label; | |
206 | GSList *radio_button_group = (GSList *) NULL; | |
207 | for (int i = 0; i < n; i++) | |
208 | { | |
209 | if ( i != 0 ) | |
210 | radio_button_group = gtk_radio_button_group( GTK_RADIO_BUTTON(m_radio) ); | |
211 | ||
212 | label.Empty(); | |
213 | for ( const wxChar *pc = choices[i]; *pc; pc++ ) | |
214 | { | |
215 | if ( *pc != wxT('&') ) | |
216 | label += *pc; | |
217 | } | |
218 | ||
219 | m_radio = GTK_RADIO_BUTTON( gtk_radio_button_new_with_label( radio_button_group, wxGTK_CONV( label ) ) ); | |
220 | ||
221 | gtk_signal_connect( GTK_OBJECT(m_radio), "key_press_event", | |
222 | GTK_SIGNAL_FUNC(gtk_radiobox_keypress_callback), (gpointer)this ); | |
223 | ||
224 | m_boxes.Append( (wxObject*) m_radio ); | |
225 | ||
226 | ConnectWidget( GTK_WIDGET(m_radio) ); | |
227 | ||
228 | if (!i) gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(m_radio), TRUE ); | |
229 | ||
230 | gtk_signal_connect( GTK_OBJECT(m_radio), "clicked", | |
231 | GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this ); | |
232 | ||
233 | gtk_signal_connect( GTK_OBJECT(m_radio), "focus_in_event", | |
234 | GTK_SIGNAL_FUNC(gtk_radiobutton_focus_in), (gpointer)this ); | |
235 | ||
236 | gtk_signal_connect( GTK_OBJECT(m_radio), "focus_out_event", | |
237 | GTK_SIGNAL_FUNC(gtk_radiobutton_focus_out), (gpointer)this ); | |
238 | ||
239 | gtk_pizza_put( GTK_PIZZA(m_parent->m_wxwindow), | |
240 | GTK_WIDGET(m_radio), | |
241 | m_x+10, m_y+10+(i*24), 10, 10 ); | |
242 | } | |
243 | ||
244 | m_parent->DoAddChild( this ); | |
245 | ||
246 | bool wasShown = IsShown(); | |
247 | if ( wasShown ) | |
248 | Hide(); // prevent PostCreation() from showing us | |
249 | PostCreation(); | |
250 | InheritAttributes(); | |
251 | ||
252 | ApplyWidgetStyle(); | |
253 | ||
254 | SetLabel( title ); | |
255 | ||
256 | SetFont( parent->GetFont() ); | |
257 | ||
258 | SetBestSize( size ); | |
259 | ||
260 | if ( wasShown ) | |
261 | Show(); | |
262 | ||
263 | return TRUE; | |
264 | } | |
265 | ||
266 | wxRadioBox::~wxRadioBox() | |
267 | { | |
268 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
269 | while (node) | |
270 | { | |
271 | GtkWidget *button = GTK_WIDGET( node->GetData() ); | |
272 | gtk_widget_destroy( button ); | |
273 | node = node->GetNext(); | |
274 | } | |
275 | } | |
276 | ||
277 | void wxRadioBox::DoSetSize( int x, int y, int width, int height, int sizeFlags ) | |
278 | { | |
279 | wxWindow::DoSetSize( x, y, width, height, sizeFlags ); | |
280 | ||
281 | LayoutItems(false); | |
282 | } | |
283 | ||
284 | wxSize wxRadioBox::DoGetBestSize() const | |
285 | { | |
286 | wxSize size = LayoutItems(true); | |
287 | ||
288 | GtkRequisition req; | |
289 | req.width = 2; | |
290 | req.height = 2; | |
291 | (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_widget) )->size_request ) (m_widget, &req ); | |
292 | if (req.width > size.x) | |
293 | size.x = req.width; | |
294 | ||
295 | return size; | |
296 | } | |
297 | ||
298 | wxSize wxRadioBox::LayoutItems(bool justCalc) const | |
299 | { | |
300 | wxSize res( 0, 0 ); | |
301 | ||
302 | // avoid dividing by 0 below | |
303 | wxCHECK_MSG( m_majorDim, res, wxT("dimension of radiobox should not be 0!") ); | |
304 | ||
305 | int num_per_major = (m_boxes.GetCount() - 1) / m_majorDim +1; | |
306 | ||
307 | int x = 7; | |
308 | int y = 15; | |
309 | ||
310 | int num_of_cols = 0; | |
311 | int num_of_rows = 0; | |
312 | if (HasFlag(wxRA_SPECIFY_COLS)) | |
313 | { | |
314 | num_of_cols = m_majorDim; | |
315 | num_of_rows = num_per_major; | |
316 | } | |
317 | else | |
318 | { | |
319 | num_of_cols = num_per_major; | |
320 | num_of_rows = m_majorDim; | |
321 | } | |
322 | ||
323 | int lineheight = GetCharHeight()+2; | |
324 | ||
325 | if ( HasFlag(wxRA_SPECIFY_COLS) || | |
326 | (HasFlag(wxRA_SPECIFY_ROWS) && (num_of_cols > 1)) ) | |
327 | { | |
328 | for (int j = 0; j < num_of_cols; j++) | |
329 | { | |
330 | y = 3; | |
331 | y += lineheight; | |
332 | ||
333 | int max_len = 0; | |
334 | wxList::compatibility_iterator node = m_boxes.Item( j*num_of_rows ); | |
335 | for (int i1 = 0; i1< num_of_rows; i1++) | |
336 | { | |
337 | GtkWidget *button = GTK_WIDGET( node->GetData() ); | |
338 | ||
339 | GtkRequisition req; | |
340 | req.width = 2; | |
341 | req.height = 2; | |
342 | (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(button) )->size_request ) | |
343 | (button, &req ); | |
344 | ||
345 | if (req.width > max_len) max_len = req.width; | |
346 | ||
347 | if ( !justCalc ) | |
348 | gtk_pizza_move( GTK_PIZZA(m_parent->m_wxwindow), button, m_x+x, m_y+y ); | |
349 | y += req.height; | |
350 | ||
351 | node = node->GetNext(); | |
352 | if (!node) break; | |
353 | } | |
354 | ||
355 | // we don't know the max_len before | |
356 | ||
357 | node = m_boxes.Item( j*num_of_rows ); | |
358 | for (int i2 = 0; i2< num_of_rows; i2++) | |
359 | { | |
360 | GtkWidget *button = GTK_WIDGET( node->GetData() ); | |
361 | ||
362 | if ( !justCalc ) | |
363 | gtk_pizza_resize( GTK_PIZZA(m_parent->m_wxwindow), button, max_len, lineheight ); | |
364 | ||
365 | node = node->GetNext(); | |
366 | if (!node) break; | |
367 | } | |
368 | ||
369 | if (y > res.y) res.y = y; | |
370 | ||
371 | x += max_len + 2; | |
372 | } | |
373 | ||
374 | res.x = x+4; | |
375 | res.y += 4; | |
376 | } | |
377 | else | |
378 | { | |
379 | int max = 0; | |
380 | ||
381 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
382 | while (node) | |
383 | { | |
384 | GtkWidget *button = GTK_WIDGET( node->GetData() ); | |
385 | ||
386 | GtkRequisition req; | |
387 | req.width = 2; | |
388 | req.height = 2; | |
389 | (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(button) )->size_request ) | |
390 | (button, &req ); | |
391 | ||
392 | if (req.width > max) max = req.width; | |
393 | ||
394 | node = node->GetNext(); | |
395 | } | |
396 | ||
397 | node = m_boxes.GetFirst(); | |
398 | while (node) | |
399 | { | |
400 | GtkWidget *button = GTK_WIDGET( node->GetData() ); | |
401 | ||
402 | if ( !justCalc ) | |
403 | gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, lineheight ); | |
404 | x += max; | |
405 | ||
406 | node = node->GetNext(); | |
407 | } | |
408 | res.x = x+4; | |
409 | res.y = 40; | |
410 | } | |
411 | ||
412 | return res; | |
413 | } | |
414 | ||
415 | bool wxRadioBox::Show( bool show ) | |
416 | { | |
417 | wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid radiobox") ); | |
418 | ||
419 | if (!wxControl::Show(show)) | |
420 | { | |
421 | // nothing to do | |
422 | return FALSE; | |
423 | } | |
424 | ||
425 | if ( HasFlag(wxNO_BORDER) ) | |
426 | gtk_widget_hide( m_widget ); | |
427 | ||
428 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
429 | while (node) | |
430 | { | |
431 | GtkWidget *button = GTK_WIDGET( node->GetData() ); | |
432 | ||
433 | if (show) gtk_widget_show( button ); else gtk_widget_hide( button ); | |
434 | ||
435 | node = node->GetNext(); | |
436 | } | |
437 | ||
438 | return TRUE; | |
439 | } | |
440 | ||
441 | int wxRadioBox::FindString( const wxString &find ) const | |
442 | { | |
443 | wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid radiobox") ); | |
444 | ||
445 | int count = 0; | |
446 | ||
447 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
448 | while (node) | |
449 | { | |
450 | GtkLabel *label = GTK_LABEL( BUTTON_CHILD(node->GetData()) ); | |
451 | #ifdef __WXGTK20__ | |
452 | wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) ); | |
453 | #else | |
454 | wxString str( label->label ); | |
455 | #endif | |
456 | if (find == str) | |
457 | return count; | |
458 | ||
459 | count++; | |
460 | ||
461 | node = node->GetNext(); | |
462 | } | |
463 | ||
464 | return -1; | |
465 | } | |
466 | ||
467 | void wxRadioBox::SetFocus() | |
468 | { | |
469 | wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") ); | |
470 | ||
471 | if (m_boxes.GetCount() == 0) return; | |
472 | ||
473 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
474 | while (node) | |
475 | { | |
476 | GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData() ); | |
477 | if (button->active) | |
478 | { | |
479 | gtk_widget_grab_focus( GTK_WIDGET(button) ); | |
480 | return; | |
481 | } | |
482 | node = node->GetNext(); | |
483 | } | |
484 | } | |
485 | ||
486 | void wxRadioBox::SetSelection( int n ) | |
487 | { | |
488 | wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") ); | |
489 | ||
490 | wxList::compatibility_iterator node = m_boxes.Item( n ); | |
491 | ||
492 | wxCHECK_RET( node, wxT("radiobox wrong index") ); | |
493 | ||
494 | GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData() ); | |
495 | ||
496 | GtkDisableEvents(); | |
497 | ||
498 | gtk_toggle_button_set_active( button, 1 ); | |
499 | ||
500 | GtkEnableEvents(); | |
501 | } | |
502 | ||
503 | int wxRadioBox::GetSelection(void) const | |
504 | { | |
505 | wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid radiobox") ); | |
506 | ||
507 | int count = 0; | |
508 | ||
509 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
510 | while (node) | |
511 | { | |
512 | GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData() ); | |
513 | if (button->active) return count; | |
514 | count++; | |
515 | node = node->GetNext(); | |
516 | } | |
517 | ||
518 | wxFAIL_MSG( wxT("wxRadioBox none selected") ); | |
519 | ||
520 | return -1; | |
521 | } | |
522 | ||
523 | wxString wxRadioBox::GetString( int n ) const | |
524 | { | |
525 | wxCHECK_MSG( m_widget != NULL, wxT(""), wxT("invalid radiobox") ); | |
526 | ||
527 | wxList::compatibility_iterator node = m_boxes.Item( n ); | |
528 | ||
529 | wxCHECK_MSG( node, wxT(""), wxT("radiobox wrong index") ); | |
530 | ||
531 | GtkLabel *label = GTK_LABEL( BUTTON_CHILD(node->GetData()) ); | |
532 | ||
533 | #ifdef __WXGTK20__ | |
534 | wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) ); | |
535 | #else | |
536 | wxString str( label->label ); | |
537 | #endif | |
538 | ||
539 | return str; | |
540 | } | |
541 | ||
542 | void wxRadioBox::SetLabel( const wxString& label ) | |
543 | { | |
544 | wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") ); | |
545 | ||
546 | wxControl::SetLabel( label ); | |
547 | ||
548 | gtk_frame_set_label( GTK_FRAME(m_widget), wxGTK_CONV( wxControl::GetLabel() ) ); | |
549 | } | |
550 | ||
551 | void wxRadioBox::SetString( int item, const wxString& label ) | |
552 | { | |
553 | wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") ); | |
554 | ||
555 | wxList::compatibility_iterator node = m_boxes.Item( item ); | |
556 | ||
557 | wxCHECK_RET( node, wxT("radiobox wrong index") ); | |
558 | ||
559 | GtkLabel *g_label = GTK_LABEL( BUTTON_CHILD(node->GetData()) ); | |
560 | ||
561 | gtk_label_set( g_label, wxGTK_CONV( label ) ); | |
562 | } | |
563 | ||
564 | bool wxRadioBox::Enable( bool enable ) | |
565 | { | |
566 | if ( !wxControl::Enable( enable ) ) | |
567 | return FALSE; | |
568 | ||
569 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
570 | while (node) | |
571 | { | |
572 | GtkButton *button = GTK_BUTTON( node->GetData() ); | |
573 | GtkLabel *label = GTK_LABEL( BUTTON_CHILD(button) ); | |
574 | ||
575 | gtk_widget_set_sensitive( GTK_WIDGET(button), enable ); | |
576 | gtk_widget_set_sensitive( GTK_WIDGET(label), enable ); | |
577 | node = node->GetNext(); | |
578 | } | |
579 | ||
580 | return TRUE; | |
581 | } | |
582 | ||
583 | void wxRadioBox::Enable( int item, bool enable ) | |
584 | { | |
585 | wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") ); | |
586 | ||
587 | wxList::compatibility_iterator node = m_boxes.Item( item ); | |
588 | ||
589 | wxCHECK_RET( node, wxT("radiobox wrong index") ); | |
590 | ||
591 | GtkButton *button = GTK_BUTTON( node->GetData() ); | |
592 | GtkLabel *label = GTK_LABEL( BUTTON_CHILD(button) ); | |
593 | ||
594 | gtk_widget_set_sensitive( GTK_WIDGET(button), enable ); | |
595 | gtk_widget_set_sensitive( GTK_WIDGET(label), enable ); | |
596 | } | |
597 | ||
598 | void wxRadioBox::Show( int item, bool show ) | |
599 | { | |
600 | wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") ); | |
601 | ||
602 | wxList::compatibility_iterator node = m_boxes.Item( item ); | |
603 | ||
604 | wxCHECK_RET( node, wxT("radiobox wrong index") ); | |
605 | ||
606 | GtkWidget *button = GTK_WIDGET( node->GetData() ); | |
607 | ||
608 | if (show) | |
609 | gtk_widget_show( button ); | |
610 | else | |
611 | gtk_widget_hide( button ); | |
612 | } | |
613 | ||
614 | wxString wxRadioBox::GetStringSelection() const | |
615 | { | |
616 | wxCHECK_MSG( m_widget != NULL, wxT(""), wxT("invalid radiobox") ); | |
617 | ||
618 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
619 | while (node) | |
620 | { | |
621 | GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData() ); | |
622 | if (button->active) | |
623 | { | |
624 | GtkLabel *label = GTK_LABEL( BUTTON_CHILD(node->GetData()) ); | |
625 | ||
626 | #ifdef __WXGTK20__ | |
627 | wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) ); | |
628 | #else | |
629 | wxString str( label->label ); | |
630 | #endif | |
631 | return str; | |
632 | } | |
633 | node = node->GetNext(); | |
634 | } | |
635 | ||
636 | wxFAIL_MSG( wxT("wxRadioBox none selected") ); | |
637 | return wxT(""); | |
638 | } | |
639 | ||
640 | bool wxRadioBox::SetStringSelection( const wxString &s ) | |
641 | { | |
642 | wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid radiobox") ); | |
643 | ||
644 | int res = FindString( s ); | |
645 | if (res == -1) return FALSE; | |
646 | SetSelection( res ); | |
647 | ||
648 | return TRUE; | |
649 | } | |
650 | ||
651 | int wxRadioBox::GetCount() const | |
652 | { | |
653 | return m_boxes.GetCount(); | |
654 | } | |
655 | ||
656 | int wxRadioBox::GetNumberOfRowsOrCols() const | |
657 | { | |
658 | return 1; | |
659 | } | |
660 | ||
661 | void wxRadioBox::SetNumberOfRowsOrCols( int WXUNUSED(n) ) | |
662 | { | |
663 | wxFAIL_MSG(wxT("wxRadioBox::SetNumberOfRowsOrCols not implemented.")); | |
664 | } | |
665 | ||
666 | void wxRadioBox::GtkDisableEvents() | |
667 | { | |
668 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
669 | while (node) | |
670 | { | |
671 | gtk_signal_disconnect_by_func( GTK_OBJECT(node->GetData()), | |
672 | GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this ); | |
673 | ||
674 | node = node->GetNext(); | |
675 | } | |
676 | } | |
677 | ||
678 | void wxRadioBox::GtkEnableEvents() | |
679 | { | |
680 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
681 | while (node) | |
682 | { | |
683 | gtk_signal_connect( GTK_OBJECT(node->GetData()), "clicked", | |
684 | GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this ); | |
685 | ||
686 | node = node->GetNext(); | |
687 | } | |
688 | } | |
689 | ||
690 | void wxRadioBox::ApplyWidgetStyle() | |
691 | { | |
692 | SetWidgetStyle(); | |
693 | ||
694 | gtk_widget_set_style( m_widget, m_widgetStyle ); | |
695 | ||
696 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
697 | while (node) | |
698 | { | |
699 | GtkWidget *widget = GTK_WIDGET( node->GetData() ); | |
700 | gtk_widget_set_style( widget, m_widgetStyle ); | |
701 | ||
702 | gtk_widget_set_style( BUTTON_CHILD(node->GetData()), m_widgetStyle ); | |
703 | ||
704 | node = node->GetNext(); | |
705 | } | |
706 | } | |
707 | ||
708 | #if wxUSE_TOOLTIPS | |
709 | void wxRadioBox::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) | |
710 | { | |
711 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
712 | while (node) | |
713 | { | |
714 | GtkWidget *widget = GTK_WIDGET( node->GetData() ); | |
715 | gtk_tooltips_set_tip( tips, widget, wxConvCurrent->cWX2MB(tip), (gchar*) NULL ); | |
716 | node = node->GetNext(); | |
717 | } | |
718 | } | |
719 | #endif // wxUSE_TOOLTIPS | |
720 | ||
721 | bool wxRadioBox::IsOwnGtkWindow( GdkWindow *window ) | |
722 | { | |
723 | if (window == m_widget->window) return TRUE; | |
724 | ||
725 | wxList::compatibility_iterator node = m_boxes.GetFirst(); | |
726 | while (node) | |
727 | { | |
728 | GtkWidget *button = GTK_WIDGET( node->GetData() ); | |
729 | ||
730 | if (window == button->window) return TRUE; | |
731 | ||
732 | node = node->GetNext(); | |
733 | } | |
734 | ||
735 | return FALSE; | |
736 | } | |
737 | ||
738 | void wxRadioBox::OnInternalIdle() | |
739 | { | |
740 | if ( m_lostFocus ) | |
741 | { | |
742 | m_hasFocus = FALSE; | |
743 | m_lostFocus = FALSE; | |
744 | ||
745 | wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() ); | |
746 | event.SetEventObject( this ); | |
747 | ||
748 | (void)GetEventHandler()->ProcessEvent( event ); | |
749 | } | |
750 | ||
751 | if (g_delayedFocus == this) | |
752 | { | |
753 | if (GTK_WIDGET_REALIZED(m_widget)) | |
754 | { | |
755 | g_delayedFocus = NULL; | |
756 | SetFocus(); | |
757 | } | |
758 | } | |
759 | } | |
760 | ||
761 | #endif // wxUSE_RADIOBOX | |
762 |