]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/combobox.cpp
The rounded corners look really dumb at this size.
[wxWidgets.git] / src / gtk1 / combobox.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk1/combobox.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Copyright: (c) 1998 Robert Roebling
6 // Licence: wxWindows licence
7 /////////////////////////////////////////////////////////////////////////////
8
9 // For compilers that support precompilation, includes "wx.h".
10 #include "wx/wxprec.h"
11
12 #if wxUSE_COMBOBOX
13
14 #include "wx/combobox.h"
15
16 #ifndef WX_PRECOMP
17 #include "wx/intl.h"
18 #include "wx/settings.h"
19 #include "wx/textctrl.h" // for wxEVT_TEXT
20 #include "wx/arrstr.h"
21 #endif
22
23 #include "wx/gtk1/private.h"
24
25 //-----------------------------------------------------------------------------
26 // idle system
27 //-----------------------------------------------------------------------------
28
29 extern void wxapp_install_idle_handler();
30 extern bool g_isIdle;
31
32 //-----------------------------------------------------------------------------
33 // data
34 //-----------------------------------------------------------------------------
35
36 extern bool g_blockEventsOnDrag;
37 static int g_SelectionBeforePopup = wxID_NONE; // this means the popup is hidden
38
39 //-----------------------------------------------------------------------------
40 // "changed" - typing and list item matches get changed, select-child
41 // if it doesn't match an item then just get a single changed
42 //-----------------------------------------------------------------------------
43
44 extern "C" {
45 static void
46 gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxComboBox *combo )
47 {
48 if (g_isIdle) wxapp_install_idle_handler();
49
50 if (combo->m_ignoreNextUpdate)
51 {
52 combo->m_ignoreNextUpdate = false;
53 return;
54 }
55
56 if (!combo->m_hasVMT) return;
57
58 wxCommandEvent event( wxEVT_TEXT, combo->GetId() );
59 event.SetString( combo->GetValue() );
60 event.SetEventObject( combo );
61 combo->HandleWindowEvent( event );
62 }
63 }
64
65 extern "C" {
66 static void
67 gtk_dummy_callback(GtkEntry *WXUNUSED(entry), GtkCombo *WXUNUSED(combo))
68 {
69 }
70 }
71
72 extern "C" {
73 static void
74 gtk_popup_hide_callback(GtkCombo *WXUNUSED(gtk_combo), wxComboBox *combo)
75 {
76 // when the popup is hidden, throw a SELECTED event only if the combobox
77 // selection changed.
78 const int curSelection = combo->GetCurrentSelection();
79
80 const bool hasChanged = curSelection != g_SelectionBeforePopup;
81
82 // reset the selection flag to value meaning that it is hidden and do it
83 // now, before generating the events, so that GetSelection() returns the
84 // new value from the event handler
85 g_SelectionBeforePopup = wxID_NONE;
86
87 if ( hasChanged )
88 {
89 wxCommandEvent event( wxEVT_COMBOBOX, combo->GetId() );
90 event.SetInt( curSelection );
91 event.SetString( combo->GetStringSelection() );
92 event.SetEventObject( combo );
93 combo->HandleWindowEvent( event );
94
95 // for consistency with the other ports, send TEXT event
96 wxCommandEvent event2( wxEVT_TEXT, combo->GetId() );
97 event2.SetString( combo->GetStringSelection() );
98 event2.SetEventObject( combo );
99 combo->HandleWindowEvent( event2 );
100 }
101 }
102 }
103
104 extern "C" {
105 static void
106 gtk_popup_show_callback(GtkCombo *WXUNUSED(gtk_combo), wxComboBox *combo)
107 {
108 // store the combobox selection value before the popup is shown
109 g_SelectionBeforePopup = combo->GetCurrentSelection();
110 }
111 }
112
113 //-----------------------------------------------------------------------------
114 // "select-child" - click/cursor get select-child, changed, select-child
115 //-----------------------------------------------------------------------------
116
117 extern "C" {
118 static void
119 gtk_combo_select_child_callback( GtkList *WXUNUSED(list), GtkWidget *WXUNUSED(widget), wxComboBox *combo )
120 {
121 if (g_isIdle) wxapp_install_idle_handler();
122
123 if (!combo->m_hasVMT) return;
124
125 if (g_blockEventsOnDrag) return;
126
127 int curSelection = combo->GetCurrentSelection();
128
129 if (combo->m_prevSelection == curSelection) return;
130
131 GtkWidget *list = GTK_COMBO(combo->m_widget)->list;
132 gtk_list_unselect_item( GTK_LIST(list), combo->m_prevSelection );
133
134 combo->m_prevSelection = curSelection;
135
136 // Quickly set the value of the combo box
137 // as GTK+ does that only AFTER the event
138 // is sent.
139 gtk_signal_disconnect_by_func( GTK_OBJECT(GTK_COMBO(combo->GetHandle())->entry),
140 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)combo );
141 combo->SetValue( combo->GetStringSelection() );
142 gtk_signal_connect_after( GTK_OBJECT(GTK_COMBO(combo->GetHandle())->entry), "changed",
143 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)combo );
144
145 // throw a SELECTED event only if the combobox popup is hidden (wxID_NONE)
146 // because when combobox popup is shown, gtk_combo_select_child_callback is
147 // called each times the mouse is over an item with a pressed button so a lot
148 // of SELECTED event could be generated if the user keep the mouse button down
149 // and select other items ...
150 if (g_SelectionBeforePopup == wxID_NONE)
151 {
152 wxCommandEvent event( wxEVT_COMBOBOX, combo->GetId() );
153 event.SetInt( curSelection );
154 event.SetString( combo->GetStringSelection() );
155 event.SetEventObject( combo );
156 combo->HandleWindowEvent( event );
157
158 // for consistency with the other ports, don't generate text update
159 // events while the user is browsing the combobox neither
160 wxCommandEvent event2( wxEVT_TEXT, combo->GetId() );
161 event2.SetString( combo->GetValue() );
162 event2.SetEventObject( combo );
163 combo->HandleWindowEvent( event2 );
164 }
165 }
166 }
167
168 //-----------------------------------------------------------------------------
169 // wxComboBox
170 //-----------------------------------------------------------------------------
171
172 BEGIN_EVENT_TABLE(wxComboBox, wxControl)
173 EVT_SIZE(wxComboBox::OnSize)
174 EVT_CHAR(wxComboBox::OnChar)
175
176 EVT_MENU(wxID_CUT, wxComboBox::OnCut)
177 EVT_MENU(wxID_COPY, wxComboBox::OnCopy)
178 EVT_MENU(wxID_PASTE, wxComboBox::OnPaste)
179 EVT_MENU(wxID_UNDO, wxComboBox::OnUndo)
180 EVT_MENU(wxID_REDO, wxComboBox::OnRedo)
181 EVT_MENU(wxID_CLEAR, wxComboBox::OnDelete)
182 EVT_MENU(wxID_SELECTALL, wxComboBox::OnSelectAll)
183
184 EVT_UPDATE_UI(wxID_CUT, wxComboBox::OnUpdateCut)
185 EVT_UPDATE_UI(wxID_COPY, wxComboBox::OnUpdateCopy)
186 EVT_UPDATE_UI(wxID_PASTE, wxComboBox::OnUpdatePaste)
187 EVT_UPDATE_UI(wxID_UNDO, wxComboBox::OnUpdateUndo)
188 EVT_UPDATE_UI(wxID_REDO, wxComboBox::OnUpdateRedo)
189 EVT_UPDATE_UI(wxID_CLEAR, wxComboBox::OnUpdateDelete)
190 EVT_UPDATE_UI(wxID_SELECTALL, wxComboBox::OnUpdateSelectAll)
191 END_EVENT_TABLE()
192
193 bool wxComboBox::Create( wxWindow *parent, wxWindowID id,
194 const wxString& value,
195 const wxPoint& pos, const wxSize& size,
196 const wxArrayString& choices,
197 long style, const wxValidator& validator,
198 const wxString& name )
199 {
200 wxCArrayString chs(choices);
201
202 return Create( parent, id, value, pos, size, chs.GetCount(),
203 chs.GetStrings(), style, validator, name );
204 }
205
206 bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
207 const wxPoint& pos, const wxSize& size,
208 int n, const wxString choices[],
209 long style, const wxValidator& validator,
210 const wxString& name )
211 {
212 m_ignoreNextUpdate = false;
213 m_needParent = true;
214 m_acceptsFocus = true;
215 m_prevSelection = 0;
216
217 if (!PreCreation( parent, pos, size ) ||
218 !CreateBase( parent, id, pos, size, style, validator, name ))
219 {
220 wxFAIL_MSG( wxT("wxComboBox creation failed") );
221 return false;
222 }
223
224 m_widget = gtk_combo_new();
225 GtkCombo *combo = GTK_COMBO(m_widget);
226
227 // Disable GTK's broken events ...
228 gtk_signal_disconnect( GTK_OBJECT(combo->entry), combo->entry_change_id );
229 // ... and add surrogate handler.
230 combo->entry_change_id = gtk_signal_connect (GTK_OBJECT (combo->entry), "changed",
231 (GtkSignalFunc) gtk_dummy_callback, combo);
232
233 // make it more useable
234 gtk_combo_set_use_arrows_always( GTK_COMBO(m_widget), TRUE );
235
236 // and case-sensitive
237 gtk_combo_set_case_sensitive( GTK_COMBO(m_widget), TRUE );
238
239 GtkWidget *list = GTK_COMBO(m_widget)->list;
240
241 // gtk_list_set_selection_mode( GTK_LIST(list), GTK_SELECTION_MULTIPLE );
242
243 for (int i = 0; i < n; i++)
244 {
245 GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( choices[i] ) );
246
247 m_clientDataList.Append( NULL );
248 m_clientObjectList.Append( NULL );
249
250 gtk_container_add( GTK_CONTAINER(list), list_item );
251
252 gtk_widget_show( list_item );
253 }
254
255 m_parent->DoAddChild( this );
256
257 m_focusWidget = combo->entry;
258
259 PostCreation(size);
260
261 ConnectWidget( combo->button );
262
263 // MSW's combo box shows the value and the selection is -1
264 gtk_entry_set_text( GTK_ENTRY(combo->entry), wxGTK_CONV(value) );
265 gtk_list_unselect_all( GTK_LIST(combo->list) );
266
267 if (style & wxCB_READONLY)
268 gtk_entry_set_editable( GTK_ENTRY( combo->entry ), FALSE );
269
270 // "show" and "hide" events are generated when user click on the combobox button which popups a list
271 // this list is the "popwin" gtk widget
272 gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "hide",
273 GTK_SIGNAL_FUNC(gtk_popup_hide_callback), (gpointer)this );
274 gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "show",
275 GTK_SIGNAL_FUNC(gtk_popup_show_callback), (gpointer)this );
276
277 gtk_signal_connect_after( GTK_OBJECT(combo->entry), "changed",
278 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this );
279
280 gtk_signal_connect_after( GTK_OBJECT(combo->list), "select-child",
281 GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this );
282
283 SetInitialSize(size); // need this too because this is a wxControlWithItems
284
285 // This is required for tool bar support
286 // wxSize setsize = GetSize();
287 // gtk_widget_set_usize( m_widget, setsize.x, setsize.y );
288
289 return true;
290 }
291
292 wxComboBox::~wxComboBox()
293 {
294 wxList::compatibility_iterator node = m_clientObjectList.GetFirst();
295 while (node)
296 {
297 wxClientData *cd = (wxClientData*)node->GetData();
298 if (cd) delete cd;
299 node = node->GetNext();
300 }
301 m_clientObjectList.Clear();
302
303 m_clientDataList.Clear();
304 }
305
306 void wxComboBox::SetFocus()
307 {
308 if ( m_hasFocus )
309 {
310 // don't do anything if we already have focus
311 return;
312 }
313
314 gtk_widget_grab_focus( m_focusWidget );
315 }
316
317 int wxComboBox::DoInsertItems(const wxArrayStringsAdapter& items,
318 unsigned int pos,
319 void **clientData,
320 wxClientDataType type)
321 {
322 wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid combobox") );
323
324 DisableEvents();
325
326 GtkWidget *list = GTK_COMBO(m_widget)->list;
327
328 GtkRcStyle *style = CreateWidgetStyle();
329
330 const unsigned int count = items.GetCount();
331 for( unsigned int i = 0; i < count; ++i, ++pos )
332 {
333 GtkWidget *
334 list_item = gtk_list_item_new_with_label( wxGTK_CONV( items[i] ) );
335
336 if ( pos == GetCount() )
337 {
338 gtk_container_add( GTK_CONTAINER(list), list_item );
339 }
340 else // insert, not append
341 {
342 GList *gitem_list = g_list_alloc ();
343 gitem_list->data = list_item;
344 gtk_list_insert_items( GTK_LIST (list), gitem_list, pos );
345 }
346
347 if (GTK_WIDGET_REALIZED(m_widget))
348 {
349 gtk_widget_realize( list_item );
350 gtk_widget_realize( GTK_BIN(list_item)->child );
351
352 if (style)
353 {
354 gtk_widget_modify_style( GTK_WIDGET( list_item ), style );
355 GtkBin *bin = GTK_BIN( list_item );
356 GtkWidget *label = GTK_WIDGET( bin->child );
357 gtk_widget_modify_style( label, style );
358 }
359
360 }
361
362 gtk_widget_show( list_item );
363
364 if ( m_clientDataList.GetCount() < GetCount() )
365 m_clientDataList.Insert( pos, NULL );
366 if ( m_clientObjectList.GetCount() < GetCount() )
367 m_clientObjectList.Insert( pos, NULL );
368
369 AssignNewItemClientData(pos, clientData, i, type);
370 }
371
372 if ( style )
373 gtk_rc_style_unref( style );
374
375 EnableEvents();
376
377 InvalidateBestSize();
378
379 return pos - 1;
380 }
381
382 void wxComboBox::DoSetItemClientData(unsigned int n, void* clientData)
383 {
384 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
385
386 wxList::compatibility_iterator node = m_clientDataList.Item( n );
387 if (!node) return;
388
389 node->SetData( (wxObject*) clientData );
390 }
391
392 void* wxComboBox::DoGetItemClientData(unsigned int n) const
393 {
394 wxCHECK_MSG( m_widget != NULL, NULL, wxT("invalid combobox") );
395
396 wxList::compatibility_iterator node = m_clientDataList.Item( n );
397
398 return node ? node->GetData() : NULL;
399 }
400
401 void wxComboBox::DoClear()
402 {
403 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
404
405 DisableEvents();
406
407 GtkWidget *list = GTK_COMBO(m_widget)->list;
408 gtk_list_clear_items( GTK_LIST(list), 0, (int)GetCount() );
409
410 m_clientObjectList.Clear();
411
412 m_clientDataList.Clear();
413
414 EnableEvents();
415
416 InvalidateBestSize();
417 }
418
419 void wxComboBox::DoDeleteOneItem(unsigned int n)
420 {
421 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
422
423 GtkList *listbox = GTK_LIST( GTK_COMBO(m_widget)->list );
424
425 GList *child = g_list_nth( listbox->children, n );
426
427 if (!child)
428 {
429 wxFAIL_MSG(wxT("wrong index"));
430 return;
431 }
432
433 DisableEvents();
434
435 GList *list = g_list_append( NULL, child->data );
436 gtk_list_remove_items( listbox, list );
437 g_list_free( list );
438
439 wxList::compatibility_iterator node = m_clientObjectList.Item( n );
440 if (node)
441 {
442 m_clientObjectList.Erase( node );
443 }
444
445 node = m_clientDataList.Item( n );
446 if (node)
447 m_clientDataList.Erase( node );
448
449 EnableEvents();
450
451 InvalidateBestSize();
452 }
453
454 void wxComboBox::SetString(unsigned int n, const wxString &text)
455 {
456 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
457
458 GtkWidget *list = GTK_COMBO(m_widget)->list;
459
460 GList *child = g_list_nth( GTK_LIST(list)->children, n );
461 if (child)
462 {
463 GtkBin *bin = GTK_BIN( child->data );
464 GtkLabel *label = GTK_LABEL( bin->child );
465 gtk_label_set_text(label, wxGTK_CONV(text));
466 }
467 else
468 {
469 wxFAIL_MSG( wxT("wxComboBox: wrong index") );
470 }
471
472 InvalidateBestSize();
473 }
474
475 int wxComboBox::FindString( const wxString &item, bool bCase ) const
476 {
477 wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid combobox") );
478
479 GtkWidget *list = GTK_COMBO(m_widget)->list;
480
481 GList *child = GTK_LIST(list)->children;
482 int count = 0;
483 while (child)
484 {
485 GtkBin *bin = GTK_BIN( child->data );
486 GtkLabel *label = GTK_LABEL( bin->child );
487 wxString str( label->label );
488 if (item.IsSameAs( str , bCase ) )
489 return count;
490
491 count++;
492 child = child->next;
493 }
494
495 return wxNOT_FOUND;
496 }
497
498 int wxComboBox::GetSelection() const
499 {
500 // if the popup is currently opened, use the selection as it had been
501 // before it dropped down
502 return g_SelectionBeforePopup == wxID_NONE ? GetCurrentSelection()
503 : g_SelectionBeforePopup;
504 }
505
506 int wxComboBox::GetCurrentSelection() const
507 {
508 wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid combobox") );
509
510 GtkWidget *list = GTK_COMBO(m_widget)->list;
511
512 GList *selection = GTK_LIST(list)->selection;
513 if (selection)
514 {
515 GList *child = GTK_LIST(list)->children;
516 int count = 0;
517 while (child)
518 {
519 if (child->data == selection->data) return count;
520 count++;
521 child = child->next;
522 }
523 }
524
525 return wxNOT_FOUND;
526 }
527
528 wxString wxComboBox::GetString(unsigned int n) const
529 {
530 wxCHECK_MSG( m_widget != NULL, wxEmptyString, wxT("invalid combobox") );
531
532 GtkWidget *list = GTK_COMBO(m_widget)->list;
533
534 wxString str;
535 GList *child = g_list_nth( GTK_LIST(list)->children, n );
536 if (child)
537 {
538 GtkBin *bin = GTK_BIN( child->data );
539 GtkLabel *label = GTK_LABEL( bin->child );
540 str = wxString( label->label );
541 }
542 else
543 {
544 wxFAIL_MSG( wxT("wxComboBox: wrong index") );
545 }
546
547 return str;
548 }
549
550 wxString wxComboBox::GetStringSelection() const
551 {
552 wxCHECK_MSG( m_widget != NULL, wxEmptyString, wxT("invalid combobox") );
553
554 GtkWidget *list = GTK_COMBO(m_widget)->list;
555
556 GList *selection = GTK_LIST(list)->selection;
557 if (selection)
558 {
559 GtkBin *bin = GTK_BIN( selection->data );
560 GtkLabel *label = GTK_LABEL( bin->child );
561 wxString tmp( label->label );
562 return tmp;
563 }
564
565 wxFAIL_MSG( wxT("wxComboBox: no selection") );
566
567 return wxEmptyString;
568 }
569
570 unsigned int wxComboBox::GetCount() const
571 {
572 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid combobox") );
573
574 GtkWidget *list = GTK_COMBO(m_widget)->list;
575
576 GList *child = GTK_LIST(list)->children;
577 unsigned int count = 0;
578 while (child) { count++; child = child->next; }
579 return count;
580 }
581
582 void wxComboBox::SetSelection( int n )
583 {
584 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
585
586 DisableEvents();
587
588 GtkWidget *list = GTK_COMBO(m_widget)->list;
589 gtk_list_unselect_item( GTK_LIST(list), m_prevSelection );
590 gtk_list_select_item( GTK_LIST(list), n );
591 m_prevSelection = n;
592
593 EnableEvents();
594 }
595
596 wxString wxComboBox::DoGetValue() const
597 {
598 GtkEntry *entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
599 wxString tmp( wxGTK_CONV_BACK( gtk_entry_get_text( entry ) ) );
600
601 #if 0
602 for (int i = 0; i < wxStrlen(tmp.c_str()) +1; i++)
603 {
604 wxChar c = tmp[i];
605 printf( "%d ", (int) (c) );
606 }
607 printf( "\n" );
608 #endif
609
610 return tmp;
611 }
612
613 void wxComboBox::SetValue( const wxString& value )
614 {
615 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
616
617 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
618 gtk_entry_set_text( GTK_ENTRY(entry), wxGTK_CONV( value ) );
619
620 InvalidateBestSize();
621 }
622
623 void wxComboBox::WriteText(const wxString& value)
624 {
625 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
626
627 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
628 GtkEditable * const edit = GTK_EDITABLE(entry);
629
630 gtk_editable_delete_selection(edit);
631 gint len = gtk_editable_get_position(edit);
632 gtk_editable_insert_text(edit, wxGTK_CONV(value), -1, &len);
633 gtk_editable_set_position(edit, len);
634 }
635
636 void wxComboBox::Copy()
637 {
638 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
639
640 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
641 gtk_editable_copy_clipboard( GTK_EDITABLE(entry) DUMMY_CLIPBOARD_ARG );
642 }
643
644 void wxComboBox::Cut()
645 {
646 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
647
648 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
649 gtk_editable_cut_clipboard( GTK_EDITABLE(entry) DUMMY_CLIPBOARD_ARG );
650 }
651
652 void wxComboBox::Paste()
653 {
654 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
655
656 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
657 gtk_editable_paste_clipboard( GTK_EDITABLE(entry) DUMMY_CLIPBOARD_ARG);
658 }
659
660 void wxComboBox::Undo()
661 {
662 // TODO
663 }
664
665 void wxComboBox::Redo()
666 {
667 // TODO
668 }
669
670 void wxComboBox::SelectAll()
671 {
672 SetSelection(0, GetLastPosition());
673 }
674
675 bool wxComboBox::CanUndo() const
676 {
677 // TODO
678 return false;
679 }
680
681 bool wxComboBox::CanRedo() const
682 {
683 // TODO
684 return false;
685 }
686
687 bool wxComboBox::HasSelection() const
688 {
689 long from, to;
690 GetSelection(&from, &to);
691 return from != to;
692 }
693
694 bool wxComboBox::CanCopy() const
695 {
696 // Can copy if there's a selection
697 return HasSelection();
698 }
699
700 bool wxComboBox::CanCut() const
701 {
702 return CanCopy() && IsEditable();
703 }
704
705 bool wxComboBox::CanPaste() const
706 {
707 // TODO: check for text on the clipboard
708 return IsEditable() ;
709 }
710
711 bool wxComboBox::IsEditable() const
712 {
713 return !HasFlag(wxCB_READONLY);
714 }
715
716
717 void wxComboBox::SetInsertionPoint( long pos )
718 {
719 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
720
721 if ( pos == GetLastPosition() )
722 pos = -1;
723
724 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
725 gtk_entry_set_position( GTK_ENTRY(entry), (int)pos );
726 }
727
728 long wxComboBox::GetInsertionPoint() const
729 {
730 return (long) GET_EDITABLE_POS( GTK_COMBO(m_widget)->entry );
731 }
732
733 wxTextPos wxComboBox::GetLastPosition() const
734 {
735 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
736 int pos = GTK_ENTRY(entry)->text_length;
737 return (long) pos-1;
738 }
739
740 void wxComboBox::Replace( long from, long to, const wxString& value )
741 {
742 wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
743
744 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
745 gtk_editable_delete_text( GTK_EDITABLE(entry), (gint)from, (gint)to );
746 if ( value.empty() ) return;
747 gint pos = (gint)to;
748
749 #if wxUSE_UNICODE
750 wxCharBuffer buffer = wxConvUTF8.cWX2MB( value );
751 gtk_editable_insert_text( GTK_EDITABLE(entry), (const char*) buffer, strlen( (const char*) buffer ), &pos );
752 #else
753 gtk_editable_insert_text( GTK_EDITABLE(entry), value.c_str(), value.length(), &pos );
754 #endif
755 }
756
757 void wxComboBox::SetSelection( long from, long to )
758 {
759 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
760 gtk_editable_select_region( GTK_EDITABLE(entry), (gint)from, (gint)to );
761 }
762
763 void wxComboBox::GetSelection( long* from, long* to ) const
764 {
765 if (IsEditable())
766 {
767 GtkEditable *editable = GTK_EDITABLE(GTK_COMBO(m_widget)->entry);
768 *from = (long) editable->selection_start_pos;
769 *to = (long) editable->selection_end_pos;
770 }
771 }
772
773 void wxComboBox::SetEditable( bool editable )
774 {
775 GtkWidget *entry = GTK_COMBO(m_widget)->entry;
776 gtk_entry_set_editable( GTK_ENTRY(entry), editable );
777 }
778
779 void wxComboBox::OnChar( wxKeyEvent &event )
780 {
781 if ( event.GetKeyCode() == WXK_RETURN )
782 {
783 // GTK automatically selects an item if its in the list
784 wxCommandEvent eventEnter(wxEVT_TEXT_ENTER, GetId());
785 eventEnter.SetString( GetValue() );
786 eventEnter.SetInt( GetSelection() );
787 eventEnter.SetEventObject( this );
788
789 if (!HandleWindowEvent( eventEnter ))
790 {
791 // This will invoke the dialog default action, such
792 // as the clicking the default button.
793
794 wxWindow *top_frame = m_parent;
795 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
796 top_frame = top_frame->GetParent();
797
798 if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
799 {
800 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
801
802 if (window->default_widget)
803 gtk_widget_activate (window->default_widget);
804 }
805 }
806
807 // Catch GTK event so that GTK doesn't open the drop
808 // down list upon RETURN.
809 return;
810 }
811
812 event.Skip();
813 }
814
815 void wxComboBox::DisableEvents()
816 {
817 gtk_signal_disconnect_by_func( GTK_OBJECT(GTK_COMBO(m_widget)->list),
818 GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this );
819 gtk_signal_disconnect_by_func( GTK_OBJECT(GTK_COMBO(m_widget)->entry),
820 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this );
821 }
822
823 void wxComboBox::EnableEvents()
824 {
825 gtk_signal_connect_after( GTK_OBJECT(GTK_COMBO(m_widget)->list), "select-child",
826 GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this );
827 gtk_signal_connect_after( GTK_OBJECT(GTK_COMBO(m_widget)->entry), "changed",
828 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this );
829 }
830
831 void wxComboBox::OnSize( wxSizeEvent &event )
832 {
833 // NB: In some situations (e.g. on non-first page of a wizard, if the
834 // size used is default size), GtkCombo widget is resized correctly,
835 // but it's look is not updated, it's rendered as if it was much wider.
836 // No other widgets are affected, so it looks like a bug in GTK+.
837 // Manually requesting resize calculation (as gtk_pizza_set_size does)
838 // fixes it.
839 if (GTK_WIDGET_VISIBLE(m_widget))
840 gtk_widget_queue_resize(m_widget);
841
842 event.Skip();
843 }
844
845 void wxComboBox::DoApplyWidgetStyle(GtkRcStyle *style)
846 {
847 // gtk_widget_modify_style( GTK_COMBO(m_widget)->button, syle );
848
849 gtk_widget_modify_style( GTK_COMBO(m_widget)->entry, style );
850 gtk_widget_modify_style( GTK_COMBO(m_widget)->list, style );
851
852 GtkList *list = GTK_LIST( GTK_COMBO(m_widget)->list );
853 GList *child = list->children;
854 while (child)
855 {
856 gtk_widget_modify_style( GTK_WIDGET(child->data), style );
857
858 GtkBin *bin = GTK_BIN(child->data);
859 gtk_widget_modify_style( bin->child, style );
860
861 child = child->next;
862 }
863 }
864
865 GtkWidget* wxComboBox::GetConnectWidget()
866 {
867 return GTK_COMBO(m_widget)->entry;
868 }
869
870 bool wxComboBox::IsOwnGtkWindow( GdkWindow *window )
871 {
872 return ( (window == GTK_ENTRY( GTK_COMBO(m_widget)->entry )->text_area) ||
873 (window == GTK_COMBO(m_widget)->button->window ) );
874 }
875
876 wxSize wxComboBox::DoGetBestSize() const
877 {
878 wxSize ret( wxControl::DoGetBestSize() );
879
880 // we know better our horizontal extent: it depends on the longest string
881 // in the combobox
882 if ( m_widget )
883 {
884 int width;
885 unsigned int count = GetCount();
886 for ( unsigned int n = 0; n < count; n++ )
887 {
888 GetTextExtent(GetString(n), &width, NULL, NULL, NULL );
889 if ( width > ret.x )
890 ret.x = width;
891 }
892 }
893
894 // empty combobox should have some reasonable default size too
895 if ( ret.x < 100 )
896 ret.x = 100;
897
898 CacheBestSize(ret);
899 return ret;
900 }
901
902 // static
903 wxVisualAttributes
904 wxComboBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
905 {
906 return GetDefaultAttributesFromGTKWidget(gtk_combo_new, true);
907 }
908
909 // ----------------------------------------------------------------------------
910 // standard event handling
911 // ----------------------------------------------------------------------------
912
913 void wxComboBox::OnCut(wxCommandEvent& WXUNUSED(event))
914 {
915 Cut();
916 }
917
918 void wxComboBox::OnCopy(wxCommandEvent& WXUNUSED(event))
919 {
920 Copy();
921 }
922
923 void wxComboBox::OnPaste(wxCommandEvent& WXUNUSED(event))
924 {
925 Paste();
926 }
927
928 void wxComboBox::OnUndo(wxCommandEvent& WXUNUSED(event))
929 {
930 Undo();
931 }
932
933 void wxComboBox::OnRedo(wxCommandEvent& WXUNUSED(event))
934 {
935 Redo();
936 }
937
938 void wxComboBox::OnDelete(wxCommandEvent& WXUNUSED(event))
939 {
940 long from, to;
941 GetSelection(& from, & to);
942 if (from != -1 && to != -1)
943 Remove(from, to);
944 }
945
946 void wxComboBox::OnSelectAll(wxCommandEvent& WXUNUSED(event))
947 {
948 SetSelection(-1, -1);
949 }
950
951 void wxComboBox::OnUpdateCut(wxUpdateUIEvent& event)
952 {
953 event.Enable( CanCut() );
954 }
955
956 void wxComboBox::OnUpdateCopy(wxUpdateUIEvent& event)
957 {
958 event.Enable( CanCopy() );
959 }
960
961 void wxComboBox::OnUpdatePaste(wxUpdateUIEvent& event)
962 {
963 event.Enable( CanPaste() );
964 }
965
966 void wxComboBox::OnUpdateUndo(wxUpdateUIEvent& event)
967 {
968 event.Enable( CanUndo() );
969 }
970
971 void wxComboBox::OnUpdateRedo(wxUpdateUIEvent& event)
972 {
973 event.Enable( CanRedo() );
974 }
975
976 void wxComboBox::OnUpdateDelete(wxUpdateUIEvent& event)
977 {
978 event.Enable(HasSelection() && IsEditable()) ;
979 }
980
981 void wxComboBox::OnUpdateSelectAll(wxUpdateUIEvent& event)
982 {
983 event.Enable(GetLastPosition() > 0);
984 }
985
986 #endif