]>
Commit | Line | Data |
---|---|---|
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->GetEventHandler()->ProcessEvent( 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->GetEventHandler()->ProcessEvent( 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->GetEventHandler()->ProcessEvent( 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->GetEventHandler()->ProcessEvent( 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->GetEventHandler()->ProcessEvent( 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( (wxObject*)NULL ); | |
251 | m_clientObjectList.Append( (wxObject*)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, (wxObject*) NULL ); | |
369 | if ( m_clientObjectList.GetCount() < GetCount() ) | |
370 | m_clientObjectList.Insert( pos, (wxObject*) 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( (GList*) 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::GetValue() 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 (!GetEventHandler()->ProcessEvent( 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 |