static void
garu_effects_equalizer_combo_box_changed (GtkComboBox *widget,
GaruEffects *self)
{
GSList *l;
gchar *band;
int active, i;
active = gtk_combo_box_get_active (widget);
g_settings_set_int (self->settings,"equalizer-preset", active);
equalizer_custom_selected = (active == G_N_ELEMENTS (eq_presets) - 1);
equalizer_changed_by_combo_box = TRUE;
for (l = self->eq_scales; l != NULL; l = l->next)
{
i = g_slist_position (self->eq_scales, l);
/* If custom preset is activated */
if (equalizer_custom_selected)
{
band = g_strdup_printf ("eq-custom-band%d", i);
gtk_range_set_value (GTK_RANGE (l->data),
g_settings_get_double (self->settings, band));
g_free (band);
}
else
{
gtk_range_set_value (GTK_RANGE (l->data),
eq_presets_values[active][i]);
}
}
equalizer_changed_by_combo_box = FALSE;
}
void
grg_recent_dox_push (const guchar * file)
{
GSList *cur, *tmp;
if (file == NULL)
return;
tmp = grg_recent_dox;
while (tmp)
{
cur = tmp;
tmp = tmp->next;
if (STR_EQ (cur->data, file) ||
(g_slist_position (grg_recent_dox, cur) >=
GRG_RECENT_LIMIT - 1))
{
grg_recent_dox =
g_slist_remove_link (grg_recent_dox, cur);
g_free (cur->data);
g_slist_free_1 (cur);
}
}
grg_recent_dox =
g_slist_prepend (grg_recent_dox, g_strdup ((guchar *) file));
recent_dox_save ();
grg_menu_update ();
}
static libspectrum_error
jump_blocks( libspectrum_tape *tape, int offset )
{
gint current_position; GSList *new_block;
current_position = g_slist_position( tape->blocks, tape->current_block );
if( current_position == -1 ) return LIBSPECTRUM_ERROR_LOGIC;
new_block = g_slist_nth( tape->blocks, current_position + offset );
if( new_block == NULL ) return LIBSPECTRUM_ERROR_CORRUPT;
tape->current_block = new_block;
return LIBSPECTRUM_ERROR_NONE;
}
/* Get the position on the tape of the current block */
libspectrum_error
libspectrum_tape_position( int *n, libspectrum_tape *tape )
{
*n = g_slist_position( tape->blocks, tape->state.current_block );
if( *n == -1 ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_LOGIC,
"libspectrum_tape_position: current block is not in tape!"
);
return LIBSPECTRUM_ERROR_LOGIC;
}
return LIBSPECTRUM_ERROR_NONE;
}
void gtk_clist_sort(GtkCList *clist)
{
HWND hWnd;
gint rowind;
GList *sel;
GSList *rowpt;
sorting_clist = clist;
if (clist && clist->cmp_func && clist->rows) {
/* Since the order of the list may change, we need to change the
* selection as well. Do this by converting the row indices into
* GSList pointers (which are invariant to the sort) and then convert
* back afterwards */
for (sel = clist->selection; sel; sel = g_list_next(sel)) {
rowind = GPOINTER_TO_INT(sel->data);
sel->data = (gpointer)g_slist_nth(clist->rowdata, rowind);
}
clist->rowdata = g_slist_sort(clist->rowdata, gtk_clist_sort_func);
for (sel = clist->selection; sel; sel = g_list_next(sel)) {
rowpt = (GSList *)(sel->data);
sel->data = GINT_TO_POINTER(g_slist_position(clist->rowdata, rowpt));
}
if (GTK_WIDGET_REALIZED(GTK_WIDGET(clist))) {
hWnd = GTK_WIDGET(clist)->hWnd;
if (clist->mode == GTK_SELECTION_SINGLE) {
sel = clist->selection;
if (sel)
rowind = GPOINTER_TO_INT(sel->data);
else
rowind = -1;
SendMessage(hWnd, LB_SETCURSEL, (WPARAM)rowind, 0);
} else {
for (rowind = 0; rowind < clist->rows; rowind++) {
SendMessage(hWnd, LB_SETSEL, (WPARAM)FALSE, (LPARAM)rowind);
}
for (sel = clist->selection; sel; sel = g_list_next(sel)) {
rowind = GPOINTER_TO_INT(sel->data);
SendMessage(hWnd, LB_SETSEL, (WPARAM)TRUE, (LPARAM)rowind);
}
}
InvalidateRect(hWnd, NULL, FALSE);
UpdateWindow(hWnd);
}
}
}
/**
* Queue a bitzi queries from the search context menu
*/
void
on_popup_search_metadata_activate(GtkMenuItem *unused_menuitem,
gpointer unused_udata)
{
GList *node_list;
GSList *data_list;
search_t *search;
guint32 bitzi_debug;
(void) unused_menuitem;
(void) unused_udata;
search = search_gui_get_current_search();
g_assert(search != NULL);
gtk_clist_freeze(GTK_CLIST(search->tree));
node_list = g_list_copy(GTK_CLIST(search->tree)->selection);
data_list = search_cb_collect_ctree_data(GTK_CTREE(search->tree),
node_list, gui_record_sha1_eq);
/* Make sure the column is actually visible. */
{
static const gint min_width = 80;
GtkCList *clist = GTK_CLIST(search->tree);
gtk_clist_set_column_visibility(clist, c_sr_meta, TRUE);
if (clist->column[c_sr_meta].width < min_width)
gtk_clist_set_column_width(clist, c_sr_meta, min_width);
}
/* Queue up our requests */
gnet_prop_get_guint32_val(PROP_BITZI_DEBUG, &bitzi_debug);
if (bitzi_debug > 10)
g_debug("on_popup_search_metadata_activate: %d items, %p",
g_slist_position(data_list, g_slist_last(data_list)) + 1,
cast_to_gconstpointer(data_list));
G_SLIST_FOREACH(data_list, search_gui_queue_bitzi_by_sha1);
gtk_clist_thaw(GTK_CLIST(search->tree));
g_slist_free(data_list);
g_list_free(node_list);
}
static void register_connections_stored(const char *adapter)
{
char filename[PATH_MAX + 1];
char *pattern;
struct stat st;
GSList *list;
bdaddr_t src;
bdaddr_t default_src;
int dev_id;
create_name(filename, PATH_MAX, STORAGEDIR, adapter, "network");
str2ba(adapter, &src);
if (stat(filename, &st) < 0)
return;
if (!(st.st_mode & __S_IFREG))
return;
textfile_foreach(filename, parse_stored_connection, &src);
/* Check default connection for current default adapter */
bacpy(&default_src, BDADDR_ANY);
dev_id = hci_get_route(&default_src);
if (dev_id < 0 || hci_devba(dev_id, &default_src) < 0)
return;
if (bacmp(&default_src, &src) != 0)
return;
pattern = textfile_get(filename, "default");
if (!pattern)
return;
list = find_connection_pattern(connection, pattern);
if (!list)
return;
default_index = g_slist_position(connection_paths, list);
}
static DBusMessage *change_default_connection(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *path;
const char *pattern;
GSList *list;
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern,
DBUS_TYPE_INVALID) == FALSE)
return NULL;
if (connection_paths == NULL ||
g_slist_length(connection_paths) == 0)
return does_not_exist(msg);
list = g_slist_find_custom(connection_paths, pattern,
(GCompareFunc) strcmp);
/* Find object path via pattern */
if (list == NULL) {
list = find_connection_pattern(conn, pattern);
if (list == NULL)
return does_not_exist(msg);
path = list->data;
} else
path = list->data;
default_index = g_slist_position(connection_paths, list);
connection_store(path, TRUE);
g_dbus_emit_signal(connection, NETWORK_PATH,
NETWORK_MANAGER_INTERFACE,
"DefaultConnectionChanged",
DBUS_TYPE_STRING, &path,
DBUS_TYPE_INVALID);
return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &path,
DBUS_TYPE_INVALID);
}
void
gnac_profiles_mgr_list_profiles(void)
{
GFile *dir = gnac_profiles_mgr_get_profiles_dir();
GError *error = NULL;
GFileEnumerator *files = g_file_enumerate_children(dir,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, &error);
if (!files && error) {
g_clear_error(&error);
/* no profiles found, try to import the default ones */
gnac_profiles_mgr_import_default_profiles();
files = g_file_enumerate_children(dir,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, &error);
if (!files && error) {
g_printerr(_("No profiles available"));
libgnac_warning("%s", error->message);
g_clear_error(&error);
return;
}
}
g_print(_("Available audio profiles:"));
g_print("\n\n");
gchar *last_used_profile = gnac_settings_get_string(
GNAC_KEY_LAST_USED_PROFILE);
GFile *profile_file = g_file_enumerator_get_container(files);
gchar *profile_file_path = g_file_get_path(profile_file);
GFileInfo *file_info;
GSList *profiles = NULL;
while ((file_info = g_file_enumerator_next_file(files, NULL, NULL))) {
if (g_file_info_get_file_type(file_info) == G_FILE_TYPE_REGULAR) {
AudioProfileGeneric *profile;
const gchar *profile_file_name = g_file_info_get_name(file_info);
gchar *profile_file_full_path = g_build_filename(profile_file_path,
profile_file_name, NULL);
gnac_profiles_default_load_generic_audio_profile(profile_file_full_path,
&profile);
if (profile) {
gpointer name = (profile->generic)->name;
profiles = g_slist_prepend(profiles, name);
}
g_free(profile_file_full_path);
}
g_object_unref(file_info);
}
g_free(profile_file_path);
profiles = g_slist_reverse(profiles);
guint count = g_slist_length(profiles);
if (count == 0) {
g_print("\t");
g_print(_("No profiles available"));
g_print("\n");
} else {
/* check if last_used_profile exists */
if (!g_slist_find_custom(profiles, last_used_profile,
(GCompareFunc) g_strcmp0))
{
last_used_profile = NULL;
}
GSList *tmp;
for (tmp = profiles; tmp; tmp = g_slist_next(tmp)) {
gint pos = g_slist_position(profiles, tmp);
gchar *count_str = g_strdup_printf("%u", pos+1);
/* if last_used_profile is not set, assume the
* first profile was last used */
gchar *name = tmp->data;
gboolean found = ((pos == 0 && !last_used_profile)
|| gnac_utils_str_equal(name, last_used_profile));
g_print("\t%2s) %s\n", found ? "*" : count_str, name);
g_free(count_str);
}
}
g_print("\n");
g_slist_free(profiles);
g_free(last_used_profile);
g_object_unref(dir);
g_file_enumerator_close(files, NULL, NULL);
g_object_unref(files);
}
GtkWidget *gui_build_dialog_gtk_table(GSList * list, gint cols, gboolean use_progress)
{
GSList *listtmp = list;
GtkWidget *adv_vbox = NULL;
GtkWidget *adv_expander = NULL;
gint ielements = g_slist_position(list, g_slist_last(list));
gint rows = ((ielements + 1) / cols) + use_progress;
GtkWidget *tab = gtk_table_new(rows, cols, FALSE);
gint actC = 0, actR = 0;
GtkWidget *to_grab_focus = NULL;
gboolean need_advanced = FALSE;
gtk_container_set_border_width(GTK_CONTAINER(tab), 15);
/* remember to free adv_expander */
adv_vbox = gtk_vbox_new(FALSE, 5);
while (listtmp)
{
GGaduKeyValue *kv = (GGaduKeyValue *) listtmp->data;
GtkWidget *entry = NULL;
gboolean need_label = TRUE;
gboolean is_advanced = FALSE;
switch (kv->type)
{
case VAR_STR:
entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(entry), g_strdup(kv->value));
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
break;
case VAR_INT:
{
entry = gtk_spin_button_new_with_range(0, 999999999, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), (gint) kv->value);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
}
break;
case VAR_INT_WITH_NEGATIVE:
{
entry = gtk_spin_button_new_with_range(-999999999, 999999999, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), (gint) kv->value);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
}
break;
case VAR_BOOL:
need_label = FALSE;
entry = gtk_check_button_new_with_mnemonic(kv->description);
if (kv->value)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(entry), TRUE);
break;
case VAR_FILE_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_button_new_from_stock("gtk-open");
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect_swapped(button_entry, "clicked", G_CALLBACK(gui_dialog_show_filename), txt_entry);
}
break;
case VAR_FONT_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_button_new_from_stock("gtk-select-font");
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect_swapped(button_entry, "clicked", G_CALLBACK(gui_dialog_show_fontchooser), txt_entry);
}
break;
case VAR_COLOUR_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
GdkColor color;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
gdk_color_parse(gtk_entry_get_text(GTK_ENTRY(txt_entry)), &color);
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_color_button_new_with_color(&color);
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect(G_OBJECT(button_entry), "color-set", G_CALLBACK(gui_dialog_show_colorchooser), txt_entry);
}
break;
case VAR_IMG:
need_label = FALSE;
entry = gtk_image_new_from_file(kv->value);
gtk_table_set_homogeneous(GTK_TABLE(tab), FALSE);
break;
case VAR_LIST:
{
GSList *selected = g_slist_nth((GSList *) kv->value, 0);
GSList *restlist = g_slist_nth((GSList *) kv->value, 1);
gint selected_index = 0;
gint i = -1;
entry = gtk_combo_box_new_text();
g_object_set_data(G_OBJECT(entry), "options-list", restlist);
while (restlist)
{
i++;
if (!g_strcasecmp(selected->data, restlist->data))
{
selected_index = i;
print_debug("############# %d %s", selected_index, selected->data);
}
gtk_combo_box_append_text(GTK_COMBO_BOX(entry), g_strdup(restlist->data));
restlist = restlist->next;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(entry), selected_index);
}
break;
default:
break;
}
if ((kv->flag & VAR_FLAG_SENSITIVE) != 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(entry), TRUE);
gtk_editable_set_editable(GTK_EDITABLE(entry), TRUE);
}
if ((kv->flag & VAR_FLAG_INSENSITIVE) != 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(entry), FALSE);
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
}
if ((kv->flag & VAR_FLAG_PASSWORD) != 0)
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
if ((kv->flag & VAR_FLAG_FOCUS) != 0)
to_grab_focus = entry;
kv->user_data = (gpointer) entry;
if ((kv->flag & VAR_FLAG_ADVANCED) != 0)
{
GtkWidget *hbox = gtk_hbox_new(FALSE, 5);
GtkWidget *align;
GtkWidget *label;
need_advanced = TRUE;
is_advanced = TRUE;
gtk_box_pack_end_defaults(GTK_BOX(hbox), entry);
if (need_label)
{
align = gtk_alignment_new(0, 0.5, 0, 0);
label = gtk_label_new_with_mnemonic(kv->description);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_box_pack_end_defaults(GTK_BOX(hbox), align);
}
gtk_box_pack_start_defaults(GTK_BOX(adv_vbox), hbox);
}
if (need_label && !is_advanced)
{
GtkWidget *align = gtk_alignment_new(0, 0.5, 0, 0);
GtkWidget *label = gtk_label_new_with_mnemonic(kv->description);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_table_attach_defaults(GTK_TABLE(tab), align, 0, 1, actR, actR + 1);
if (entry)
gtk_table_attach_defaults(GTK_TABLE(tab), entry, 1, 2, actR, actR + 1);
}
else if (!is_advanced)
{
gtk_table_attach(GTK_TABLE(tab), entry, actC, actC + 2, actR, actR + 1, GTK_FILL, GTK_SHRINK, 0, 0);
}
if (!is_advanced)
{
if ((actC + 1) < cols)
actC++;
else
{
actC = 0;
actR++;
}
}
listtmp = listtmp->next;
}
if (need_advanced)
{
adv_expander = gtk_expander_new_with_mnemonic(_("_More options"));
gtk_container_add(GTK_CONTAINER(adv_expander), adv_vbox);
gtk_table_attach_defaults(GTK_TABLE(tab), adv_expander, 0, rows, actR, actR + 1);
}
else
{
gtk_widget_destroy(adv_vbox);
}
/* progress stuff */
if (use_progress)
{
GtkWidget *progress = gtk_progress_bar_new();
gtk_table_attach_defaults(GTK_TABLE(tab), progress, 0, rows, actR, actR + 1);
}
if (to_grab_focus)
gtk_widget_grab_focus(GTK_WIDGET(to_grab_focus));
return tab;
}
/**
* This is our callback for the receiving-im-msg signal.
*
* We return TRUE to block the IM, FALSE to accept the IM
*/
static gboolean receiving_im_msg_cb(GaimAccount * account, char **sender,
char **buffer, int *flags, void *data)
{
gboolean retval = FALSE; /* assume the sender is allowed */
gboolean found = FALSE;
gint pos = -1;
char *botmsg = NULL;
PendingMessage *pending = NULL;
GSList *slist = NULL;
GSList *search = NULL;
GaimConnection *connection = NULL;
/* expire any old entries in pending */
expire_pending_list();
connection = gaim_account_get_connection(account);
/* not good, but don't do anything */
if (!connection || !sender) {
return retval;
}
/* if there is already an open conversation, allowed it */
if (gaim_find_conversation_with_account(*sender, account)) {
return retval;
}
/* don't make buddies use the challenge/response system */
if (gaim_find_buddy(account, *sender)) {
return retval;
}
/* don't make permit list members use the challenge/response system */
for (slist = account->permit; slist != NULL; slist = slist->next) {
if (!gaim_utf8_strcasecmp
(*sender, gaim_normalize(account, (char *) slist->data))) {
return retval;
}
}
/* if there is no question or no answer, allow the sender */
const char *question =
gaim_prefs_get_string("/plugins/core/bot/challenger/question");
const char *answer =
gaim_prefs_get_string("/plugins/core/bot/challenger/answer");
if (!question || !answer) {
return retval;
}
/* blank / null message ... can this even happen? */
if (!*buffer) {
return retval;
}
/* search if this sender is already in pending */
for (search = pending_list; search; search = search->next) {
pending = search->data;
pos = g_slist_position(pending_list, search);
if (protocmp(account, pending) && usercmp(account, pending)
&& sendercmp(*sender, pending)) {
found = TRUE;
break;
}
}
if (!found) {
/**
* its the first time through, save the nick/msg to the
* queue and ask the question
*/
GTimeVal *now = NULL;
now = g_new0(GTimeVal, 1);
g_get_current_time(now);
PendingMessage *newpend = NULL;
newpend = g_new0(PendingMessage, 1);
newpend->tv_sec = now->tv_sec;
newpend->protocol = g_strdup(account->protocol_id);
newpend->username = g_strdup(account->username);
newpend->sender = g_strdup(*sender);
newpend->message = g_strdup(*buffer);
pending_list = g_slist_append(pending_list, newpend);
botmsg =
g_strdup_printf(_
("Bot Challenger engaged: you are now being ignored! Your message will be delivered if you can correctly answer the following question within %i minutes: %s"),
BOT_MAX_MINUTES, question);
send_auto_reply(account, *sender, botmsg);
g_free(now);
g_free(botmsg);
retval = TRUE;
} else {
if (gaim_utf8_strcasecmp(*buffer, answer)) {
/**
* Sorry, thanks for playing, please try again
*/
retval = TRUE;
} else {
botmsg =
_
("Bot Challenger accepted your answer and delivered your original message. You may now speak freely.");
send_auto_reply(account, *sender, botmsg);
if (gaim_prefs_get_bool
("/plugins/core/bot/challenger/auto_add_permit")) {
if (!gaim_privacy_permit_add(account, *sender, FALSE)) {
gaim_debug_info("bot-challenger",
"Unable to add %s/%s/%s to permit list\n",
*sender, pending->username,
pending->protocol);
}
}
/**
* Free what is currently in the buffer (the correct answer)
* and replace it with the user's first message that was
* queued, pending the correct answer. I think some other
* process is supposed to free the buffer after its sent.
*/
g_free(*buffer);
*buffer = pending->message;
/* Clean up everything else except pending->message */
free_pending(search, FALSE);
retval = FALSE; /* Don't block this message */
}
}
debug_pending_list();
return retval; /* returning TRUE will block the IM */
}
// Tests for slist
void tg_slist_tests()
{
GSList *slist,*st,*rem;
gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
gint chk_buf[20];
gint i;
gint g_slist_insert_data;
gint g_slist_insert_before_data;
gint ip1 = 10;
gint ip2 = 15;
gint ip3 = 5;
gint ip4 = 12;
gint g_slist_nth_data_op,g_slist_find_custom_op;
//Trying to use the allocators so that even they get tested!
GAllocator* alloc = g_allocator_new ("alloc_slist",5000);
g_slist_push_allocator (alloc);
slist = NULL;
for (i = 0; i < 10; i++)
slist = g_slist_append (slist, &nums[i]);
//List looks like:
// 0 1 2 3 4 5 6 7 8 9
//Test for g_slist_insert....inserted 10 at pos 4
g_slist_insert(slist,&ip1,4);
st = g_slist_nth (slist,0);
for(i = 0;i < 4;i++)
st = st->next;
g_slist_insert_data = *((gint*) st->data);
g_assert(g_slist_insert_data == 10);
/* for (i = 0; i < 10; i++)
{
st = g_slist_nth (slist, i);
chk_buf[i] = *((gint*) st->data);
}*/
//List looks like:
// 0 1 2 3 10 4 5 6 7 8 9
//Test for g_slist_insert_before....inserted 15 at pos 7
st = g_slist_nth (slist,7);
g_slist_insert_before(slist,st,&ip2);
st = g_slist_nth (slist,0);
for(i = 0;i < 7;i++)
st = st->next;
g_slist_insert_before_data = *((gint*) st->data);
g_assert(g_slist_insert_before_data == 15);
//List looks like:
// 0 1 2 3 10 4 5 15 6 7 8 9
//Test for g_slist_index....finding 15 at pos 7
st = g_slist_nth (slist,0);
g_assert(g_slist_index(st,&ip2)==7);
//Test for g_slist_nth_data....getting 6 at position 8
g_slist_nth_data_op = *((gint*) g_slist_nth_data(slist,8));
g_assert(g_slist_nth_data_op == 6) ;
//Test for g_slist_position
st = g_slist_nth (slist,7);
g_assert(g_slist_position (slist,st) == 7);
//Test for g_slist_find_custom
st = g_slist_find_custom(slist,&ip3,compare_fun_gr);
g_slist_find_custom_op = *((gint*) st->data);
g_assert(g_slist_find_custom_op == 5);
//Test for g_slist_sort_with_data
st = g_slist_sort_with_data(slist,compare_fun_gr_data,&ip3);
for (i = 0; i < 10; i++)
{
st = g_slist_nth (slist, i);
g_assert (*((gint*) st->data) == i);
}
//List looks like:
// 0 1 2 3 4 5 6 7 8 9 10 15
//Test for g_slist_remove_link
st = g_slist_nth (slist, 5);
rem = g_slist_remove_link(slist , st);
st = g_slist_nth (slist, 5);
g_assert (*((gint*) st->data) == 6);
//List looks like:
// 0 1 2 3 4 6 7 8 9 10 15
//Test for g_slist_remove_all
g_slist_insert(slist,&ip4,4);
g_slist_insert(slist,&ip4,6);
g_slist_insert(slist,&ip4,8);
//List looks like:
// 0 1 2 3 4 12 6 7 12 8 12 9 10 15
g_slist_remove_all(slist ,&ip4);
g_slist_free (slist);
g_slist_pop_allocator ();
}
