]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/gtk1/listbox.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_LISTBOX | |
14 | ||
15 | #include "wx/listbox.h" | |
16 | ||
17 | #ifndef WX_PRECOMP | |
18 | #include "wx/dynarray.h" | |
19 | #include "wx/intl.h" | |
20 | #include "wx/utils.h" | |
21 | #include "wx/settings.h" | |
22 | #include "wx/checklst.h" | |
23 | #include "wx/arrstr.h" | |
24 | #endif | |
25 | ||
26 | #include "wx/gtk1/private.h" | |
27 | ||
28 | #if wxUSE_TOOLTIPS | |
29 | #include "wx/tooltip.h" | |
30 | #endif | |
31 | ||
32 | #include <gdk/gdk.h> | |
33 | #include <gtk/gtk.h> | |
34 | #include <gdk/gdkkeysyms.h> | |
35 | ||
36 | //----------------------------------------------------------------------------- | |
37 | // idle system | |
38 | //----------------------------------------------------------------------------- | |
39 | ||
40 | extern void wxapp_install_idle_handler(); | |
41 | extern bool g_isIdle; | |
42 | ||
43 | //----------------------------------------------------------------------------- | |
44 | // data | |
45 | //----------------------------------------------------------------------------- | |
46 | ||
47 | extern bool g_blockEventsOnDrag; | |
48 | extern bool g_blockEventsOnScroll; | |
49 | extern wxCursor g_globalCursor; | |
50 | extern wxWindowGTK *g_delayedFocus; | |
51 | extern wxWindowGTK *g_focusWindow; | |
52 | extern wxWindowGTK *g_focusWindowLast; | |
53 | ||
54 | static bool g_hasDoubleClicked = false; | |
55 | ||
56 | //----------------------------------------------------------------------------- | |
57 | // idle callback for SetFirstItem | |
58 | //----------------------------------------------------------------------------- | |
59 | ||
60 | struct wxlistbox_idle_struct | |
61 | { | |
62 | wxListBox *m_listbox; | |
63 | int m_item; | |
64 | gint m_tag; | |
65 | }; | |
66 | ||
67 | extern "C" { | |
68 | static gint wxlistbox_idle_callback( gpointer gdata ) | |
69 | { | |
70 | wxlistbox_idle_struct* data = (wxlistbox_idle_struct*) gdata; | |
71 | gdk_threads_enter(); | |
72 | ||
73 | gtk_idle_remove( data->m_tag ); | |
74 | ||
75 | // check that the items haven't been deleted from the listbox since we had | |
76 | // installed this callback | |
77 | wxListBox *lbox = data->m_listbox; | |
78 | if ( data->m_item < (int)lbox->GetCount() ) | |
79 | { | |
80 | lbox->SetFirstItem( data->m_item ); | |
81 | } | |
82 | ||
83 | delete data; | |
84 | ||
85 | gdk_threads_leave(); | |
86 | ||
87 | return TRUE; | |
88 | } | |
89 | } | |
90 | ||
91 | //----------------------------------------------------------------------------- | |
92 | // "focus_in_event" | |
93 | //----------------------------------------------------------------------------- | |
94 | ||
95 | extern "C" { | |
96 | static gint gtk_listitem_focus_in_callback( GtkWidget *WXUNUSED(widget), | |
97 | GdkEvent *WXUNUSED(event), | |
98 | wxWindow *win ) | |
99 | { | |
100 | if (g_isIdle) | |
101 | wxapp_install_idle_handler(); | |
102 | ||
103 | g_focusWindowLast = | |
104 | g_focusWindow = win; | |
105 | ||
106 | // does the window itself think that it has the focus? | |
107 | if ( !win->m_hasFocus ) | |
108 | { | |
109 | // not yet, notify it | |
110 | win->m_hasFocus = true; | |
111 | ||
112 | wxChildFocusEvent eventChildFocus(win); | |
113 | (void)win->HandleWindowEvent(eventChildFocus); | |
114 | ||
115 | wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId()); | |
116 | eventFocus.SetEventObject(win); | |
117 | ||
118 | (void)win->HandleWindowEvent(eventFocus); | |
119 | } | |
120 | ||
121 | return FALSE; | |
122 | } | |
123 | } | |
124 | ||
125 | //----------------------------------------------------------------------------- | |
126 | // "focus_out_event" | |
127 | //----------------------------------------------------------------------------- | |
128 | ||
129 | extern "C" { | |
130 | static gint gtk_listitem_focus_out_callback( GtkWidget *WXUNUSED(widget), | |
131 | GdkEventFocus *WXUNUSED(gdk_event), | |
132 | wxWindowGTK *win ) | |
133 | { | |
134 | if (g_isIdle) | |
135 | wxapp_install_idle_handler(); | |
136 | ||
137 | g_focusWindow = NULL; | |
138 | ||
139 | // don't send the window a kill focus event if it thinks that it doesn't | |
140 | // have focus already | |
141 | if ( win->m_hasFocus ) | |
142 | { | |
143 | win->m_hasFocus = false; | |
144 | ||
145 | wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() ); | |
146 | event.SetEventObject( win ); | |
147 | ||
148 | // even if we did process the event in wx code, still let GTK itself | |
149 | // process it too as otherwise bad things happen, especially in GTK2 | |
150 | // where the text control simply aborts the program if it doesn't get | |
151 | // the matching focus out event | |
152 | (void)win->HandleWindowEvent( event ); | |
153 | } | |
154 | ||
155 | return FALSE; | |
156 | } | |
157 | } | |
158 | ||
159 | //----------------------------------------------------------------------------- | |
160 | // "button_release_event" | |
161 | //----------------------------------------------------------------------------- | |
162 | ||
163 | /* we would normally emit a wxEVT_COMMAND_LISTBOX_DOUBLECLICKED event once | |
164 | a GDK_2BUTTON_PRESS occurs, but this has the particular problem of the | |
165 | listbox keeping the focus until it receives a GDK_BUTTON_RELEASE event. | |
166 | this can lead to race conditions so that we emit the dclick event | |
167 | after the GDK_BUTTON_RELEASE event after the GDK_2BUTTON_PRESS event */ | |
168 | ||
169 | extern "C" { | |
170 | static gint | |
171 | gtk_listbox_button_release_callback( GtkWidget * WXUNUSED(widget), | |
172 | GdkEventButton * WXUNUSED(gdk_event), | |
173 | wxListBox *listbox ) | |
174 | { | |
175 | if (g_isIdle) wxapp_install_idle_handler(); | |
176 | ||
177 | if (g_blockEventsOnDrag) return FALSE; | |
178 | if (g_blockEventsOnScroll) return FALSE; | |
179 | ||
180 | if (!listbox->m_hasVMT) return FALSE; | |
181 | ||
182 | if (!g_hasDoubleClicked) return FALSE; | |
183 | ||
184 | wxCommandEvent event( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, listbox->GetId() ); | |
185 | event.SetEventObject( listbox ); | |
186 | ||
187 | wxArrayInt aSelections; | |
188 | int n, count = listbox->GetSelections(aSelections); | |
189 | if ( count > 0 ) | |
190 | { | |
191 | n = aSelections[0]; | |
192 | if ( listbox->HasClientObjectData() ) | |
193 | event.SetClientObject( listbox->GetClientObject(n) ); | |
194 | else if ( listbox->HasClientUntypedData() ) | |
195 | event.SetClientData( listbox->GetClientData(n) ); | |
196 | event.SetString( listbox->GetString(n) ); | |
197 | } | |
198 | else | |
199 | { | |
200 | n = -1; | |
201 | } | |
202 | ||
203 | event.SetInt(n); | |
204 | ||
205 | listbox->HandleWindowEvent( event ); | |
206 | ||
207 | return FALSE; | |
208 | } | |
209 | } | |
210 | ||
211 | //----------------------------------------------------------------------------- | |
212 | // "button_press_event" | |
213 | //----------------------------------------------------------------------------- | |
214 | ||
215 | extern "C" { | |
216 | static gint | |
217 | gtk_listbox_button_press_callback( GtkWidget *widget, | |
218 | GdkEventButton *gdk_event, | |
219 | wxListBox *listbox ) | |
220 | { | |
221 | if (g_isIdle) wxapp_install_idle_handler(); | |
222 | ||
223 | if (g_blockEventsOnDrag) return FALSE; | |
224 | if (g_blockEventsOnScroll) return FALSE; | |
225 | ||
226 | if (!listbox->m_hasVMT) return FALSE; | |
227 | ||
228 | int sel = listbox->GtkGetIndex( widget ); | |
229 | ||
230 | #if wxUSE_CHECKLISTBOX | |
231 | if ((listbox->m_hasCheckBoxes) && (gdk_event->x < 15) && (gdk_event->type != GDK_2BUTTON_PRESS)) | |
232 | { | |
233 | wxCheckListBox *clb = (wxCheckListBox *)listbox; | |
234 | ||
235 | clb->Check( sel, !clb->IsChecked(sel) ); | |
236 | ||
237 | wxCommandEvent event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() ); | |
238 | event.SetEventObject( listbox ); | |
239 | event.SetInt( sel ); | |
240 | listbox->HandleWindowEvent( event ); | |
241 | } | |
242 | #endif // wxUSE_CHECKLISTBOX | |
243 | ||
244 | if ((gdk_event->state == 0) && | |
245 | (((listbox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0) || | |
246 | ((listbox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)) ) | |
247 | { | |
248 | listbox->m_blockEvent = true; | |
249 | ||
250 | int i; | |
251 | for (i = 0; i < (int)listbox->GetCount(); i++) | |
252 | if (i != sel) | |
253 | gtk_list_unselect_item( GTK_LIST(listbox->m_list), i ); | |
254 | ||
255 | listbox->m_blockEvent = false; | |
256 | ||
257 | return false; | |
258 | } | |
259 | ||
260 | /* emit wxEVT_COMMAND_LISTBOX_DOUBLECLICKED later */ | |
261 | g_hasDoubleClicked = (gdk_event->type == GDK_2BUTTON_PRESS); | |
262 | ||
263 | return FALSE; | |
264 | } | |
265 | } | |
266 | ||
267 | //----------------------------------------------------------------------------- | |
268 | // "key_press_event" | |
269 | //----------------------------------------------------------------------------- | |
270 | ||
271 | extern "C" { | |
272 | static gint | |
273 | gtk_listbox_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxListBox *listbox ) | |
274 | { | |
275 | if (g_isIdle) | |
276 | wxapp_install_idle_handler(); | |
277 | ||
278 | if (g_blockEventsOnDrag) | |
279 | return FALSE; | |
280 | ||
281 | bool ret = false; | |
282 | ||
283 | if ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) | |
284 | { | |
285 | wxNavigationKeyEvent new_event; | |
286 | /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */ | |
287 | new_event.SetDirection( (gdk_event->keyval == GDK_Tab) ); | |
288 | /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */ | |
289 | new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) ); | |
290 | new_event.SetCurrentFocus( listbox ); | |
291 | ret = listbox->HandleWindowEvent( new_event ); | |
292 | } | |
293 | ||
294 | if ((gdk_event->keyval == GDK_Return) && (!ret)) | |
295 | { | |
296 | // eat return in all modes | |
297 | ret = true; | |
298 | } | |
299 | ||
300 | #if wxUSE_CHECKLISTBOX | |
301 | if ((gdk_event->keyval == ' ') && (listbox->m_hasCheckBoxes) && (!ret)) | |
302 | { | |
303 | int sel = listbox->GtkGetIndex( widget ); | |
304 | ||
305 | wxCheckListBox *clb = (wxCheckListBox *)listbox; | |
306 | ||
307 | clb->Check( sel, !clb->IsChecked(sel) ); | |
308 | ||
309 | wxCommandEvent new_event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() ); | |
310 | new_event.SetEventObject( listbox ); | |
311 | new_event.SetInt( sel ); | |
312 | ret = listbox->HandleWindowEvent( new_event ); | |
313 | } | |
314 | #endif // wxUSE_CHECKLISTBOX | |
315 | ||
316 | // Check or uncheck item with SPACE | |
317 | if ((gdk_event->keyval == ' ') && (!ret) && | |
318 | (((listbox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0) || | |
319 | ((listbox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)) ) | |
320 | { | |
321 | int sel = listbox->GtkGetIndex( widget ); | |
322 | ||
323 | if (sel != -1) | |
324 | { | |
325 | ret = true; | |
326 | ||
327 | if (listbox->IsSelected( sel )) | |
328 | gtk_list_unselect_item( listbox->m_list, sel ); | |
329 | else | |
330 | gtk_list_select_item( listbox->m_list, sel ); | |
331 | ||
332 | wxCommandEvent new_event(wxEVT_COMMAND_LISTBOX_SELECTED, listbox->GetId() ); | |
333 | new_event.SetEventObject( listbox ); | |
334 | wxArrayInt aSelections; | |
335 | int n, count = listbox->GetSelections(aSelections); | |
336 | if ( count > 0 ) | |
337 | { | |
338 | n = aSelections[0]; | |
339 | if ( listbox->HasClientObjectData() ) | |
340 | new_event.SetClientObject( listbox->GetClientObject(n) ); | |
341 | else if ( listbox->HasClientUntypedData() ) | |
342 | new_event.SetClientData( listbox->GetClientData(n) ); | |
343 | new_event.SetString( listbox->GetString(n) ); | |
344 | } | |
345 | else | |
346 | { | |
347 | n = -1; | |
348 | } | |
349 | new_event.SetInt(n); | |
350 | listbox->HandleWindowEvent( new_event ); | |
351 | } | |
352 | } | |
353 | ||
354 | if (ret) | |
355 | { | |
356 | gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" ); | |
357 | return TRUE; | |
358 | } | |
359 | ||
360 | return FALSE; | |
361 | } | |
362 | } | |
363 | ||
364 | //----------------------------------------------------------------------------- | |
365 | // "select" and "deselect" | |
366 | //----------------------------------------------------------------------------- | |
367 | ||
368 | static void gtk_listitem_select_cb( GtkWidget *widget, | |
369 | wxListBox *listbox, | |
370 | bool is_selection ) | |
371 | { | |
372 | if (g_isIdle) wxapp_install_idle_handler(); | |
373 | ||
374 | if (!listbox->m_hasVMT) return; | |
375 | if (g_blockEventsOnDrag) return; | |
376 | ||
377 | if (listbox->m_blockEvent) return; | |
378 | ||
379 | wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, listbox->GetId() ); | |
380 | event.SetEventObject( listbox ); | |
381 | ||
382 | // indicate whether this is a selection or a deselection | |
383 | event.SetExtraLong( is_selection ); | |
384 | ||
385 | if ((listbox->GetWindowStyleFlag() & wxLB_SINGLE) != 0) | |
386 | { | |
387 | int sel = listbox->GtkGetIndex( widget ); | |
388 | ||
389 | if (listbox->m_prevSelection != sel) | |
390 | gtk_list_unselect_item( listbox->m_list, listbox->m_prevSelection ); | |
391 | ||
392 | listbox->m_prevSelection = sel; | |
393 | } | |
394 | ||
395 | wxArrayInt aSelections; | |
396 | int n, count = listbox->GetSelections(aSelections); | |
397 | if ( count > 0 ) | |
398 | { | |
399 | n = aSelections[0]; | |
400 | if ( listbox->HasClientObjectData() ) | |
401 | event.SetClientObject( listbox->GetClientObject(n) ); | |
402 | else if ( listbox->HasClientUntypedData() ) | |
403 | event.SetClientData( listbox->GetClientData(n) ); | |
404 | event.SetString( listbox->GetString(n) ); | |
405 | } | |
406 | else | |
407 | { | |
408 | n = -1; | |
409 | } | |
410 | ||
411 | event.SetInt(n); | |
412 | ||
413 | // No longer required with new code in wxLB_SINGLE | |
414 | // listbox->GetEventHandler()->AddPendingEvent( event ); | |
415 | listbox->HandleWindowEvent( event ); | |
416 | } | |
417 | ||
418 | extern "C" { | |
419 | static void gtk_listitem_select_callback( GtkWidget *widget, wxListBox *listbox ) | |
420 | { | |
421 | gtk_listitem_select_cb( widget, listbox, TRUE ); | |
422 | } | |
423 | } | |
424 | ||
425 | extern "C" { | |
426 | static void gtk_listitem_deselect_callback( GtkWidget *widget, wxListBox *listbox ) | |
427 | { | |
428 | gtk_listitem_select_cb( widget, listbox, FALSE ); | |
429 | } | |
430 | } | |
431 | ||
432 | //----------------------------------------------------------------------------- | |
433 | // wxListBox | |
434 | //----------------------------------------------------------------------------- | |
435 | ||
436 | extern "C" { | |
437 | static gint | |
438 | gtk_listbox_realized_callback( GtkWidget *WXUNUSED(widget), wxListBox *win ) | |
439 | { | |
440 | if (g_isIdle) | |
441 | wxapp_install_idle_handler(); | |
442 | ||
443 | GList *child = win->m_list->children; | |
444 | for (child = win->m_list->children; child != NULL; child = child->next) | |
445 | gtk_widget_show( GTK_WIDGET(child->data) ); | |
446 | ||
447 | return false; | |
448 | } | |
449 | } | |
450 | ||
451 | //----------------------------------------------------------------------------- | |
452 | // wxListBox | |
453 | //----------------------------------------------------------------------------- | |
454 | ||
455 | // ---------------------------------------------------------------------------- | |
456 | // construction | |
457 | // ---------------------------------------------------------------------------- | |
458 | ||
459 | wxListBox::wxListBox() | |
460 | { | |
461 | m_list = NULL; | |
462 | #if wxUSE_CHECKLISTBOX | |
463 | m_hasCheckBoxes = false; | |
464 | #endif // wxUSE_CHECKLISTBOX | |
465 | } | |
466 | ||
467 | bool wxListBox::Create( wxWindow *parent, wxWindowID id, | |
468 | const wxPoint &pos, const wxSize &size, | |
469 | const wxArrayString& choices, | |
470 | long style, const wxValidator& validator, | |
471 | const wxString &name ) | |
472 | { | |
473 | wxCArrayString chs(choices); | |
474 | ||
475 | return Create( parent, id, pos, size, chs.GetCount(), chs.GetStrings(), | |
476 | style, validator, name ); | |
477 | } | |
478 | ||
479 | bool wxListBox::Create( wxWindow *parent, wxWindowID id, | |
480 | const wxPoint &pos, const wxSize &size, | |
481 | int n, const wxString choices[], | |
482 | long style, const wxValidator& validator, | |
483 | const wxString &name ) | |
484 | { | |
485 | m_needParent = true; | |
486 | m_acceptsFocus = true; | |
487 | m_prevSelection = 0; // or -1 ?? | |
488 | m_blockEvent = false; | |
489 | ||
490 | if (!PreCreation( parent, pos, size ) || | |
491 | !CreateBase( parent, id, pos, size, style, validator, name )) | |
492 | { | |
493 | wxFAIL_MSG( wxT("wxListBox creation failed") ); | |
494 | return false; | |
495 | } | |
496 | ||
497 | m_widget = gtk_scrolled_window_new( NULL, NULL ); | |
498 | if (style & wxLB_ALWAYS_SB) | |
499 | { | |
500 | gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget), | |
501 | GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS ); | |
502 | } | |
503 | else | |
504 | { | |
505 | gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget), | |
506 | GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); | |
507 | } | |
508 | ||
509 | m_list = GTK_LIST( gtk_list_new() ); | |
510 | ||
511 | GtkSelectionMode mode; | |
512 | if (style & wxLB_MULTIPLE) | |
513 | { | |
514 | mode = GTK_SELECTION_MULTIPLE; | |
515 | } | |
516 | else if (style & wxLB_EXTENDED) | |
517 | { | |
518 | mode = GTK_SELECTION_EXTENDED; | |
519 | } | |
520 | else | |
521 | { | |
522 | // if style was 0 set single mode | |
523 | m_windowStyle |= wxLB_SINGLE; | |
524 | mode = GTK_SELECTION_SINGLE; | |
525 | } | |
526 | ||
527 | gtk_list_set_selection_mode( GTK_LIST(m_list), mode ); | |
528 | ||
529 | gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), GTK_WIDGET(m_list) ); | |
530 | ||
531 | /* make list scroll when moving the focus down using cursor keys */ | |
532 | gtk_container_set_focus_vadjustment( | |
533 | GTK_CONTAINER(m_list), | |
534 | gtk_scrolled_window_get_vadjustment( | |
535 | GTK_SCROLLED_WINDOW(m_widget))); | |
536 | ||
537 | gtk_widget_show( GTK_WIDGET(m_list) ); | |
538 | ||
539 | gtk_signal_connect( GTK_OBJECT(m_list), "realize", | |
540 | GTK_SIGNAL_FUNC(gtk_listbox_realized_callback), (gpointer) this ); | |
541 | ||
542 | if ( style & wxLB_SORT ) | |
543 | { | |
544 | // this will change Append() behaviour | |
545 | m_strings = new wxSortedArrayString; | |
546 | } | |
547 | else | |
548 | { | |
549 | m_strings = NULL; | |
550 | } | |
551 | ||
552 | Append(n, choices); | |
553 | ||
554 | m_parent->DoAddChild( this ); | |
555 | ||
556 | PostCreation(size); | |
557 | SetInitialSize(size); // need this too because this is a wxControlWithItems | |
558 | ||
559 | return true; | |
560 | } | |
561 | ||
562 | wxListBox::~wxListBox() | |
563 | { | |
564 | m_hasVMT = false; | |
565 | ||
566 | Clear(); | |
567 | ||
568 | delete m_strings; | |
569 | } | |
570 | ||
571 | // ---------------------------------------------------------------------------- | |
572 | // adding items | |
573 | // ---------------------------------------------------------------------------- | |
574 | ||
575 | int wxListBox::DoInsertItems(const wxArrayStringsAdapter& items, | |
576 | unsigned int pos, | |
577 | void **clientData, | |
578 | wxClientDataType type) | |
579 | { | |
580 | wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") ); | |
581 | ||
582 | const unsigned count = GetCount(); | |
583 | wxCHECK_MSG( pos <= count, wxNOT_FOUND, | |
584 | wxT("invalid index in wxListBox::InsertItems") ); | |
585 | ||
586 | // code elsewhere supposes we have as many items in m_clientList as items | |
587 | // in the listbox | |
588 | wxASSERT_MSG( m_clientList.GetCount() == count, | |
589 | wxT("bug in client data management") ); | |
590 | ||
591 | InvalidateBestSize(); | |
592 | ||
593 | const unsigned numItems = items.GetCount(); | |
594 | ||
595 | for ( unsigned int n = 0; n < numItems; ++n, ++pos ) | |
596 | { | |
597 | const wxString& item = items[n]; | |
598 | ||
599 | const unsigned idx = m_strings ? m_strings->Add(item) | |
600 | : pos; | |
601 | ||
602 | GtkAddItem(item, idx == GetCount() ? (unsigned) -1 : idx); | |
603 | ||
604 | m_clientList.Insert(idx, NULL); | |
605 | ||
606 | AssignNewItemClientData(idx, clientData, n, type); | |
607 | } | |
608 | ||
609 | wxASSERT_MSG( m_clientList.GetCount() == GetCount(), | |
610 | wxT("bug in client data management") ); | |
611 | ||
612 | return pos - 1; | |
613 | } | |
614 | ||
615 | void wxListBox::GtkAddItem( const wxString &item, int pos ) | |
616 | { | |
617 | wxCHECK_RET( m_list != NULL, wxT("invalid listbox") ); | |
618 | ||
619 | GtkWidget *list_item; | |
620 | ||
621 | wxString label(item); | |
622 | #if wxUSE_CHECKLISTBOX | |
623 | if (m_hasCheckBoxes) | |
624 | { | |
625 | label.Prepend(wxCHECKLBOX_STRING); | |
626 | } | |
627 | #endif // wxUSE_CHECKLISTBOX | |
628 | ||
629 | list_item = gtk_list_item_new_with_label( wxGTK_CONV( label ) ); | |
630 | ||
631 | GList *gitem_list = g_list_alloc (); | |
632 | gitem_list->data = list_item; | |
633 | ||
634 | if (pos == -1) | |
635 | gtk_list_append_items( GTK_LIST (m_list), gitem_list ); | |
636 | else | |
637 | gtk_list_insert_items( GTK_LIST (m_list), gitem_list, pos ); | |
638 | ||
639 | gtk_signal_connect_after( GTK_OBJECT(list_item), "select", | |
640 | GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this ); | |
641 | ||
642 | if (HasFlag(wxLB_MULTIPLE) || HasFlag(wxLB_EXTENDED)) | |
643 | gtk_signal_connect_after( GTK_OBJECT(list_item), "deselect", | |
644 | GTK_SIGNAL_FUNC(gtk_listitem_deselect_callback), (gpointer)this ); | |
645 | ||
646 | gtk_signal_connect( GTK_OBJECT(list_item), | |
647 | "button_press_event", | |
648 | (GtkSignalFunc)gtk_listbox_button_press_callback, | |
649 | (gpointer) this ); | |
650 | ||
651 | gtk_signal_connect_after( GTK_OBJECT(list_item), | |
652 | "button_release_event", | |
653 | (GtkSignalFunc)gtk_listbox_button_release_callback, | |
654 | (gpointer) this ); | |
655 | ||
656 | gtk_signal_connect( GTK_OBJECT(list_item), | |
657 | "key_press_event", | |
658 | (GtkSignalFunc)gtk_listbox_key_press_callback, | |
659 | (gpointer)this ); | |
660 | ||
661 | ||
662 | gtk_signal_connect( GTK_OBJECT(list_item), "focus_in_event", | |
663 | GTK_SIGNAL_FUNC(gtk_listitem_focus_in_callback), (gpointer)this ); | |
664 | ||
665 | gtk_signal_connect( GTK_OBJECT(list_item), "focus_out_event", | |
666 | GTK_SIGNAL_FUNC(gtk_listitem_focus_out_callback), (gpointer)this ); | |
667 | ||
668 | ConnectWidget( list_item ); | |
669 | ||
670 | if (GTK_WIDGET_REALIZED(m_widget)) | |
671 | { | |
672 | gtk_widget_show( list_item ); | |
673 | ||
674 | gtk_widget_realize( list_item ); | |
675 | gtk_widget_realize( GTK_BIN(list_item)->child ); | |
676 | ||
677 | #if wxUSE_TOOLTIPS | |
678 | if (m_tooltip) m_tooltip->Apply( this ); | |
679 | #endif | |
680 | } | |
681 | ||
682 | // Apply current widget style to the new list_item | |
683 | GtkRcStyle *style = CreateWidgetStyle(); | |
684 | if (style) | |
685 | { | |
686 | gtk_widget_modify_style( GTK_WIDGET( list_item ), style ); | |
687 | GtkBin *bin = GTK_BIN( list_item ); | |
688 | gtk_widget_modify_style( GTK_WIDGET( bin->child ), style ); | |
689 | gtk_rc_style_unref( style ); | |
690 | } | |
691 | } | |
692 | ||
693 | // ---------------------------------------------------------------------------- | |
694 | // deleting items | |
695 | // ---------------------------------------------------------------------------- | |
696 | ||
697 | void wxListBox::DoClear() | |
698 | { | |
699 | wxCHECK_RET( m_list != NULL, wxT("invalid listbox") ); | |
700 | ||
701 | gtk_list_clear_items( m_list, 0, (int)GetCount() ); | |
702 | ||
703 | if ( GTK_LIST(m_list)->last_focus_child != NULL ) | |
704 | { | |
705 | // This should be NULL, I think. | |
706 | GTK_LIST(m_list)->last_focus_child = NULL; | |
707 | } | |
708 | ||
709 | m_clientList.Clear(); | |
710 | ||
711 | if ( m_strings ) | |
712 | m_strings->Clear(); | |
713 | } | |
714 | ||
715 | void wxListBox::DoDeleteOneItem(unsigned int n) | |
716 | { | |
717 | wxCHECK_RET( m_list != NULL, wxT("invalid listbox") ); | |
718 | ||
719 | GList *child = g_list_nth( m_list->children, n ); | |
720 | ||
721 | wxCHECK_RET( child, wxT("wrong listbox index") ); | |
722 | ||
723 | GList *list = g_list_append( NULL, child->data ); | |
724 | gtk_list_remove_items( m_list, list ); | |
725 | g_list_free( list ); | |
726 | ||
727 | wxList::compatibility_iterator node = m_clientList.Item( n ); | |
728 | if ( node ) | |
729 | { | |
730 | m_clientList.Erase( node ); | |
731 | } | |
732 | ||
733 | if ( m_strings ) | |
734 | m_strings->RemoveAt(n); | |
735 | } | |
736 | ||
737 | // ---------------------------------------------------------------------------- | |
738 | // client data | |
739 | // ---------------------------------------------------------------------------- | |
740 | ||
741 | void wxListBox::DoSetItemClientData(unsigned int n, void* clientData) | |
742 | { | |
743 | wxCHECK_RET( m_widget != NULL, wxT("invalid listbox control") ); | |
744 | ||
745 | wxList::compatibility_iterator node = m_clientList.Item( n ); | |
746 | wxCHECK_RET( node, wxT("invalid index in wxListBox::DoSetItemClientData") ); | |
747 | ||
748 | node->SetData( (wxObject*) clientData ); | |
749 | } | |
750 | ||
751 | void* wxListBox::DoGetItemClientData(unsigned int n) const | |
752 | { | |
753 | wxCHECK_MSG( m_widget != NULL, NULL, wxT("invalid listbox control") ); | |
754 | ||
755 | wxList::compatibility_iterator node = m_clientList.Item( n ); | |
756 | wxCHECK_MSG( node, NULL, wxT("invalid index in wxListBox::DoGetItemClientData") ); | |
757 | ||
758 | return node->GetData(); | |
759 | } | |
760 | ||
761 | // ---------------------------------------------------------------------------- | |
762 | // string list access | |
763 | // ---------------------------------------------------------------------------- | |
764 | ||
765 | wxString wxListBox::GetRealLabel(GList *item) const | |
766 | { | |
767 | GtkBin *bin = GTK_BIN( item->data ); | |
768 | GtkLabel *label = GTK_LABEL( bin->child ); | |
769 | ||
770 | wxString str; | |
771 | ||
772 | str = wxString( label->label ); | |
773 | ||
774 | #if wxUSE_CHECKLISTBOX | |
775 | // checklistboxes have "[±] " prepended to their lables, remove it | |
776 | // | |
777 | // NB: 4 below is the length of wxCHECKLBOX_STRING from wx/gtk1/checklst.h | |
778 | if ( m_hasCheckBoxes ) | |
779 | str.erase(0, 4); | |
780 | #endif // wxUSE_CHECKLISTBOX | |
781 | ||
782 | return str; | |
783 | } | |
784 | ||
785 | void wxListBox::SetString(unsigned int n, const wxString &string) | |
786 | { | |
787 | wxCHECK_RET( m_list != NULL, wxT("invalid listbox") ); | |
788 | ||
789 | GList *child = g_list_nth( m_list->children, n ); | |
790 | if (child) | |
791 | { | |
792 | GtkBin *bin = GTK_BIN( child->data ); | |
793 | GtkLabel *label = GTK_LABEL( bin->child ); | |
794 | ||
795 | wxString str; | |
796 | #if wxUSE_CHECKLISTBOX | |
797 | if (m_hasCheckBoxes) | |
798 | str += wxCHECKLBOX_STRING; | |
799 | #endif // wxUSE_CHECKLISTBOX | |
800 | str += string; | |
801 | ||
802 | gtk_label_set( label, wxGTK_CONV( str ) ); | |
803 | } | |
804 | else | |
805 | { | |
806 | wxFAIL_MSG(wxT("wrong listbox index")); | |
807 | } | |
808 | } | |
809 | ||
810 | wxString wxListBox::GetString(unsigned int n) const | |
811 | { | |
812 | wxCHECK_MSG( m_list != NULL, wxEmptyString, wxT("invalid listbox") ); | |
813 | ||
814 | GList *child = g_list_nth( m_list->children, n ); | |
815 | if (child) | |
816 | { | |
817 | return GetRealLabel(child); | |
818 | } | |
819 | ||
820 | wxFAIL_MSG(wxT("wrong listbox index")); | |
821 | ||
822 | return wxEmptyString; | |
823 | } | |
824 | ||
825 | unsigned int wxListBox::GetCount() const | |
826 | { | |
827 | wxCHECK_MSG( m_list != NULL, 0, wxT("invalid listbox") ); | |
828 | ||
829 | GList *children = m_list->children; | |
830 | return g_list_length(children); | |
831 | } | |
832 | ||
833 | int wxListBox::FindString( const wxString &item, bool bCase ) const | |
834 | { | |
835 | wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") ); | |
836 | ||
837 | GList *child = m_list->children; | |
838 | int count = 0; | |
839 | while (child) | |
840 | { | |
841 | if ( item.IsSameAs( GetRealLabel(child), bCase ) ) | |
842 | return count; | |
843 | ||
844 | count++; | |
845 | child = child->next; | |
846 | } | |
847 | ||
848 | // it's not an error if the string is not found -> no wxCHECK | |
849 | ||
850 | return wxNOT_FOUND; | |
851 | } | |
852 | ||
853 | // ---------------------------------------------------------------------------- | |
854 | // selection | |
855 | // ---------------------------------------------------------------------------- | |
856 | ||
857 | int wxListBox::GetSelection() const | |
858 | { | |
859 | wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") ); | |
860 | ||
861 | GList *child = m_list->children; | |
862 | int count = 0; | |
863 | while (child) | |
864 | { | |
865 | if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED) return count; | |
866 | count++; | |
867 | child = child->next; | |
868 | } | |
869 | return wxNOT_FOUND; | |
870 | } | |
871 | ||
872 | int wxListBox::GetSelections( wxArrayInt& aSelections ) const | |
873 | { | |
874 | wxCHECK_MSG( m_list != NULL, wxNOT_FOUND, wxT("invalid listbox") ); | |
875 | ||
876 | // get the number of selected items first | |
877 | GList *child = m_list->children; | |
878 | int count = 0; | |
879 | for (child = m_list->children; child != NULL; child = child->next) | |
880 | { | |
881 | if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED) | |
882 | count++; | |
883 | } | |
884 | ||
885 | aSelections.Empty(); | |
886 | ||
887 | if (count > 0) | |
888 | { | |
889 | // now fill the list | |
890 | aSelections.Alloc(count); // optimization attempt | |
891 | int i = 0; | |
892 | for (child = m_list->children; child != NULL; child = child->next, i++) | |
893 | { | |
894 | if (GTK_WIDGET(child->data)->state == GTK_STATE_SELECTED) | |
895 | aSelections.Add(i); | |
896 | } | |
897 | } | |
898 | ||
899 | return count; | |
900 | } | |
901 | ||
902 | bool wxListBox::IsSelected( int n ) const | |
903 | { | |
904 | wxCHECK_MSG( m_list != NULL, false, wxT("invalid listbox") ); | |
905 | ||
906 | GList *target = g_list_nth( m_list->children, n ); | |
907 | ||
908 | wxCHECK_MSG( target, false, wxT("invalid listbox index") ); | |
909 | ||
910 | return (GTK_WIDGET(target->data)->state == GTK_STATE_SELECTED) ; | |
911 | } | |
912 | ||
913 | void wxListBox::DoSetSelection( int n, bool select ) | |
914 | { | |
915 | wxCHECK_RET( m_list != NULL, wxT("invalid listbox") ); | |
916 | ||
917 | m_blockEvent = true; | |
918 | ||
919 | if (select) | |
920 | { | |
921 | if ((m_windowStyle & wxLB_SINGLE) != 0) | |
922 | gtk_list_unselect_item( m_list, m_prevSelection ); | |
923 | gtk_list_select_item( m_list, n ); | |
924 | m_prevSelection = n; | |
925 | } | |
926 | else | |
927 | gtk_list_unselect_item( m_list, n ); | |
928 | ||
929 | m_blockEvent = false; | |
930 | } | |
931 | ||
932 | void wxListBox::DoSetFirstItem( int n ) | |
933 | { | |
934 | wxCHECK_RET( m_list, wxT("invalid listbox") ); | |
935 | ||
936 | if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (m_list)) | |
937 | return; | |
938 | ||
939 | // terribly efficient | |
940 | const gchar *vadjustment_key = "gtk-vadjustment"; | |
941 | guint vadjustment_key_id = g_quark_from_static_string (vadjustment_key); | |
942 | ||
943 | GtkAdjustment *adjustment = | |
944 | (GtkAdjustment*) gtk_object_get_data_by_id (GTK_OBJECT (m_list), vadjustment_key_id); | |
945 | wxCHECK_RET( adjustment, wxT("invalid listbox code") ); | |
946 | ||
947 | GList *target = g_list_nth( m_list->children, n ); | |
948 | wxCHECK_RET( target, wxT("invalid listbox index") ); | |
949 | ||
950 | GtkWidget *item = GTK_WIDGET(target->data); | |
951 | wxCHECK_RET( item, wxT("invalid listbox code") ); | |
952 | ||
953 | if (item->allocation.y == -1) | |
954 | { | |
955 | wxlistbox_idle_struct* data = new wxlistbox_idle_struct; | |
956 | data->m_listbox = this; | |
957 | data->m_item = n; | |
958 | data->m_tag = gtk_idle_add_priority( 800, wxlistbox_idle_callback, (gpointer) data ); | |
959 | ||
960 | return; | |
961 | } | |
962 | ||
963 | float y = item->allocation.y; | |
964 | if (y > adjustment->upper - adjustment->page_size) | |
965 | y = adjustment->upper - adjustment->page_size; | |
966 | gtk_adjustment_set_value( adjustment, y ); | |
967 | } | |
968 | ||
969 | // ---------------------------------------------------------------------------- | |
970 | // helpers | |
971 | // ---------------------------------------------------------------------------- | |
972 | ||
973 | int wxListBox::GtkGetIndex( GtkWidget *item ) const | |
974 | { | |
975 | if (item) | |
976 | { | |
977 | GList *child = m_list->children; | |
978 | int count = 0; | |
979 | while (child) | |
980 | { | |
981 | if (GTK_WIDGET(child->data) == item) return count; | |
982 | count++; | |
983 | child = child->next; | |
984 | } | |
985 | } | |
986 | return -1; | |
987 | } | |
988 | ||
989 | #if wxUSE_TOOLTIPS | |
990 | void wxListBox::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) | |
991 | { | |
992 | GList *child = m_list->children; | |
993 | while (child) | |
994 | { | |
995 | gtk_tooltips_set_tip( tips, GTK_WIDGET( child->data ), wxConvCurrent->cWX2MB(tip), NULL ); | |
996 | child = child->next; | |
997 | } | |
998 | } | |
999 | #endif // wxUSE_TOOLTIPS | |
1000 | ||
1001 | GtkWidget *wxListBox::GetConnectWidget() | |
1002 | { | |
1003 | // return GTK_WIDGET(m_list); | |
1004 | return m_widget; | |
1005 | } | |
1006 | ||
1007 | bool wxListBox::IsOwnGtkWindow( GdkWindow *window ) | |
1008 | { | |
1009 | return m_widget->window == window || | |
1010 | GTK_WIDGET(m_list)->window == window; | |
1011 | } | |
1012 | ||
1013 | void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style) | |
1014 | { | |
1015 | if (m_hasBgCol && m_backgroundColour.Ok()) | |
1016 | { | |
1017 | GdkWindow *window = GTK_WIDGET(m_list)->window; | |
1018 | if ( window ) | |
1019 | { | |
1020 | m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) ); | |
1021 | gdk_window_set_background( window, m_backgroundColour.GetColor() ); | |
1022 | gdk_window_clear( window ); | |
1023 | } | |
1024 | } | |
1025 | ||
1026 | GList *child = m_list->children; | |
1027 | while (child) | |
1028 | { | |
1029 | gtk_widget_modify_style( GTK_WIDGET(child->data), style ); | |
1030 | ||
1031 | GtkBin *bin = GTK_BIN( child->data ); | |
1032 | GtkWidget *label = GTK_WIDGET( bin->child ); | |
1033 | gtk_widget_modify_style( label, style ); | |
1034 | ||
1035 | child = child->next; | |
1036 | } | |
1037 | } | |
1038 | ||
1039 | void wxListBox::OnInternalIdle() | |
1040 | { | |
1041 | wxCursor cursor = m_cursor; | |
1042 | if (g_globalCursor.Ok()) cursor = g_globalCursor; | |
1043 | ||
1044 | if (GTK_WIDGET(m_list)->window && cursor.Ok()) | |
1045 | { | |
1046 | /* I now set the cursor the anew in every OnInternalIdle call | |
1047 | as setting the cursor in a parent window also effects the | |
1048 | windows above so that checking for the current cursor is | |
1049 | not possible. */ | |
1050 | ||
1051 | gdk_window_set_cursor( GTK_WIDGET(m_list)->window, cursor.GetCursor() ); | |
1052 | ||
1053 | GList *child = m_list->children; | |
1054 | while (child) | |
1055 | { | |
1056 | GtkBin *bin = GTK_BIN( child->data ); | |
1057 | GtkWidget *label = GTK_WIDGET( bin->child ); | |
1058 | ||
1059 | if (!label->window) | |
1060 | break; | |
1061 | else | |
1062 | gdk_window_set_cursor( label->window, cursor.GetCursor() ); | |
1063 | ||
1064 | child = child->next; | |
1065 | } | |
1066 | } | |
1067 | ||
1068 | if (g_delayedFocus == this) | |
1069 | { | |
1070 | if (GTK_WIDGET_REALIZED(m_widget)) | |
1071 | { | |
1072 | gtk_widget_grab_focus( m_widget ); | |
1073 | g_delayedFocus = NULL; | |
1074 | } | |
1075 | } | |
1076 | ||
1077 | if (wxUpdateUIEvent::CanUpdate(this)) | |
1078 | UpdateWindowUI(wxUPDATE_UI_FROMIDLE); | |
1079 | } | |
1080 | ||
1081 | wxSize wxListBox::DoGetBestSize() const | |
1082 | { | |
1083 | int lbWidth = 100; // some defaults | |
1084 | int lbHeight = 110; | |
1085 | int wLine; | |
1086 | ||
1087 | // Find the widest line | |
1088 | for(unsigned int i = 0; i < GetCount(); i++) { | |
1089 | wxString str(GetString(i)); | |
1090 | GetTextExtent(str, &wLine, NULL); | |
1091 | lbWidth = wxMax(lbWidth, wLine); | |
1092 | } | |
1093 | ||
1094 | // Add room for the scrollbar | |
1095 | lbWidth += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X); | |
1096 | ||
1097 | // And just a bit more | |
1098 | int cx, cy; | |
1099 | GetTextExtent( wxT("X"), &cx, &cy); | |
1100 | lbWidth += 3 * cx; | |
1101 | ||
1102 | // don't make the listbox too tall (limit height to around 10 items) but don't | |
1103 | // make it too small neither | |
1104 | lbHeight = (cy+4) * wxMin(wxMax(GetCount(), 3), 10); | |
1105 | ||
1106 | wxSize best(lbWidth, lbHeight); | |
1107 | CacheBestSize(best); | |
1108 | return best; | |
1109 | } | |
1110 | ||
1111 | void wxListBox::FixUpMouseEvent(GtkWidget *widget, wxCoord& x, wxCoord& y) | |
1112 | { | |
1113 | // the mouse event coords are relative to the listbox items, we need to | |
1114 | // translate them to the normal client coords | |
1115 | x += widget->allocation.x; | |
1116 | y += widget->allocation.y; | |
1117 | } | |
1118 | ||
1119 | ||
1120 | // static | |
1121 | wxVisualAttributes | |
1122 | wxListBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) | |
1123 | { | |
1124 | return GetDefaultAttributesFromGTKWidget(gtk_list_new, true); | |
1125 | } | |
1126 | ||
1127 | #endif // wxUSE_LISTBOX |