//__________________________________________________________________
void _HYPlatformPullDown::_AddMenuItem (_String& newItem, long index)
{
if (theMenu) {
GList * singleItem = g_list_alloc();
singleItem->prev = singleItem->next = nil;
if (newItem.Equal(&menuSeparator)) {
GtkWidget * itemContents = gtk_separator_menu_item_new ();
gtk_widget_show (itemContents);
singleItem->data = gtk_list_item_new();
gtk_container_add((GtkContainer*)singleItem->data,itemContents);
gtk_combo_set_item_string (GTK_COMBO (theMenu), GTK_ITEM (singleItem->data), "");
gtk_widget_set_sensitive((GtkWidget*)singleItem->data,false);
widgetList.InsertElement ((BaseRef)itemContents,2*index,false,false);
} else {
_String inItem = newItem;
if (newItem.beginswith ("(")) {
inItem.Trim (1,-1);
}
GtkWidget * itemContents = gtk_menu_item_new_with_label (inItem.sData);
gtk_widget_show (itemContents);
singleItem->data = gtk_list_item_new();
gtk_container_add((GtkContainer*)singleItem->data,itemContents);
gtk_combo_set_item_string (GTK_COMBO (theMenu), GTK_ITEM (singleItem->data), inItem.sData);
gtk_widget_set_sensitive((GtkWidget*)singleItem->data,inItem.sLength == newItem.sLength);
widgetList.InsertElement ((BaseRef)itemContents,2*index,false,false);
}
widgetList.InsertElement ((BaseRef)singleItem->data,2*index,false,false);
GdkColor convColor = HYColorToGDKColor(_hyGTKMenuBackground);
gtk_widget_modify_bg ((GtkWidget*)singleItem->data, GTK_STATE_INSENSITIVE,
&convColor);
gtk_widget_show ((GtkWidget*)singleItem->data);
if (index<0) {
gtk_list_append_items (GTK_LIST (GTK_COMBO (theMenu)->list), singleItem);
} else {
gtk_list_insert_items (GTK_LIST (GTK_COMBO (theMenu)->list), singleItem, index);
}
/*printf ("\nAdding menu item %s at %d\n", newItem.sData, index);
for (long k = 0; k<widgetList.lLength; k++)
printf ("%d %s\n", k, GTK_OBJECT_TYPE_NAME (GTK_WIDGET (widgetList(k))));*/
}
if (((_HYPullDown*)this)->MenuItemCount()==1||selection==index) {
cbSelection = -1;
_RefreshComboBox();
}
}
/**** LIST ITEM constructor ****/
int
clip_GTK_LISTITEMNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
C_widget *cchild;
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1,MAP_t);
CHECKOPT3(2,CHARACTER_t,MAP_t,NUMERIC_t);
switch (_clip_parinfo(cm,2))
{
case CHARACTER_t:
wid = gtk_list_item_new_with_label(_clip_parc(cm,2));
break;
case MAP_t:
case NUMERIC_t:
wid = gtk_list_item_new();
cchild = _fetch_cwidget(cm,_clip_spar(cm,2));
CHECKCWID(cchild,GTK_IS_WIDGET);
gtk_container_add(GTK_CONTAINER(wid), cchild->widget);
break;
}
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
void
gmdb_form_add_icon(gchar *text)
{
GList *glist = NULL;
GtkWidget *li;
GtkWidget *label;
GtkWidget *box;
GtkWidget *pixmapwid;
GdkPixmap *pixmap;
GdkBitmap *mask;
li = gtk_list_item_new ();
box = gtk_hbox_new (FALSE,5);
pixmap = gdk_pixmap_colormap_create_from_xpm( NULL,
gtk_widget_get_colormap(app), &mask, NULL, "table.xpm");
/* a pixmap widget to contain the pixmap */
pixmapwid = gtk_pixmap_new( pixmap, mask );
gtk_widget_show( pixmapwid );
gtk_box_pack_start (GTK_BOX (box), pixmapwid, FALSE, TRUE, 0);
label = gtk_label_new (text);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(li), box);
glist = g_list_append (glist, li);
gtk_widget_show (label);
gtk_widget_show_all (li);
gtk_hlist_append_items(GTK_HLIST(form_hlist), glist);
}
/*
* Creates a new GtkWidget of class GtkListItem, performing any specialized
* initialization needed for the widget to work correctly in this environment.
* If a dialog box is used to initialize the widget, return NULL from this
* function, and call data->callback with your new widget when it is done.
* If the widget needs a special destroy handler, add a signal here.
*/
GtkWidget *
gb_list_item_new (GbWidgetNewData * data)
{
GtkWidget *new_widget;
if (data->action == GB_CREATING)
new_widget = gtk_list_item_new_with_label (data->name);
else
{
new_widget = gtk_list_item_new ();
gtk_container_add (GTK_CONTAINER (new_widget), editor_new_placeholder());
}
return new_widget;
}
gint main( int argc,
gchar *argv[] )
{
GtkWidget *separator;
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *scrolled_window;
GtkWidget *frame;
GtkWidget *gtklist;
GtkWidget *button;
GtkWidget *list_item;
GList *dlist;
guint i;
gchar buffer[64];
/* Initialize GTK (and subsequently GDK) */
gtk_init(&argc, &argv);
/* Create a window to put all the widgets in
* connect gtk_main_quit() to the "destroy" event of
* the window to handle window manager close-window-events
*/
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkList Example");
gtk_signal_connect(GTK_OBJECT(window),
"destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
/* Inside the window we need a box to arrange the widgets
* vertically */
vbox=gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
/* This is the scrolled window to put the List widget inside */
scrolled_window=gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_usize(scrolled_window, 250, 150);
gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
gtk_widget_show(scrolled_window);
/* Create thekList widget.
* Connect the sigh_print_selection() signal handler
* function to the "selection_changed" signal of the List
* to print out the selected items each time the selection
* has changed */
gtklist=gtk_list_new();
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(scrolled_window),
gtklist);
gtk_widget_show(gtklist);
gtk_signal_connect(GTK_OBJECT(gtklist),
"selection_changed",
GTK_SIGNAL_FUNC(sigh_print_selection),
NULL);
/* We create a "Prison" to put a list item in ;) */
frame=gtk_frame_new("Prison");
gtk_widget_set_usize(frame, 200, 50);
gtk_container_set_border_width(GTK_CONTAINER(frame), 5);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(vbox), frame);
gtk_widget_show(frame);
/* Connect the sigh_button_event() signal handler to the List
* which will handle the "arresting" of list items
*/
gtk_signal_connect(GTK_OBJECT(gtklist),
"button_release_event",
GTK_SIGNAL_FUNC(sigh_button_event),
frame);
/* Create a separator */
separator=gtk_hseparator_new();
gtk_container_add(GTK_CONTAINER(vbox), separator);
gtk_widget_show(separator);
/* Finally create a button and connect its "clicked" signal
* to the destruction of the window */
button=gtk_button_new_with_label("Close");
gtk_container_add(GTK_CONTAINER(vbox), button);
gtk_widget_show(button);
gtk_signal_connect_object(GTK_OBJECT(button),
"clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(window));
/* Now we create 5 list items, each having its own
* label and add them to the List using gtk_container_add()
* Also we query the text string from the label and
* associate it with the list_item_data_key for each list item
*/
for (i=0; i<5; i++) {
GtkWidget *label;
gchar *string;
sprintf(buffer, "ListItemContainer with Label #%d", i);
label=gtk_label_new(buffer);
list_item=gtk_list_item_new();
gtk_container_add(GTK_CONTAINER(list_item), label);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(gtklist), list_item);
gtk_widget_show(list_item);
gtk_label_get(GTK_LABEL(label), &string);
gtk_object_set_data(GTK_OBJECT(list_item),
list_item_data_key,
string);
}
/* Here, we are creating another 5 labels, this time
* we use gtk_list_item_new_with_label() for the creation
* we can't query the text string from the label because
* we don't have the labels pointer and therefore
* we just associate the list_item_data_key of each
* list item with the same text string.
* For adding of the list items we put them all into a doubly
* linked list (GList), and then add them by a single call to
* gtk_list_append_items().
* Because we use g_list_prepend() to put the items into the
* doubly linked list, their order will be descending (instead
* of ascending when using g_list_append())
*/
dlist=NULL;
for (; i<10; i++) {
sprintf(buffer, "List Item with Label %d", i);
list_item=gtk_list_item_new_with_label(buffer);
dlist=g_list_prepend(dlist, list_item);
gtk_widget_show(list_item);
gtk_object_set_data(GTK_OBJECT(list_item),
list_item_data_key,
"ListItem with integrated Label");
}
gtk_list_append_items(GTK_LIST(gtklist), dlist);
/* Finally we want to see the window, don't we? ;) */
gtk_widget_show(window);
/* Fire up the main event loop of gtk */
gtk_main();
/* We get here after gtk_main_quit() has been called which
* happens if the main window gets destroyed
*/
return(0);
}
void
gb_label_get_standard_properties (GtkWidget * widget,
GbWidgetGetArgData * data,
const char *label_p,
const char *use_underline_p,
const char *use_markup_p,
const char *justify_p,
const char *wrap_p,
const char *selectable_p,
const char *xalign_p,
const char *yalign_p,
const char *xpad_p,
const char *ypad_p,
const char *focus_target_p)
{
const gchar *label_text;
gint i;
label_text = gtk_label_get_label (GTK_LABEL (widget));
gb_widget_output_translatable_text (data, label_p, label_text);
gb_widget_output_bool (data, use_underline_p,
gtk_label_get_use_underline (GTK_LABEL (widget)));
gb_widget_output_bool (data, use_markup_p,
GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), use_markup_p)));
for (i = 0; i < sizeof (GbJustifyValues) / sizeof (GbJustifyValues[0]); i++)
{
if (GbJustifyValues[i] == GTK_LABEL (widget)->jtype)
gb_widget_output_choice (data, justify_p, i, GbJustifySymbols[i]);
}
gb_widget_output_bool (data, wrap_p, GTK_LABEL (widget)->wrap);
gb_widget_output_bool (data, selectable_p,
gtk_label_get_selectable (GTK_LABEL (widget)));
gb_widget_output_float (data, xalign_p, GTK_MISC (widget)->xalign);
gb_widget_output_float (data, yalign_p, GTK_MISC (widget)->yalign);
gb_widget_output_int (data, xpad_p, GTK_MISC (widget)->xpad);
gb_widget_output_int (data, ypad_p, GTK_MISC (widget)->ypad);
/* Labels not in buttons may have a focus target widget. */
if (!gb_label_find_mnemonic_widget (widget))
{
gchar *accel_target;
accel_target = gtk_object_get_data (GTK_OBJECT (widget), focus_target_p);
/* If we're showing we need to display the list of possible focus target
widgets. We walk the tree of widgets in this component, and if a
widget has CAN_FOCUS set, we add it to the list. */
if (data->action == GB_SHOWING)
{
GList *focus_targets = NULL, *standard_items = NULL;
GtkWidget *item, *combo;
property_set_visible (focus_target_p, TRUE);
gb_label_get_focus_targets (gtk_widget_get_toplevel (widget),
&focus_targets);
property_set_combo_strings (focus_target_p, focus_targets);
g_list_free (focus_targets);
combo = property_get_value_widget (focus_target_p);
item = gtk_list_item_new_with_label (_("Auto"));
gtk_widget_show (item);
standard_items = g_list_append (standard_items, item);
item = gtk_list_item_new ();
gtk_widget_set_sensitive (item, FALSE);
gtk_widget_show (item);
standard_items = g_list_append (standard_items, item);
gtk_combo_set_item_string (GTK_COMBO (combo), GTK_ITEM (item), "");
gtk_list_prepend_items (GTK_LIST (GTK_COMBO (combo)->list),
standard_items);
if (!accel_target)
{
accel_target = _("Auto");
}
gb_widget_output_combo (data, focus_target_p, accel_target);
}
else
{
/* When saving, we only save the property if it has been set. */
if (accel_target)
{
/* First check that the widget is still there, and if it isn't
just skip it. */
if (glade_util_find_widget (gtk_widget_get_toplevel (widget),
accel_target))
{
gb_widget_output_combo (data, focus_target_p, accel_target);
}
}
else
{
/* If no target has been set, and the label has an underlined
key, we try to find a default target and save that. */
if (gtk_label_get_use_underline (GTK_LABEL (widget)))
{
GtkWidget *accel_target;
accel_target = glade_util_find_default_accelerator_target (widget);
if (accel_target)
{
gb_widget_output_string (data, focus_target_p, gtk_widget_get_name (accel_target));
}
}
}
}
}
else
{
if (data->action == GB_SHOWING)
{
property_set_visible (focus_target_p, FALSE);
}
}
}
GtkWidget *scripts_config_page () {
GtkWidget *page_vbox;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *gtklist=NULL;
GtkWidget *scrollwin=NULL;
GtkWidget *games_hbox;
unsigned i = 0;
GList* s;
page_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (page_vbox), 8);
games_hbox = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (games_hbox), 0);
gtk_box_pack_start (GTK_BOX (page_vbox), games_hbox, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtklist = gtk_list_new ();
gtk_widget_set_usize (gtklist, 136, -1);
// gtk_container_add (GTK_CONTAINER (scrollwin), gtklist);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollwin), gtklist);
gtk_container_add (GTK_CONTAINER (frame), scrollwin);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
button = gtk_button_new_with_label(_("Install ..."));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button),
"clicked", G_CALLBACK(install_button_callback), NULL);
#if have_time_to_implement_that
button = gtk_button_new_with_label(_("Remove"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
#endif
gtk_box_pack_start (GTK_BOX (games_hbox), vbox, FALSE, FALSE, 0);
notebook = gtk_notebook_new ();
// the tabs are hidden, so nobody will notice its a notebook
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
gtk_box_pack_start (GTK_BOX (games_hbox), notebook, FALSE, FALSE, 15);
for (s = scripts; s; s = g_list_next(s), ++i) {
const char* filename = s->data;
GtkWidget *page;
GtkWidget* item;
Script* script;
script = g_datalist_get_data(&scriptdata, filename);
item = gtk_list_item_new();
if (s == scripts) {
gtk_list_item_select(GTK_LIST_ITEM(item));
}
gtk_container_add (GTK_CONTAINER (item), gtk_label_new(filename));
gtk_signal_connect (GTK_OBJECT (item), "select",
GTK_SIGNAL_FUNC(scripts_page_select_callback), GINT_TO_POINTER(i));
gtk_widget_show_all(item);
gtk_container_add (GTK_CONTAINER (gtklist), item);
label = gtk_label_new (filename);
if (script) {
page = generic_script_frame(filename, script);
gtk_object_set_data_full (GTK_OBJECT (notebook), filename, script,
(GtkDestroyNotify) unref_option_widgets);
}
else {
page = gtk_label_new(_("Invalid script"));
gtk_widget_show(page);
}
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label);
}
gtk_widget_show_all (page_vbox);
return page_vbox;
}
/* Inserts items at the beginning of the list. */
int
clip_GTK_LISTPREPENDITEMS(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
ClipVar *cv = _clip_spar(ClipMachineMemory, 2);
GList *items = NULL;
CHECKCWID(clst, GTK_IS_LIST);
CHECKARG4(2, ARRAY_type_of_ClipVarType, CHARACTER_type_of_ClipVarType, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
switch (cv->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType)
{
case CHARACTER_type_of_ClipVarType:
items =
g_list_append(items,
gtk_list_item_new_with_label(cv->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf));
break;
case MAP_type_of_ClipVarType:
case NUMERIC_type_of_ClipVarType:
{
C_widget *citem = _fetch_cwidget(ClipMachineMemory, cv);
CHECKCWID(citem, GTK_IS_WIDGET);
if (GTK_IS_LIST_ITEM(citem->widget))
items = g_list_append(items, citem->widget);
else
{
GtkWidget *item = gtk_list_item_new();
gtk_container_add(GTK_CONTAINER(item), citem->widget);
items = g_list_append(items, item);
}
break;
}
case ARRAY_type_of_ClipVarType:
{
C_widget *citem;
GtkWidget *item;
int i;
for (i = 0; i < cv->ClipArrVar_a_of_ClipVar.count_of_ClipArrVar; i++)
{
switch (cv->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar[i].ClipType_t_of_ClipVar.
ClipVartype_type_of_ClipType)
{
case CHARACTER_type_of_ClipVarType:
items =
g_list_append(items,
gtk_list_item_new_with_label(cv->ClipArrVar_a_of_ClipVar.
ClipVar_items_of_ClipArrVar[i].ClipStrVar_s_of_ClipVar.
ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf));
break;
case MAP_type_of_ClipVarType:
case NUMERIC_type_of_ClipVarType:
citem = _fetch_cwidget(ClipMachineMemory, &cv->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar[i]);
CHECKCWID(citem, GTK_IS_WIDGET);
if (GTK_IS_LIST_ITEM(citem->widget))
items = g_list_append(items, citem->widget);
else
{
item = gtk_list_item_new();
gtk_container_add(GTK_CONTAINER(item), citem->widget);
items = g_list_append(items, item);
}
break;
default:
break;
}
}
}
default:
break;
}
gtk_list_prepend_items(GTK_LIST(clst->widget), items);
return 0;
err:
return 1;
}
gint main(int argc, gchar *argv[])
{
setlocale(LC_ALL, "en_US.UTF-8");
// textdomain (PACKAGE);
// bindtextdomain (PACKAGE, LOCALEDIR);
// bindtextdomain (PACKAGE, LOCALEDIR);
//bind_textdomain_codeset (PACKAGE, "UTF-8");
// textdomain (PACKAGE);
gtk_set_locale();
bindtextdomain ("main", "./locale");
textdomain ("main");
GtkWidget *separator;
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *scrolled_window;
GtkWidget *frame;
GtkWidget *gtklist;
GtkWidget *button;
GtkWidget *list_item;
GList *dlist;
guint i;
gchar buffer[64];
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GtkList Example");
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
//vbox
vbox=gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
//scrolled window
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scrolled_window, 250, 150);
gtk_container_add (GTK_CONTAINER (vbox), scrolled_window);
gtk_widget_show (scrolled_window);
//list
gtklist=gtk_list_new ();
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window),
gtklist);
gtk_widget_show (gtklist);
// g_signal_connect (G_OBJECT (gtklist), "selection_changed",
// G_CALLBACK (sigh_print_selection),
// NULL);
//list item
for (i = 0; i < 5; i++)
{
GtkWidget *label;
gchar *string;
sprintf(buffer, "徐镇杰", i);
label=gtk_label_new (buffer);
list_item=gtk_list_item_new ();
gtk_container_add (GTK_CONTAINER (list_item), label);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (gtklist), list_item);
gtk_widget_show(list_item);
gtk_label_get (GTK_LABEL (label), &string);
g_object_set_data (G_OBJECT (list_item), list_item_data_key, string);
}
gtk_widget_show (window);
gtk_main ();
return 0;
}
static void fill_wifi_list(GtkWidget *gtk_list, libin_wifi* pp)
{
//GtkWidget *gtk_list;
GList *items;
GList *copy;
GtkWidget *listitem;
GtkWidget *elementItem;
GSList *group;
GtkWidget *radio;
gint i;
//must initialize here for first use!
items = NULL;
copy = NULL;
group = NULL;
Element* element_content = NULL;
for(i=1;i<=pp[i].NET_NUMBER;i++)
{//.NET_NUMBER==0means the last??
listitem = gtk_list_item_new();
items = g_list_append(items, listitem);
elementItem = list_element_new(pp[i].ESSID, IMG_FILE,
(double)(100+pp[i].Singal_level)/100, &group);
char *onState = "on";
char *offState = "off";
if(!strcmp("on",pp[i].Encryption_key))
{//if crypted
elementItem = list_element_new(pp[i].ESSID, IMG_ENCRYPTED,
(double)(100+pp[i].Singal_level)/100, &group);
}
/*else if(!strcmp("off",pp[i].Encryption_key))
{
elementItem = list_element_new(pp[i].ESSID, IMG_FILE,
(double)(100+pp[i].Singal_level)/100, &group);
//elementItem = list_element_new(pp[i].ESSID, IMG_UNENCRYPTED,
// (double)(100+pp[i].Singal_level)/100, &group);
}*/
else
{
//elementItem = list_element_new(pp[i].ESSID, IMG_FILE,
// (double)(100+pp[i].Singal_level)/100, &group);
elementItem = list_element_new(pp[i].ESSID, NULL,
(double)(100+pp[i].Singal_level)/100, &group);
}
gtk_container_add(GTK_CONTAINER(listitem), elementItem);
gtk_widget_show_all(listitem);
//gtk_container_add(GTK_CONTAINER(gtk_list), listitem);
element_content = g_object_get_data (G_OBJECT (elementItem), "element_content");
g_object_set_data (G_OBJECT (element_content->radiobutton), "network", g_strdup (pp[i].ESSID));
g_object_set_data (G_OBJECT (element_content->radiobutton), "password", pp[i].Encryption_key);
if(1 == i)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(element_content->radiobutton),TRUE);
select_radio(GTK_TOGGLE_BUTTON(element_content->radiobutton), NULL);
}
}
/*for(i = 0; i < 5; ++i)
{
listitem = gtk_list_item_new();
items = g_list_append(items, listitem);
elementItem = list_element_new("name", IMG_FILE, 0.8, &group);
//gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),TRUE);
#if MY_DEBUG_OUT == 1
g_print("add element to listitem\n");
#endif
gtk_container_add(GTK_CONTAINER(listitem), elementItem);
#if MY_DEBUG_OUT == 1
g_print("add element to listitem ok\n");
#endif
gtk_widget_show_all(listitem);
}*/
copy = g_list_copy(items);
g_list_free(items);
items = NULL;
gtk_list_append_items(GTK_LIST(gtk_list), copy);
//return gtk_list;
}
