自学教程：C++ GTK_LIST函数代码示例

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);}

voidlayer_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 voidgb_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. */intclip_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. */intclip_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 voidlayer_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. */intclip_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. */intclip_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);}

static voidlayer_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);  }}

intclip_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. */intclip_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.*/intclip_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 gintgtk_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 voidgtkcombo_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. */intclip_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. */intclip_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. */intclip_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::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);}