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