static void
prefs_load_xml_end_element(
GMarkupParseContext * context,
const gchar * element,
gpointer user_data,
GError ** error)
{
struct prefs_parser_state * state = (struct prefs_parser_state*)user_data;
if(!g_utf8_collate(element, "vqcc_gtk")
&& state->tag==PREFS_TAG_VQCC_GTK) {
state->tag = PREFS_TAG_NO_TAG;
}
else if(!g_utf8_collate(element, "settings")
&& state->tag==PREFS_TAG_VQCC_GTK_SETTINGS) {
state->tag = PREFS_TAG_VQCC_GTK;
}
else if(!g_utf8_collate(element, "pref")
&& state->tag==PREFS_TAG_VQCC_GTK_SETTINGS_PREF) {
state->tag = PREFS_TAG_VQCC_GTK_SETTINGS;
}
else if(!g_utf8_collate(element, "entry")
&& state->tag==PREFS_TAG_VQCC_GTK_SETTINGS_PREF_ENTRY) {
state->tag = PREFS_TAG_VQCC_GTK_SETTINGS_PREF;
}
}
static gboolean
parse_notify_arg (const gchar *option_name, const gchar *value,
gpointer data, GError **error)
{
CutConsoleUIFactory *console = data;
if (value == NULL ||
g_utf8_collate(value, "yes") == 0 ||
g_utf8_collate(value, "true") == 0 ||
g_utf8_collate(value, "auto") == 0) {
if (!console->notify_command) {
console->notify_command = g_strdup(search_notify_command());
}
} else if (g_utf8_collate(value, "no") == 0 ||
g_utf8_collate(value, "false") == 0) {
if (console->notify_command) {
g_free(console->notify_command);
console->notify_command = NULL;
}
} else {
g_set_error(error,
G_OPTION_ERROR,
G_OPTION_ERROR_BAD_VALUE,
_("Invalid notify value: %s"), value);
return FALSE;
}
return TRUE;
}
static gint
mouse_settings_themes_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data)
{
gchar *name_a, *name_b;
gint retval;
/* get the names from the model */
gtk_tree_model_get (model, a, COLUMN_THEME_DISPLAY_NAME, &name_a, -1);
gtk_tree_model_get (model, b, COLUMN_THEME_DISPLAY_NAME, &name_b, -1);
/* make sure the names are not null */
if (G_UNLIKELY (name_a == NULL))
name_a = g_strdup ("");
if (G_UNLIKELY (name_b == NULL))
name_b = g_strdup ("");
/* sort the names but keep Default on top */
if (g_utf8_collate (name_a, _("Default")) == 0)
retval = -1;
else if (g_utf8_collate (name_b, _("Default")) == 0)
retval = 1;
else
retval = g_utf8_collate (name_a, name_b);
/* cleanup */
g_free (name_a);
g_free (name_b);
return retval;
}
gint
compare_filelist_entry_path(gconstpointer filelist_entry1,
gconstpointer filelist_entry2)
{
const struct mpd_entity *e1, *e2;
int n = 0;
e1 = ((const struct filelist_entry *)filelist_entry1)->entity;
e2 = ((const struct filelist_entry *)filelist_entry2)->entity;
if (e1 != NULL && e2 != NULL &&
mpd_entity_get_type(e1) == mpd_entity_get_type(e2)) {
switch (mpd_entity_get_type(e1)) {
case MPD_ENTITY_TYPE_UNKNOWN:
break;
case MPD_ENTITY_TYPE_DIRECTORY:
n = g_utf8_collate(mpd_directory_get_path(mpd_entity_get_directory(e1)),
mpd_directory_get_path(mpd_entity_get_directory(e2)));
break;
case MPD_ENTITY_TYPE_SONG:
break;
case MPD_ENTITY_TYPE_PLAYLIST:
n = g_utf8_collate(mpd_playlist_get_path(mpd_entity_get_playlist(e1)),
mpd_playlist_get_path(mpd_entity_get_playlist(e2)));
}
}
return n;
}
static gint sort_func(gconstpointer da, gconstpointer db, gpointer dat) {
const hub_user_t *a = da;
const hub_user_t *b = db;
tab_t *t = dat;
int p = t->order;
if(t->opfirst && !a->isop != !b->isop)
return a->isop && !b->isop ? -1 : 1;
// All orders have the username as secondary order.
int o = p == SORT_USER ? 0 :
p == SORT_SHARE ? a->sharesize > b->sharesize ? 1 : -1:
p == SORT_CONN ? (t->tab.hub->adc ? a->conn - b->conn : strcmp(a->conn?a->conn:"", b->conn?b->conn:"")) :
p == SORT_DESC ? g_utf8_collate(a->desc?a->desc:"", b->desc?b->desc:"") :
p == SORT_MAIL ? g_utf8_collate(a->mail?a->mail:"", b->mail?b->mail:"") :
p == SORT_CLIENT ? strcmp(a->client?a->client:"", b->client?b->client:"")
: (ip4_cmp(a->ip4, b->ip4) != 0 ? ip4_cmp(a->ip4, b->ip4) : ip6_cmp(a->ip6, b->ip6));
// Username sort
if(!o)
o = g_utf8_collate(a->name, b->name);
if(!o && a->name_hub && b->name_hub)
o = strcmp(a->name_hub, b->name_hub);
if(!o)
o = a - b;
return t->reverse ? -1*o : o;
}
static void set_single(gpointer data, const char *param)
{
int val = mpd_server_check_command_allowed(connection, "single");
if (val == MPD_SERVER_COMMAND_NOT_SUPPORTED)
{
char * mesg = g_strdup_printf("%s: %s",
_("Single"),
_("The used MPD server is too old and does not support this."));
playlist3_message_show(pl3_messages,mesg,ERROR_CRITICAL);
g_free(mesg);
} else if (val == MPD_SERVER_COMMAND_NOT_ALLOWED)
{
char * mesg = g_strdup_printf("%s: %s",
_("Single"),
_("You have insufficient permission to use this option."));
playlist3_message_show(pl3_messages, mesg, ERROR_WARNING);
g_free(mesg);
} else if (val == MPD_SERVER_COMMAND_ALLOWED)
{
if (g_utf8_collate(param, "on") == 0)
{
mpd_player_set_single(connection, TRUE);
} else if (g_utf8_collate(param, "off") == 0)
{
mpd_player_set_single(connection, FALSE);
} else
{
mpd_player_set_single(connection, !mpd_player_get_single(connection));
}
}
}
gboolean gfire_game_load_config_xml(gboolean p_force)
{
if(!p_force && gfire_games_config)
return TRUE;
xmlnode *node = NULL;
gchar *filename = g_build_filename(purple_user_dir(), "gfire_game_config.xml", NULL);
if(filename)
{
purple_debug(PURPLE_DEBUG_INFO, "gfire", "Loading Game Launch Data from: %s\n", filename);
g_free(filename);
}
node = purple_util_read_xml_from_file("gfire_game_config.xml", "Gfire Game Config List");
if(!node)
{
purple_debug(PURPLE_DEBUG_ERROR, "gfire", "gfire_game_load_config_xml: Couldn't load game config.\n");
return FALSE;
}
// Check for a valid game config
if(g_utf8_collate(node->name, "game_config"))
{
xmlnode_free(node);
return FALSE;
}
// Check for a valid version
if(!xmlnode_get_attrib(node, "version") || g_utf8_collate(xmlnode_get_attrib(node, "version"), "2"))
{
xmlnode_free(node);
return FALSE;
}
// Delete all old configurations
gfire_game_config_cleanup();
// Parse all games
xmlnode *game_node = xmlnode_get_child(node, "game");
while(game_node)
{
gfire_game_configuration *gconf = gfire_game_configuration_create_from_xml(game_node);
if(gconf)
gfire_games_config = g_list_append(gfire_games_config, gconf);
game_node = xmlnode_get_next_twin(game_node);
}
gfire_game_config_sort();
xmlnode_free(node);
return TRUE;
}
static gint
sort_personas (FolksPersona *persona_a,
FolksPersona *persona_b)
{
EmpathyContact *contact;
TpAccount *account_a, *account_b;
gint ret_val;
g_return_val_if_fail (persona_a != NULL || persona_b != NULL, 0);
/* alias */
ret_val = g_utf8_collate (
folks_aliasable_get_alias (FOLKS_ALIASABLE (persona_a)),
folks_aliasable_get_alias (FOLKS_ALIASABLE (persona_b)));
if (ret_val != 0)
goto out;
/* identifier */
ret_val = g_utf8_collate (folks_persona_get_display_id (persona_a),
folks_persona_get_display_id (persona_b));
if (ret_val != 0)
goto out;
contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
TPF_PERSONA (persona_a)));
account_a = empathy_contact_get_account (contact);
g_object_unref (contact);
contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
TPF_PERSONA (persona_b)));
account_b = empathy_contact_get_account (contact);
g_object_unref (contact);
/* protocol */
ret_val = strcmp (tp_account_get_protocol (account_a),
tp_account_get_protocol (account_a));
if (ret_val != 0)
goto out;
/* account ID */
ret_val = strcmp (tp_proxy_get_object_path (account_a),
tp_proxy_get_object_path (account_a));
out:
return ret_val;
}
/** used to compare 2 iters and sort the by type first, and
* by date and no transaction after
* always put the white line below
* \param model the GtkTreeModel
* \param iter_1
* \param iter_2
* \return -1 if iter_1 is above iter_2
* */
gint gsb_transactions_list_sort_by_type ( gint transaction_number_1,
gint transaction_number_2 )
{
gint return_value;
/* if it's the same type, we sort by the content of the types */
if ( gsb_data_transaction_get_method_of_payment_number ( transaction_number_1) == gsb_data_transaction_get_method_of_payment_number ( transaction_number_2))
{
return_value = g_utf8_collate ( g_utf8_casefold ( gsb_data_transaction_get_method_of_payment_content ( transaction_number_1) ? gsb_data_transaction_get_method_of_payment_content ( transaction_number_1) : "",
-1 ),
g_utf8_casefold ( gsb_data_transaction_get_method_of_payment_content ( transaction_number_2) ? gsb_data_transaction_get_method_of_payment_content ( transaction_number_2) : "",
-1 ));
if ( !return_value )
return gsb_transactions_list_sort_by_date_and_no ( transaction_number_1, transaction_number_2 );
}
else
{
const gchar *temp_1;
const gchar *temp_2;
temp_1 = gsb_data_payment_get_name (gsb_data_transaction_get_method_of_payment_number (transaction_number_1));
temp_2 = gsb_data_payment_get_name (gsb_data_transaction_get_method_of_payment_number (transaction_number_2));
/* g_utf8_collate is said not very fast, must try with big big account to check
* if it's enough, for me it's ok (cedric), eventually, change with gsb_strcasecmp */
return_value = g_utf8_collate ( g_utf8_casefold ( temp_1 ? temp_1 : "",
-1 ),
g_utf8_casefold ( temp_2 ? temp_2 : "",
-1 ));
}
if ( return_value )
return return_value;
else
{
/* it seems that the 2 types are different no but same spell... */
return_value = g_utf8_collate ( g_utf8_casefold ( gsb_data_transaction_get_method_of_payment_content ( transaction_number_1)? gsb_data_transaction_get_method_of_payment_content ( transaction_number_1): "",
-1 ),
g_utf8_casefold ( gsb_data_transaction_get_method_of_payment_content ( transaction_number_2)? gsb_data_transaction_get_method_of_payment_content ( transaction_number_2): "",
-1 ));
if ( !return_value )
return gsb_transactions_list_sort_by_date_and_no ( transaction_number_1, transaction_number_2 );
}
return return_value;
}
gint
sort_default_comparator (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b,
gpointer user_data)
{
const gchar *keya, *keyb;
gchar *namea, *nameb;
/* By default we sort by:
* - Presence of key pointer (to keep none-option at top)
* - Name
*/
gtk_tree_model_get (model, a, CRYPTUI_KEY_STORE_KEY, &keya,
CRYPTUI_KEY_STORE_NAME, &namea, -1);
gtk_tree_model_get (model, b, CRYPTUI_KEY_STORE_KEY, &keyb,
CRYPTUI_KEY_STORE_NAME, &nameb, -1);
/* This somewhat strage set of checks keep the none-option,
separator, and keys in proper order */
if (!keya && keyb)
return -1;
else if (!keyb && keya)
return 1;
else if (!namea && nameb)
return 1;
else if (!nameb && namea)
return -1;
else if (!keya && !keyb)
return 0;
else if (!namea && !nameb)
return 0;
return g_utf8_collate (namea, nameb);
}
static void
gtr_message_table_selection_changed (GtkTreeSelection *selection,
GtrMessageTable *table)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtrMsg *msg;
GList *current_msg = NULL;
GtrMessageTablePrivate *priv;
GtrPo *po;
g_return_if_fail (selection != NULL);
priv = gtr_message_table_get_instance_private (table);
po = gtr_tab_get_po (priv->tab);
current_msg = gtr_po_get_current_message (po);
if (gtk_tree_selection_get_selected (selection, &model, &iter) == TRUE)
{
gtk_tree_model_get (model, &iter,
GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg, -1);
if (msg != NULL
&& g_utf8_collate (gtr_msg_get_msgid (msg),
gtr_msg_get_msgid (current_msg->data)))
{
g_signal_handlers_block_by_func (priv->tab, showed_message_cb, table);
gtr_tab_message_go_to (priv->tab, msg,
FALSE, GTR_TAB_MOVE_NONE);
g_signal_handlers_unblock_by_func (priv->tab, showed_message_cb, table);
}
}
}
gint
gnomegadu_ui_tree_sort (GtkTreeModel * model, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data)
{
gchar *str_a = NULL, *str_b = NULL;
gint status_a = 0, status_b = 0;
gint ret = 0;
gtk_tree_model_get (GTK_TREE_MODEL (model), a, UI_CONTACTS_COLUMN_DISPLAYED, &str_a, UI_CONTACTS_COLUMN_STATUS,
&status_a, -1);
gtk_tree_model_get (GTK_TREE_MODEL (model), b, UI_CONTACTS_COLUMN_DISPLAYED, &str_b, UI_CONTACTS_COLUMN_STATUS,
&status_b, -1);
if ((status_a == GNOMEGADU_STATUS_UNAVAIL) && (status_b != GNOMEGADU_STATUS_UNAVAIL))
ret = 1;
if ((status_a != GNOMEGADU_STATUS_UNAVAIL) && (status_b == GNOMEGADU_STATUS_UNAVAIL))
ret = -1;
if (str_a && str_b && ret == 0) {
ret = g_utf8_collate (str_a, str_b);
}
g_free (str_a);
g_free (str_b);
return ret;
}
static int
compare_iters (GtkTreeModel* model, GtkTreeIter* iter_a, GtkTreeIter* iter_b, gpointer user_data)
{
UnicodeBlock *block_a, *block_b;
char *label_a, *label_b;
int ret;
gtk_tree_model_get (model, iter_a, BLOCK_CHAPTERS_MODEL_UNICODE_BLOCK_PTR, &block_a, -1);
gtk_tree_model_get (model, iter_b, BLOCK_CHAPTERS_MODEL_UNICODE_BLOCK_PTR, &block_b, -1);
if (block_a == NULL && block_b != NULL)
return -1;
else if (block_a != NULL && block_b == NULL)
return 1;
else if (block_a == NULL && block_b == NULL)
return 0;
gtk_tree_model_get (model, iter_a, BLOCK_CHAPTERS_MODEL_LABEL, &label_a, -1);
gtk_tree_model_get (model, iter_b, BLOCK_CHAPTERS_MODEL_LABEL, &label_b, -1);
ret = g_utf8_collate (label_a, label_b);
g_free (label_a);
g_free (label_b);
return ret;
}
static gint
gimp_plug_in_manager_file_proc_compare (gconstpointer a,
gconstpointer b,
gpointer data)
{
GimpPlugInProcedure *proc_a = GIMP_PLUG_IN_PROCEDURE (a);
GimpPlugInProcedure *proc_b = GIMP_PLUG_IN_PROCEDURE (b);
const gchar *label_a;
const gchar *label_b;
gint retval = 0;
if (g_str_has_prefix (proc_a->prog, "gimp-xcf"))
return -1;
if (g_str_has_prefix (proc_b->prog, "gimp-xcf"))
return 1;
label_a = gimp_plug_in_procedure_get_label (proc_a);
label_b = gimp_plug_in_procedure_get_label (proc_b);
if (label_a && label_b)
retval = g_utf8_collate (label_a, label_b);
return retval;
}
static gint tree_compare(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gTree *tree)
{
bool def = true;
int comp;
char *ka = tree->iterToKey(a);
char *kb = tree->iterToKey(b);
const char *ta, *tb;
//fprintf(stderr, "ka = '%s' kb = '%s'\n", ka, kb);
//if (tree->view && tree->view->onCompare)
// def = tree->view->onCompare(tree->view, ka, kb, &comp);
if (def)
{
ta = tree->getRow(ka)->get(tree->getSortColumn())->text();
if (!ta) ta = "";
tb = tree->getRow(kb)->get(tree->getSortColumn())->text();
if (!tb) tb = "";
//fprintf(stderr, "ta = '%s' tb = '%s'\n", ta, tb);
comp = g_utf8_collate(ta, tb);
}
if (!tree->isSortAscending())
comp = (-comp);
return comp;
}
/** used to compare 2 iters and sort the by reconcile number first, and
* by date and no transaction after
* always put the white line below
* \param model the GtkTreeModel
* \param iter_1
* \param iter_2
* \return -1 if iter_1 is above iter_2
* */
gint gsb_transactions_list_sort_by_reconcile_nb ( gint transaction_number_1,
gint transaction_number_2 )
{
gint return_value;
if ( gsb_data_transaction_get_reconcile_number ( transaction_number_1) == gsb_data_transaction_get_reconcile_number ( transaction_number_2))
return gsb_transactions_list_sort_by_date_and_no ( transaction_number_1, transaction_number_2 );
else
{
const gchar *temp_1;
const gchar *temp_2;
temp_1 = gsb_data_reconcile_get_name ( gsb_data_transaction_get_reconcile_number ( transaction_number_1));
temp_2 = gsb_data_reconcile_get_name ( gsb_data_transaction_get_reconcile_number ( transaction_number_2));
/* g_utf8_collate is said not very fast, must try with big big account to check
* if it's enough, for me it's ok (cedric), eventually, change with gsb_strcasecmp */
return_value = g_utf8_collate ( g_utf8_casefold ( temp_1 ? temp_1 : "",
-1 ),
g_utf8_casefold ( temp_2 ? temp_2 : "",
-1 ));
}
if ( return_value )
return return_value;
else
return gsb_transactions_list_sort_by_date_and_no ( transaction_number_1, transaction_number_2 );
}
static gboolean
chat_nick_matches_name(PurpleConversation *conv, const char *aname)
{
PurpleConvChat *chat = NULL;
char *nick = NULL;
char *name = NULL;
gboolean ret = FALSE;
PurpleAccount *account;
chat = purple_conversation_get_chat_data(conv);
if (chat == NULL)
return ret;
account = purple_conversation_get_account(conv);
nick = g_strdup(purple_normalize(account, chat->nick));
name = g_strdup(purple_normalize(account, aname));
if (g_utf8_collate(nick, name) == 0)
ret = TRUE;
g_free(nick);
g_free(name);
return ret;
}
static gint _lib_modulelist_gui_sort(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
{
dt_iop_module_t *modulea, *moduleb;
gtk_tree_model_get(model, a, COL_MODULE, &modulea, -1);
gtk_tree_model_get(model, b, COL_MODULE, &moduleb, -1);
return g_utf8_collate(modulea->name(), moduleb->name());
}
static GtkWidget *
gnc_prefs_find_page (GtkNotebook *notebook, const gchar *name)
{
int n_pages, i;
GtkWidget *child;
const gchar *child_name;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
g_return_val_if_fail (name, NULL);
ENTER("");
n_pages = gtk_notebook_get_n_pages (notebook);
for (i = 0; i < n_pages; i++)
{
child = gtk_notebook_get_nth_page (notebook, i);
g_return_val_if_fail (child, NULL);
child_name = gtk_notebook_get_tab_label_text (notebook, child);
g_return_val_if_fail (child_name, NULL);
if (g_utf8_collate (name, child_name) == 0)
{
LEAVE("found at index: %d", i);
return child;
}
}
LEAVE("not found");
return NULL;
}
static gint
sort_chat_users_by_pic(GtkTreeModel * model, GtkTreeIter * a,
GtkTreeIter * b, gpointer userdata)
{
GaimConvChatBuddyFlags f1 = 0, f2 = 0;
gint flag_mask = 0x000F;
char *user1 = NULL, *user2 = NULL;
gint ret = 0;
gtk_tree_model_get(model, a, CHAT_USERS_NAME_COLUMN, &user1,
CHAT_USERS_FLAGS_COLUMN, &f1, -1);
gtk_tree_model_get(model, b, CHAT_USERS_NAME_COLUMN, &user2,
CHAT_USERS_FLAGS_COLUMN, &f2, -1);
f1 = f1 & flag_mask;
f2 = f2 & flag_mask;
if (user1 == NULL || user2 == NULL) {
if (!(user1 == NULL && user2 == NULL))
ret = (user1 == NULL) ? -1 : 1;
} else if (f1 != f2) {
/* sort more important users first */
ret = (f1 > f2) ? -1 : 1;
} else {
ret = g_utf8_collate(user1, user2);
}
g_free(user1);
g_free(user2);
return ret;
}
/* void ggp_confer_participants_add(PurpleConnection *gc, const gchar *chat_name, const uin_t *recipients, int count) {{{ */
void ggp_confer_participants_add(PurpleConnection *gc, const gchar *chat_name,
const uin_t *recipients, int count)
{
GGPInfo *info = gc->proto_data;
GList *l;
gchar *str_uin;
for (l = info->chats; l != NULL; l = l->next) {
GGPChat *chat = l->data;
int i;
if (g_utf8_collate(chat->name, chat_name) != 0)
continue;
for (i = 0; i < count; i++) {
PurpleConversation *conv;
if (g_list_find(chat->participants,
GINT_TO_POINTER(recipients[i])) != NULL) {
continue;
}
chat->participants = g_list_append(chat->participants,
GINT_TO_POINTER(recipients[i]));
str_uin = g_strdup_printf("%lu", (unsigned long int)recipients[i]);
conv = ggp_confer_find_by_name(gc, chat_name);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(conv),
str_uin, NULL,
PURPLE_CBFLAGS_NONE, TRUE);
g_free(str_uin);
}
break;
}
}
static gint
wp_list_sort (GtkTreeModel *model,
GtkTreeIter *a, GtkTreeIter *b,
AppearanceData *data)
{
MateWPItem *itema, *itemb;
gint retval;
gtk_tree_model_get (model, a, 1, &itema, -1);
gtk_tree_model_get (model, b, 1, &itemb, -1);
if (!strcmp (itema->filename, "(none)"))
{
retval = -1;
}
else if (!strcmp (itemb->filename, "(none)"))
{
retval = 1;
}
else
{
retval = g_utf8_collate (itema->description, itemb->description);
}
return retval;
}
/* void ggp_confer_participants_add_uin(GaimConnection *gc, const gchar *chat_name, const uin_t uin) {{{ */
void ggp_confer_participants_add_uin(GaimConnection *gc, const gchar *chat_name,
const uin_t uin)
{
GaimConversation *conv;
GGPInfo *info = gc->proto_data;
GGPChat *chat;
GList *l;
gchar *str_uin;
for (l = info->chats; l != NULL; l = l->next) {
chat = l->data;
if (g_utf8_collate(chat->name, chat_name) != 0)
continue;
if (g_list_find(chat->participants, GINT_TO_POINTER(uin)) == NULL) {
chat->participants = g_list_append(
chat->participants, GINT_TO_POINTER(uin));
str_uin = g_strdup_printf("%lu", (unsigned long int)uin);
conv = ggp_confer_find_by_name(gc, chat_name);
gaim_conv_chat_add_user(GAIM_CONV_CHAT(conv), str_uin, NULL,
GAIM_CBFLAGS_NONE, TRUE);
g_free(str_uin);
}
break;
}
}
/** used to compare 2 iters and sort the by category first, and
* by date and no transaction after
* always put the white line below
* \param model the GtkTreeModel
* \param iter_1
* \param iter_2
* \return -1 if iter_1 is above iter_2
* */
gint gsb_transactions_list_sort_by_category ( gint transaction_number_1,
gint transaction_number_2 )
{
gint return_value;
gchar *temp_1;
gchar *temp_2;
/** we want to take the name of the categ, so, either
* split of transaction
* transfer : ...
* categ : under-categ
* and after, we sort by str
* */
temp_1 = gsb_transactions_get_category_real_name ( transaction_number_1);
temp_2 = gsb_transactions_get_category_real_name ( transaction_number_2);
/* g_utf8_collate is said not very fast, must try with big big account to check
* if it's enough, for me it's ok (cedric), eventually, change with gsb_strcasecmp */
return_value = g_utf8_collate ( g_utf8_casefold ( temp_1 ? temp_1 : "",
-1 ),
g_utf8_casefold ( temp_2 ? temp_2 : "",
-1 ));
g_free (temp_1);
g_free (temp_2);
if ( return_value )
return return_value;
else
return gsb_transactions_list_sort_by_date_and_no ( transaction_number_1, transaction_number_2 );
}
static gint
gwy_app_file_chooser_type_compare(gconstpointer a,
gconstpointer b)
{
return g_utf8_collate(_(gwy_file_func_get_description((const gchar*)a)),
_(gwy_file_func_get_description((const gchar*)b)));
}
static int
cmp_str (const char *s1, const char *s2)
{
if (s1 == s2)
return 0;
else if (!s1)
return -1;
else if (!s2)
return 1;
/* optimization 1: ascii */
if (isascii(s1[0]) && isascii(s2[0])) {
int diff;
diff = tolower(s1[0]) - tolower(s2[0]);
if (diff != 0)
return diff;
}
/* utf 8 */
{
char *u1, *u2;
int diff;
u1 = g_utf8_strdown (s1, -1);
u2 = g_utf8_strdown (s2, -1);
diff = g_utf8_collate (u1, u2);
g_free (u1);
g_free (u2);
return diff;
}
}
static inline int
compare_string_values (const GValue *a_value, const GValue *b_value)
{
const char *str1, *str2;
int retval;
str1 = g_value_get_string (a_value);
str2 = g_value_get_string (b_value);
if (str1 == NULL)
{
retval = -1;
}
else if (str2 == NULL)
{
retval = 1;
}
else
{
char *str_a;
char *str_b;
str_a = g_utf8_casefold (str1, -1);
str_b = g_utf8_casefold (str2, -1);
retval = g_utf8_collate (str_a, str_b);
g_free (str_a);
g_free (str_b);
}
return retval;
}
static gint
place_compare_func (gconstpointer a,
gconstpointer b,
gpointer user_data)
{
GtkWidget *child_a, *child_b;
Place *place_a, *place_b;
gchar *path;
gboolean is_home;
child_a = GTK_WIDGET (a);
child_b = GTK_WIDGET (b);
place_a = g_object_get_data (G_OBJECT (child_a), "place");
place_b = g_object_get_data (G_OBJECT (child_b), "place");
path = g_file_get_path (place_a->location);
is_home = (g_strcmp0 (path, g_get_home_dir ()) == 0);
g_free (path);
if (is_home)
return -1;
if (place_a->place_type == place_b->place_type)
return g_utf8_collate (place_a->display_name, place_b->display_name);
if (place_a->place_type == PLACE_XDG)
return -1;
if ((place_a->place_type == PLACE_BOOKMARKS) && (place_b->place_type == PLACE_OTHER))
return -1;
return 1;
}
static gint
schemes_compare(GtkSourceStyleScheme *a, GtkSourceStyleScheme *b)
{
const gchar *name_a = gtk_source_style_scheme_get_name(a);
const gchar *name_b = gtk_source_style_scheme_get_name(b);
return g_utf8_collate(name_a, name_b);
}
errno_t sss_utf8_case_eq(const uint8_t *s1, const uint8_t *s2)
{
gchar *gs1;
gchar *gs2;
gssize n1, n2;
gint gret;
errno_t ret;
n1 = g_utf8_strlen((const gchar *)s1, -1);
n2 = g_utf8_strlen((const gchar *)s2, -1);
gs1 = g_utf8_casefold((const gchar *)s1, n1);
if (gs1 == NULL) {
return ENOMEM;
}
gs2 = g_utf8_casefold((const gchar *)s2, n2);
if (gs2 == NULL) {
return ENOMEM;
}
gret = g_utf8_collate(gs1, gs2);
if (gret == 0) {
ret = EOK;
} else {
ret = ENOMATCH;
}
g_free(gs1);
g_free(gs2);
return ret;
}
