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

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