void SetID3Genre(GripInfo *ginfo,int id3_genre)
{
GtkWidget *item;
item=
GTK_WIDGET(g_list_nth(ginfo->gui_info.id3_genre_item_list,
ID3GenrePos(id3_genre))->data);
gtk_list_select_child(GTK_LIST(GTK_COMBO(ginfo->gui_info.id3_genre_combo)->
list),item);
}
static void add_message(GtkWidget *list, const char *str, ...)
{
static int line = 0;
va_list ap;
char buf[BUFSIZ];
GList *items = NULL;
GtkWidget *item;
va_start(ap, str);
vsnprintf(buf, sizeof(buf), str, ap);
va_end(ap);
item = gtk_list_item_new_with_label(buf);
gtk_widget_show(item);
items = g_list_append(items, item);
gtk_list_append_items(GTK_LIST(list), items);
line++;
gtk_list_scroll_vertical(GTK_LIST(list), GTK_SCROLL_JUMP, 1.0);
}
void
layer_dialog_set_diagram(Diagram *dia)
{
DiagramData *data;
GtkWidget *layer_widget;
Layer *layer;
Layer *active_layer = NULL;
int sel_pos;
int i,j;
if (dia!=NULL)
active_layer = dia->data->active_layer;
if (layer_dialog == NULL || layer_dialog->dialog == NULL)
layer_dialog_create(); /* May have been destroyed */
g_assert(layer_dialog != NULL); /* must be valid now */
gtk_container_foreach (GTK_CONTAINER(layer_dialog->layer_list),
_layer_widget_clear_layer, NULL);
gtk_list_clear_items(GTK_LIST(layer_dialog->layer_list), 0, -1);
layer_dialog->diagram = dia;
if (dia != NULL) {
i = g_list_index(dia_open_diagrams(), dia);
if (i >= 0 && layer_dialog->diagram_omenu != NULL)
gtk_option_menu_set_history(GTK_OPTION_MENU(layer_dialog->diagram_omenu),
i);
}
if (dia != NULL) {
data = dia->data;
sel_pos = 0;
for (i=data->layers->len-1,j=0; i>=0; i--,j++) {
layer = (Layer *) g_ptr_array_index(data->layers, i);
layer_widget = dia_layer_widget_new(dia, layer);
gtk_widget_show(layer_widget);
gtk_container_add(GTK_CONTAINER(layer_dialog->layer_list), layer_widget);
if (layer==active_layer)
sel_pos = j;
}
gtk_list_select_item(GTK_LIST(layer_dialog->layer_list), sel_pos);
}
}
static int
_combo_simple_entry_change(GtkEntry * entry, gpointer data)
{
GtkCombo *cb = GTK_COMBO(data);
int i;
i = _combo_simple_find_in_list(cb, gtk_entry_get_text(entry));
if (i == -1)
gtk_list_unselect_all(GTK_LIST(cb->list));
else
{
gtk_signal_handler_block_by_func(GTK_OBJECT(cb->list), GSF(_combo_simple_list_select), data);
gtk_list_select_item(GTK_LIST(cb->list), i);
gtk_signal_handler_unblock_by_func(GTK_OBJECT(cb->list), GSF(_combo_simple_list_select), data);
}
return 0;
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_combo_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gboolean value_in_list, ok_if_empty, case_sensitive, arrows, arrows_always;
gchar *items;
GList *item_list = NULL;
value_in_list = gb_widget_input_bool (data, ValueInList);
if (data->apply)
{
gtk_object_set_data (GTK_OBJECT (widget), ValueInList,
value_in_list ? "TRUE" : NULL);
}
ok_if_empty = gb_widget_input_bool (data, OKIfEmpty);
if (data->apply)
{
gtk_object_set_data (GTK_OBJECT (widget), OKIfEmpty,
ok_if_empty ? "TRUE" : NULL);
}
case_sensitive = gb_widget_input_bool (data, Case);
if (data->apply)
gtk_combo_set_case_sensitive (GTK_COMBO (widget), case_sensitive);
arrows = gb_widget_input_bool (data, Arrows);
if (data->apply)
gtk_combo_set_use_arrows (GTK_COMBO (widget), arrows);
arrows_always = gb_widget_input_bool (data, Always);
if (data->apply)
gtk_combo_set_use_arrows_always (GTK_COMBO (widget), arrows_always);
items = gb_widget_input_text (data, Items);
if (data->apply)
{
gchar *pos = items;
gchar *items_end = &items[strlen (items)];
while (pos < items_end)
{
gchar *item_end = strchr (pos, '\n');
if (item_end == NULL)
item_end = items_end;
*item_end = '\0';
item_list = g_list_append (item_list, pos);
pos = item_end + 1;
}
if (item_list)
gtk_combo_set_popdown_strings (GTK_COMBO (widget), item_list);
else
gtk_list_clear_items (GTK_LIST (GTK_COMBO (widget)->list), 0, -1);
g_list_free (item_list);
}
if (data->action == GB_APPLYING)
g_free (items);
}
int wxComboBox::DoInsert(const wxString &item, unsigned int pos)
{
wxCHECK_MSG( !(GetWindowStyle() & wxCB_SORT), -1,
wxT("can't insert into sorted list"));
wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid combobox") );
wxCHECK_MSG( IsValidInsert(pos), -1, wxT("invalid index") );
unsigned int count = GetCount();
if (pos == count)
return Append(item);
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
gtk_combo_box_insert_text( combobox, pos, wxGTK_CONV( item ) );
}
else
#endif
{
DisableEvents();
GtkWidget *list = GTK_COMBO(m_widget)->list;
GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( item ) );
GList *gitem_list = g_list_alloc ();
gitem_list->data = list_item;
gtk_list_insert_items( GTK_LIST (list), gitem_list, pos );
if (GTK_WIDGET_REALIZED(m_widget))
{
gtk_widget_realize( list_item );
gtk_widget_realize( GTK_BIN(list_item)->child );
ApplyWidgetStyle();
}
gtk_widget_show( list_item );
EnableEvents();
}
count = GetCount();
if ( m_clientDataList.GetCount() < count )
m_clientDataList.Insert( pos, (wxObject*) NULL );
if ( m_clientObjectList.GetCount() < count )
m_clientObjectList.Insert( pos, (wxObject*) NULL );
InvalidateBestSize();
return pos;
}
/* Toggles the focus row. If the focus row is selected, it's unselected.
* If the focus row is unselected, it's selected. If the selection mode of
* list is GTK_SELECTION_BROWSE, this has no effect, as the selection is
* always at the focus row. */
int
clip_GTK_LISTTOGGLEFOCUSROW(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
CHECKCWID(clst, GTK_IS_LIST);
gtk_list_toggle_focus_row(GTK_LIST(clst->widget));
return 0;
err:
return 1;
}
/* Unselects all children of list. A signal will
* be emitted for each newly unselected child. */
int
clip_GTK_LISTUNSELECTALL(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
CHECKCWID(clst, GTK_IS_LIST);
gtk_list_unselect_all(GTK_LIST(clst->widget));
return 0;
err:
return 1;
}
static void okButton_clicked( GtkWidget *widget, void *data )
{
gtk_widget_hide( microcodeWindow );
if (GTK_LIST(microcodeList)->selection != 0)
{
char *text = 0;
GtkListItem *item = GTK_LIST_ITEM(GTK_LIST(microcodeList)->selection->data);
GtkLabel *label = GTK_LABEL(GTK_BIN(item)->child);
gtk_label_get( label, &text );
if (text != 0)
for (int i = 0; i < numMicrocodeTypes; i++)
if (!strcmp( text, MicrocodeTypes[i] ))
{
selectedMicrocode = i;
return;
}
}
selectedMicrocode = NONE;
}
static void
layer_dialog_rename_callback(GtkWidget *widget, gpointer gdata)
{
GtkWidget *selected;
Diagram *dia;
Layer *layer;
dia = layer_dialog->diagram;
selected = GTK_LIST(layer_dialog->layer_list)->selection->data;
layer = dia->data->active_layer;
layer_dialog_edit_layer (DIA_LAYER_WIDGET (selected), dia, layer);
}
/* Toggles between adding to the selection and beginning a new selection.
* Only in GTK_SELECTION_EXTENDED. Useful with gtk_list_extend_selection. */
int
clip_GTK_LISTTOGGLEADDMODE(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
CHECKCWID(clst, GTK_IS_LIST);
gtk_list_toggle_add_mode(GTK_LIST(clst->widget));
return 0;
err:
return 1;
}
unsigned int wxComboBox::GetCount() const
{
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid combobox") );
GtkWidget *list = GTK_COMBO(m_widget)->list;
GList *child = GTK_LIST(list)->children;
unsigned int count = 0;
while (child) { count++; child = child->next; }
return count;
}
/* Stops the drag selection mode and ungrabs the pointer.
* This has no effect if a drag selection is not active. */
int
clip_GTK_LISTENDDRAGSELECTION(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
CHECKCWID(clst, GTK_IS_LIST);
gtk_list_end_drag_selection(GTK_LIST(clst->widget));
return 0;
err:
return 1;
}
void UponBuiltinLibOptionsRemoveButtonClicked (GtkWidget * dialogue)
{
GtkList *sourceList = GTK_LIST (gtk_object_get_data (GTK_OBJECT (dialogue), "SourceList"));
GList *selection = sourceList->selection;
if (!selection)
return;
GList *copy = g_list_copy (selection);
gtk_list_remove_items (sourceList, copy);
g_list_free (copy);
}
int wxComboBox::GetCurrentSelection() const
{
wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid combobox") );
GtkWidget *list = GTK_COMBO(m_widget)->list;
GList *selection = GTK_LIST(list)->selection;
if (selection)
{
GList *child = GTK_LIST(list)->children;
int count = 0;
while (child)
{
if (child->data == selection->data) return count;
count++;
child = child->next;
}
}
return wxNOT_FOUND;
}
static void
layer_dialog_new_callback(GtkWidget *widget, gpointer gdata)
{
Layer *layer;
Diagram *dia;
GtkWidget *selected;
GList *list = NULL;
GtkWidget *layer_widget;
int pos;
static int next_layer_num = 1;
dia = layer_dialog->diagram;
if (dia != NULL) {
gchar* new_layer_name = g_strdup_printf(_("New layer %d"),
next_layer_num++);
layer = new_layer(new_layer_name, dia->data);
assert(GTK_LIST(layer_dialog->layer_list)->selection != NULL);
selected = GTK_LIST(layer_dialog->layer_list)->selection->data;
pos = gtk_list_child_position(GTK_LIST(layer_dialog->layer_list), selected);
data_add_layer_at(dia->data, layer, dia->data->layers->len - pos);
diagram_add_update_all(dia);
diagram_flush(dia);
layer_widget = dia_layer_widget_new(dia, layer);
gtk_widget_show(layer_widget);
list = g_list_prepend(list, layer_widget);
gtk_list_insert_items(GTK_LIST(layer_dialog->layer_list), list, pos);
gtk_list_select_item(GTK_LIST(layer_dialog->layer_list), pos);
undo_layer(dia, layer, TYPE_ADD_LAYER, dia->data->layers->len - pos);
undo_set_transactionpoint(dia->undo);
}
}
int wxComboBox::FindString( const wxString &item, bool bCase ) const
{
wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid combobox") );
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
GtkTreeModel* model = gtk_combo_box_get_model( combobox );
GtkTreeIter iter;
gtk_tree_model_get_iter_first( model, &iter );
if (!gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter ))
return -1;
int count = 0;
do
{
GValue value = { 0, };
gtk_tree_model_get_value( model, &iter, 0, &value );
wxString str = wxGTK_CONV_BACK( g_value_get_string( &value ) );
g_value_unset( &value );
if (item.IsSameAs( str, bCase ) )
return count;
count++;
} while (gtk_tree_model_iter_next( model, &iter ));
}
else
#endif
{
GtkWidget *list = GTK_COMBO(m_widget)->list;
GList *child = GTK_LIST(list)->children;
int count = 0;
while (child)
{
GtkBin *bin = GTK_BIN( child->data );
GtkLabel *label = GTK_LABEL( bin->child );
wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) );
if (item.IsSameAs( str , bCase ) )
return count;
count++;
child = child->next;
}
}
return wxNOT_FOUND;
}
int
clip_GTK_COMBOSETPOPDOWNSTRINGS(ClipMachine * ClipMachineMemory)
{
C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory);
ClipArrVar *astr = (ClipArrVar *) _clip_vptr(_clip_spar(ClipMachineMemory, 2));
GList *str_list = NULL;
ClipStrVar *s;
int i;
CHECKCWID(ccmb, GTK_IS_COMBO);
CHECKOPT(2, ARRAY_type_of_ClipVarType);
for (i = 0; i < astr->count_of_ClipArrVar; i++)
{
if (astr->ClipVar_items_of_ClipArrVar[i].ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType !=
CHARACTER_type_of_ClipVarType)
continue;
s = (ClipStrVar *) _clip_vptr(&astr->ClipVar_items_of_ClipArrVar[i]);
if (ccmb->objtype == GTK_WIDGET_COMBO_SIMPLE)
str_list = g_list_append(str_list, gtk_list_item_new_with_label(s->ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf));
else
str_list = g_list_append(str_list, s->ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf);
}
if (ccmb->objtype == GTK_WIDGET_COMBO_SIMPLE)
{
gtk_list_clear_items(GTK_LIST(GTK_COMBO(ccmb->widget)->list), 0, -1);
gtk_list_append_items(GTK_LIST(GTK_COMBO(ccmb->widget)->list), str_list);
}
else
gtk_combo_set_popdown_strings(GTK_COMBO(ccmb->widget), str_list);
return 0;
err:
return 1;
}
void wxComboBox::SetSelection( int n )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
DisableEvents();
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
gtk_combo_box_set_active( combobox, n );
}
else
#endif
{
GtkWidget *list = GTK_COMBO(m_widget)->list;
gtk_list_unselect_item( GTK_LIST(list), m_prevSelection );
gtk_list_select_item( GTK_LIST(list), n );
m_prevSelection = n;
}
EnableEvents();
}
/* Unselects the child number item of the list. Nothing happens if item
* is out of bounds. The signal GtkList::unselect-child will be emitted. */
int
clip_GTK_LISTUNSELECTITEM(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
gint item = INT_OPTION(ClipMachineMemory, 2, 1);
CHECKCWID(clst, GTK_IS_LIST);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_list_unselect_item(GTK_LIST(clst->widget), item - 1);
return 0;
err:
return 1;
}
gboolean BuiltinLibOptionsNewButtonClicked_callback (char *filename, gpointer userData)
{
if (!filename || !*filename)
return TRUE;
GtkWidget *dialogue = GTK_WIDGET (userData);
GtkList *sourceList = GTK_LIST (gtk_object_get_data (GTK_OBJECT (dialogue), "SourceList"));
char *relativeFilename = ImportPaths_ConvertFileToRelative (filename);
GList *itemsStr = g_list_prepend (NULL, relativeFilename);
GList *items = MakeListItemListFromStringList (itemsStr);
gtk_list_append_items (sourceList, items);
return TRUE; /* destroy dialogue */
}
/*
Set the list selection mode. The selection mode can be any value in GtkSelectionMode:
GTK_SELECTION_SINGLE
Zero or one element may be selected.
GTK_SELECTION_BROWSE
Exactly one element is always selected (this can be false after you have changed the selection mode).
GTK_SELECTION_MULTIPLE
Any number of elements may be selected. Clicks toggle the state of an item.
GTK_SELECTION_EXTENDED
Any number of elements may be selected. Click-drag selects a range of elements; the Ctrl key may be used to enlarge the
selection, and Shift key to select between the focus and the child pointed to.
*/
int
clip_GTK_LISTSETSELECTIONMODE(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
GtkSelectionMode mode = _clip_parni(ClipMachineMemory, 2);
CHECKCWID(clst, GTK_IS_LIST);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_list_set_selection_mode(GTK_LIST(clst->widget), mode);
return 0;
err:
return 1;
}
static gint
gtk_listbox_button_press_callback( GtkWidget *widget,
GdkEventButton *gdk_event,
wxListBox *listbox )
{
if (g_isIdle) wxapp_install_idle_handler();
if (g_blockEventsOnDrag) return FALSE;
if (g_blockEventsOnScroll) return FALSE;
if (!listbox->m_hasVMT) return FALSE;
int sel = listbox->GtkGetIndex( widget );
#if wxUSE_CHECKLISTBOX
if ((listbox->m_hasCheckBoxes) && (gdk_event->x < 15) && (gdk_event->type != GDK_2BUTTON_PRESS))
{
wxCheckListBox *clb = (wxCheckListBox *)listbox;
clb->Check( sel, !clb->IsChecked(sel) );
wxCommandEvent event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() );
event.SetEventObject( listbox );
event.SetInt( sel );
listbox->GetEventHandler()->ProcessEvent( event );
}
#endif // wxUSE_CHECKLISTBOX
if ((gdk_event->state == 0) &&
(((listbox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0) ||
((listbox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)) )
{
listbox->m_blockEvent = true;
int i;
for (i = 0; i < (int)listbox->GetCount(); i++)
if (i != sel)
gtk_list_unselect_item( GTK_LIST(listbox->m_list), i );
listbox->m_blockEvent = false;
return false;
}
/* emit wxEVT_COMMAND_LISTBOX_DOUBLECLICKED later */
g_hasDoubleClicked = (gdk_event->type == GDK_2BUTTON_PRESS);
return FALSE;
}
static void
gtkcombo_combo_select_child_callback( GtkList *WXUNUSED(list), GtkWidget *WXUNUSED(widget), wxComboBox *combo )
{
if (g_isIdle) wxapp_install_idle_handler();
if (!combo->m_hasVMT) return;
if (g_blockEventsOnDrag) return;
int curSelection = combo->GetCurrentSelection();
if (combo->m_prevSelection == curSelection) return;
GtkWidget *list = GTK_COMBO(combo->m_widget)->list;
gtk_list_unselect_item( GTK_LIST(list), combo->m_prevSelection );
combo->m_prevSelection = curSelection;
// Quickly set the value of the combo box
// as GTK+ does that only AFTER the event
// is sent.
g_signal_handlers_disconnect_by_func (GTK_COMBO (combo->GetHandle())->entry,
(gpointer) gtkcombo_text_changed_callback,
combo);
combo->SetValue( combo->GetStringSelection() );
g_signal_connect_after (GTK_COMBO (combo->GetHandle())->entry, "changed",
G_CALLBACK (gtkcombo_text_changed_callback), combo);
// throw a SELECTED event only if the combobox popup is hidden (wxID_NONE)
// because when combobox popup is shown, gtkcombo_combo_select_child_callback is
// called each times the mouse is over an item with a pressed button so a lot
// of SELECTED event could be generated if the user keep the mouse button down
// and select other items ...
if (g_SelectionBeforePopup == wxID_NONE)
{
wxCommandEvent event( wxEVT_COMMAND_COMBOBOX_SELECTED, combo->GetId() );
event.SetInt( curSelection );
event.SetString( combo->GetStringSelection() );
event.SetEventObject( combo );
combo->GetEventHandler()->ProcessEvent( event );
// for consistency with the other ports, don't generate text update
// events while the user is browsing the combobox neither
wxCommandEvent event2( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
event2.SetString( combo->GetValue() );
event2.SetEventObject( combo );
combo->GetEventHandler()->ProcessEvent( event2 );
}
}
/* Unselects the given child. The signal GtkList::unselect-child will be emitted. */
int
clip_GTK_LISTUNSELECTCHILD(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
C_widget *cchild = CWIDGET_ARG(ClipMachineMemory, 2);
CHECKCWID(clst, GTK_IS_LIST);
CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWID(cchild, GTK_IS_LIST_ITEM);
gtk_list_unselect_child(GTK_LIST(clst->widget), cchild->widget);
return 0;
err:
return 1;
}
/* Toggles the child item of list. If the selection mode of list is
* GTK_SELECTION_BROWSE, the item is selected, and the others are unselected. */
int
clip_GTK_LISTTOGGLEROW(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
C_widget *citem = CWIDGET_ARG(ClipMachineMemory, 2);
CHECKCWID(clst, GTK_IS_LIST);
CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWID(citem, GTK_IS_LIST_ITEM);
gtk_list_toggle_row(GTK_LIST(clst->widget), citem->widget);
return 0;
err:
return 1;
}
/* Searches the children of list for the index of child. */
int
clip_GTK_LISTCHILDPOSITION(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
C_widget *cchild = CWIDGET_ARG(ClipMachineMemory, 2);
CHECKCWID(clst, GTK_IS_LIST);
CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWID(cchild, GTK_IS_LIST_ITEM);
_clip_retni(ClipMachineMemory, gtk_list_child_position(GTK_LIST(clst->widget), cchild->widget));
return 0;
err:
return 1;
}
void wxComboBox::Delete(unsigned int n)
{
wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
wxCHECK_RET( IsValid(n), wxT("invalid index") );
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
gtk_combo_box_remove_text( combobox, n );
}
else
#endif
{
GtkList *listbox = GTK_LIST( GTK_COMBO(m_widget)->list );
GList *child = g_list_nth( listbox->children, n );
if (!child)
{
wxFAIL_MSG(wxT("wrong index"));
return;
}
DisableEvents();
GList *list = g_list_append( (GList*) NULL, child->data );
gtk_list_remove_items( listbox, list );
g_list_free( list );
EnableEvents();
}
wxList::compatibility_iterator node = m_clientObjectList.Item( n );
if (node)
{
wxClientData *cd = (wxClientData*)node->GetData();
if (cd) delete cd;
m_clientObjectList.Erase( node );
}
node = m_clientDataList.Item( n );
if (node)
m_clientDataList.Erase( node );
InvalidateBestSize();
}
void wxComboBox::DoClear()
{
wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
DisableEvents();
GtkWidget *list = GTK_COMBO(m_widget)->list;
gtk_list_clear_items( GTK_LIST(list), 0, (int)GetCount() );
m_clientObjectList.Clear();
m_clientDataList.Clear();
EnableEvents();
InvalidateBestSize();
}
void sigh_print_selection(GtkWidget *gtklist, struttura *str)
{
int revert,keycode;
if (str->tp.luncodicet9==0) return;
XGetInputFocus(str->display, &str->win,&revert);
GList *dlist;
GtkWidget *child;
gtk_widget_set_usize(str->tp.scrolled_window, 0,S_W_MAIN);
// Fetch the doubly linked list of selected items of the List, remember to treat this as read-only!
//g_print("Selection\n");
dlist=GTK_LIST(gtklist)->selection;
//g_print("Selection 1\n");
// Individuiamo l'elemento che ha emesso il segnale e calcoliamo la sua posizione all'interno della lista
child=gtk_container_get_focus_child(GTK_CONTAINER(gtklist));
str->tp.indice=gtk_list_child_position((GtkList *)gtklist,child);
//g_print("Selection 2\n");
int dim_parola = strlen(str->tp.vetparole[str->tp.indice].parola);
//g_print("Selection 3\n");
// If there are no selected items there is nothing more to do than just telling the user so
if(!dlist){
//g_print("Selection cleared\n");
return;
}
//g_print("Selection 4\n");
// Ok, we got a selection and so we print itbacca
for (int i=0; i < dim_parola;i++)
{
sendtofocus(str,(int)str->tp.vetparole[str->tp.indice].parola[i]);
}
char query[200];
bzero (query,200);
sprintf (query, "update globale set frequenza=frequenza+1 where parola =\'%s\';",str->tp.vetparole[str->tp.indice].parola);
//printf("\n%s\n",query);
if (sqlite3_exec(str->tp.db,query,0,0,0))
fprintf(stderr,"error : programm %s ,function sigh_print_selection(..) sqlite3_exec return error\n ",NameProgramm);
gtk_list_clear_items ((GtkList *) gtklist,0,N);
str->tp.luncodicet9 = 0;
bzero(str->tp.codicet9,LEN_WORD_DB+1);
gdk_window_process_all_updates ();
//XCloseDisplay(display);
}
