static int lang_collate (gconstpointer a, gconstpointer b) { gboolean clean; Language *l1 = find_lang ((const char *)a, &clean); Language *l2 = find_lang ((const char *)b, &clean); /* paranoia */ if (l1 == NULL || l2 == NULL) return 0; if (l1->collate_key == NULL) { const char *name; name = strchr (_(l1->name), '|'); if (name != NULL) name++; else name = _(l1->name); l1->collate_key = g_utf8_collate_key (name, -1); } if (l2->collate_key == NULL) { const char *name; name = strchr (_(l2->name), '|'); if (name != NULL) name++; else name = _(l2->name); l2->collate_key = g_utf8_collate_key (name, -1); } return strcmp (l1->collate_key, l2->collate_key); }
/** * compare 2 strings unsensitive * if a string is NULL, it will go after the non NULL * * \param string_1 * \param string_2 * * \return -1 string_1 before string_2 (or string_2 NULL) ; 0 if same or NULL everyone ; +1 if string_1 after string_2 (or string_1 NULL) * */ gint my_strcasecmp ( const gchar *string_1, const gchar *string_2 ) { if (!string_1 && string_2) return 1; if (string_1 && !string_2) return -1; if ( string_1 && string_2 ) { if ( g_utf8_validate ( string_1, -1, NULL ) && g_utf8_validate ( string_2, -1, NULL )) { gint retour; gchar *new_1, *new_2; new_1 = g_utf8_collate_key ( g_utf8_casefold ( string_1,-1 ), -1 ); new_2 = g_utf8_collate_key ( g_utf8_casefold ( string_2,-1 ), -1 ); retour = strcmp ( new_1, new_2 ); g_free ( new_1 ); g_free ( new_2 ); return ( retour ); } else return ( g_ascii_strcasecmp ( string_1, string_2 ) ); } return 0; }
static gint _compare_contacts(PContact a, PContact b) { const char * utf8_str_a = NULL; const char * utf8_str_b = NULL; if (p_contact_name(a) != NULL) { utf8_str_a = p_contact_name(a); } else { utf8_str_a = p_contact_barejid(a); } if (p_contact_name(b) != NULL) { utf8_str_b = p_contact_name(b); } else { utf8_str_b = p_contact_barejid(b); } gchar *key_a = g_utf8_collate_key(utf8_str_a, -1); gchar *key_b = g_utf8_collate_key(utf8_str_b, -1); gint result = g_strcmp0(key_a, key_b); g_free(key_a); g_free(key_b); return result; }
gint stringCmp(GString *a, GString *b) { gchar *aKey = g_utf8_collate_key(a->str, a->len); gchar *bKey = g_utf8_collate_key(b->str, b->len); gint cmp = strcmp(aKey, bKey); g_free(aKey); g_free(bKey); return cmp; }
EphyNodeFilterExpression * ephy_node_filter_expression_new (EphyNodeFilterExpressionType type, ...) { EphyNodeFilterExpression *exp; va_list valist; va_start (valist, type); exp = g_new0 (EphyNodeFilterExpression, 1); exp->type = type; switch (type) { case EPHY_NODE_FILTER_EXPRESSION_NODE_EQUALS: exp->args.node_args.a = va_arg (valist, EphyNode *); exp->args.node_args.b = va_arg (valist, EphyNode *); break; case EPHY_NODE_FILTER_EXPRESSION_EQUALS: case EPHY_NODE_FILTER_EXPRESSION_HAS_PARENT: case EPHY_NODE_FILTER_EXPRESSION_HAS_CHILD: exp->args.node_args.a = va_arg (valist, EphyNode *); break; case EPHY_NODE_FILTER_EXPRESSION_NODE_PROP_EQUALS: case EPHY_NODE_FILTER_EXPRESSION_CHILD_PROP_EQUALS: exp->args.prop_args.prop_id = va_arg (valist, int); exp->args.prop_args.second_arg.node = va_arg (valist, EphyNode *); break; case EPHY_NODE_FILTER_EXPRESSION_STRING_PROP_CONTAINS: case EPHY_NODE_FILTER_EXPRESSION_STRING_PROP_EQUALS: exp->args.prop_args.prop_id = va_arg (valist, int); exp->args.prop_args.second_arg.string = g_utf8_casefold (va_arg (valist, char *), -1); break; case EPHY_NODE_FILTER_EXPRESSION_KEY_PROP_CONTAINS: case EPHY_NODE_FILTER_EXPRESSION_KEY_PROP_EQUALS: { char *folded; exp->args.prop_args.prop_id = va_arg (valist, int); folded = g_utf8_casefold (va_arg (valist, char *), -1); exp->args.prop_args.second_arg.string = g_utf8_collate_key (folded, -1); g_free (folded); break; } case EPHY_NODE_FILTER_EXPRESSION_INT_PROP_EQUALS: case EPHY_NODE_FILTER_EXPRESSION_INT_PROP_BIGGER_THAN: case EPHY_NODE_FILTER_EXPRESSION_INT_PROP_LESS_THAN: exp->args.prop_args.prop_id = va_arg (valist, int); exp->args.prop_args.second_arg.number = va_arg (valist, int); break; default: break; } va_end (valist); return exp; }
static GladeStockItem * new_from_values (const gchar *name, const gchar *nick, gint value) { GladeStockItem *new_gsi = NULL; gchar *clean_name; size_t len = 0; guint i = 0; guint j = 0; new_gsi = (GladeStockItem *) g_malloc0 (sizeof(GladeStockItem)); new_gsi->value_name = g_strdup (name); new_gsi->value_nick = g_strdup (nick); new_gsi->value = value; clean_name = g_strdup (name); len = strlen (clean_name); while (i+j <= len) { if (clean_name[i+j] == '_') j++; clean_name[i] = clean_name[i+j]; i++; } new_gsi->clean_name = g_utf8_collate_key (clean_name, i - 1); g_free (clean_name); return new_gsi; }
static Occupant* _muc_occupant_new(const char *const nick, const char *const jid, muc_role_t role, muc_affiliation_t affiliation, resource_presence_t presence, const char *const status) { Occupant *occupant = malloc(sizeof(Occupant)); if (nick) { occupant->nick = strdup(nick); occupant->nick_collate_key = g_utf8_collate_key(occupant->nick, -1); } else { occupant->nick = NULL; occupant->nick_collate_key = NULL; } if (jid) { occupant->jid = strdup(jid); } else { occupant->jid = NULL; } occupant->presence = presence; if (status) { occupant->status = strdup(status); } else { occupant->status = NULL; } occupant->role = role; occupant->affiliation = affiliation; return occupant; }
/** * gimp_tag_new: * @tag_string: a tag name. * * If given tag name is not valid, an attempt will be made to fix it. * * Return value: a new #GimpTag object, or NULL if tag string is invalid and * cannot be fixed. **/ GimpTag * gimp_tag_new (const char *tag_string) { GimpTag *tag; gchar *tag_name; gchar *case_folded; gchar *collate_key; g_return_val_if_fail (tag_string != NULL, NULL); tag_name = gimp_tag_string_make_valid (tag_string); if (! tag_name) return NULL; tag = g_object_new (GIMP_TYPE_TAG, NULL); tag->tag = g_quark_from_string (tag_name); case_folded = g_utf8_casefold (tag_name, -1); collate_key = g_utf8_collate_key (case_folded, -1); tag->collate_key = g_quark_from_string (collate_key); g_free (collate_key); g_free (case_folded); g_free (tag_name); return tag; }
static gint _compare_participants(PContact a, PContact b) { const char * utf8_str_a = p_contact_barejid(a); const char * utf8_str_b = p_contact_barejid(b); gchar *key_a = g_utf8_collate_key(utf8_str_a, -1); gchar *key_b = g_utf8_collate_key(utf8_str_b, -1); gint result = g_strcmp0(key_a, key_b); g_free(key_a); g_free(key_b); return result; }
static gint _compare_occupants(Occupant *a, Occupant *b) { const char * utf8_str_a = a->nick; const char * utf8_str_b = b->nick; gchar *key_a = g_utf8_collate_key(utf8_str_a, -1); gchar *key_b = g_utf8_collate_key(utf8_str_b, -1); gint result = g_strcmp0(key_a, key_b); g_free(key_a); g_free(key_b); return result; }
static Enumerator * enumerator_new (GFile *root, const char *path, gboolean ignore_case) { Enumerator *e; gint i; gchar *case_folded; e = g_new0 (Enumerator, 1); e->path = g_strdup (path); e->ignore_case = ignore_case; e->components = g_strsplit (e->path, G_DIR_SEPARATOR_S, -1); e->depth = g_strv_length (e->components); if (e->ignore_case) { e->case_components = g_new0 (char *, e->depth + 1); for (i = 0; e->components[i]; i++) { case_folded = g_utf8_casefold (e->components[i], -1); e->case_components[i] = g_utf8_collate_key (case_folded, -1); g_free (case_folded); } }
int aw_planet_compare_by_name (AwPlanet *planet_a, AwPlanet *planet_b) { const char *name_a = NULL, *tail_a; const char *name_b = NULL, *tail_b; char *key_a; char *key_b; int num_a; int num_b; int cmp; if (planet_a) name_a = aw_planet_get_name (planet_a); if (planet_b) name_b = aw_planet_get_name (planet_b); if (name_a == name_b) return 0; if (!name_a) return -1; if (!name_b) return +1; tail_a = strrchr (name_a, ' '); tail_b = strrchr (name_b, ' '); key_a = g_utf8_collate_key (name_a, tail_a - name_a); key_b = g_utf8_collate_key (name_b, tail_b - name_b); cmp = strcmp (key_a, key_b); g_free (key_a); g_free (key_b); if (0 != cmp || 1 != sscanf (tail_a, "%d", &num_a) || 1 != sscanf (tail_b, "%d", &num_b)) return cmp; if (num_a < num_b) return -1; if (num_a > num_b) return +1; return 0; }
static gboolean gnc_create_extension_info (SCM extension) { ExtensionInfo *ext_info; gchar *typeStr, *tmp; gchar* name; gchar* guid; ext_info = g_new0(ExtensionInfo, 1); ext_info->extension = extension; gnc_extension_path(extension, &ext_info->path); if (!gnc_extension_type( extension, &ext_info->type )) { /* Can't parse the type passed to us. Bail now. */ g_free(ext_info); return FALSE; } /* Get all the pieces */ name = gnc_extension_name(extension); guid = gnc_extension_guid(extension); ext_info->ae.label = g_strdup(gettext(name)); ext_info->ae.name = gnc_ext_gen_action_name(guid); ext_info->ae.tooltip = gnc_extension_documentation(extension); ext_info->ae.stock_id = NULL; ext_info->ae.accelerator = NULL; ext_info->ae.callback = NULL; g_free(name); g_free(guid); tmp = g_strdup_printf("%s/%s", ext_info->path, ext_info->ae.label); ext_info->sort_key = g_utf8_collate_key(tmp, -1); g_free(tmp); switch (ext_info->type) { case GTK_UI_MANAGER_MENU: typeStr = "menu"; break; case GTK_UI_MANAGER_MENUITEM: typeStr = "menuitem"; break; default: typeStr = "unk"; break; } ext_info->typeStr = typeStr; DEBUG( "extension: %s/%s [%s] tip [%s] type %s\n", ext_info->path, ext_info->ae.label, ext_info->ae.name, ext_info->ae.tooltip, ext_info->typeStr ); scm_gc_protect_object(extension); /* need to append so we can run them in order */ extension_list = g_slist_append(extension_list, ext_info); return TRUE; }
static char *isort_key(char *src) { char *s; src = g_utf8_casefold(src, -1); s = g_utf8_collate_key(src, -1); g_free(src); return (s); }
/* make sure the font list is valid */ static void ensure_font_list (FontViewModel *self) { FcPattern *pat; FcObjectSet *os; gint i; FcChar8 *file; gchar *font_name, *collation_key; GdkPixbuf *pix; if (self->priv->font_list) { FcFontSetDestroy (self->priv->font_list); self->priv->font_list = NULL; } gtk_list_store_clear (GTK_LIST_STORE (self)); /* always reinitialize the font database */ if (!FcInitReinitialize()) return; pat = FcPatternCreate (); os = FcObjectSetBuild (FC_FILE, FC_FAMILY, FC_WEIGHT, FC_SLANT, NULL); self->priv->font_list = FcFontList (NULL, pat, os); FcPatternDestroy (pat); FcObjectSetDestroy (os); if (!self->priv->font_list) return; for (i = 0; i < self->priv->font_list->nfont; i++) { FcPatternGetString (self->priv->font_list->fonts[i], FC_FILE, 0, &file); font_name = font_utils_get_font_name_for_file (self->priv->library, (const gchar *) file); if (!font_name) continue; pix = get_fallback_icon (); collation_key = g_utf8_collate_key (font_name, -1); gtk_list_store_insert_with_values (GTK_LIST_STORE (self), NULL, -1, COLUMN_NAME, font_name, COLUMN_POINTER, self->priv->font_list->fonts[i], COLUMN_PATH, file, COLUMN_ICON, pix, COLUMN_COLLATION_KEY, collation_key, -1); ensure_thumbnail (self, (const gchar *) file); g_free (font_name); g_free (collation_key); g_object_unref (pix); } }
static gint shell_app_info_compare (gconstpointer a, gconstpointer b, gpointer data) { ShellAppSystem *system = data; const char *id_a = a; const char *id_b = b; ShellAppInfo *info_a = g_hash_table_lookup (system->priv->app_id_to_info, id_a); ShellAppInfo *info_b = g_hash_table_lookup (system->priv->app_id_to_info, id_b); if (!info_a->name_collation_key) info_a->name_collation_key = g_utf8_collate_key (gmenu_tree_entry_get_name ((GMenuTreeEntry*)info_a->entry), -1); if (!info_b->name_collation_key) info_b->name_collation_key = g_utf8_collate_key (gmenu_tree_entry_get_name ((GMenuTreeEntry*)info_b->entry), -1); return strcmp (info_a->name_collation_key, info_b->name_collation_key); }
void p_contact_set_name(const PContact contact, const char *const name) { FREE_SET_NULL(contact->name); FREE_SET_NULL(contact->name_collate_key); if (name) { contact->name = strdup(name); contact->name_collate_key = g_utf8_collate_key(contact->name, -1); } }
static gboolean search_callback(GtkTreeModel*, int, const char* key, GtkTreeIter* iter, void* data) { wxListBox* listbox = static_cast<wxListBox*>(data); wxTreeEntry* entry = GetEntry(listbox->m_liststore, iter, listbox); wxCHECK_MSG(entry, true, "could not get entry"); wxGtkString keyc(g_utf8_collate_key(key, -1)); return strncmp(keyc, wx_tree_entry_get_collate_key(entry), strlen(keyc)); }
void _cinnamon_app_set_entry (CinnamonApp *app, GMenuTreeEntry *entry) { if (app->entry != NULL) gmenu_tree_item_unref (app->entry); app->entry = gmenu_tree_item_ref (entry); if (app->name_collation_key != NULL) g_free (app->name_collation_key); app->name_collation_key = g_utf8_collate_key (cinnamon_app_get_name (app), -1); }
gint compare_utf8_str(const gchar *str1, const gchar *str2) { gchar *key1, *key2; gint ret = 0; if (!str1) return 1; if (!str2) return -1; key1 = g_utf8_collate_key(str1, -1); key2 = g_utf8_collate_key(str2, -1); ret = strcmp(key1, key2); g_free(key1); g_free(key2); return ret; }
PContact p_contact_new(const char *const barejid, const char *const name, GSList *groups, const char *const subscription, const char *const offline_message, gboolean pending_out) { PContact contact = malloc(sizeof(struct p_contact_t)); contact->barejid = strdup(barejid); contact->barejid_collate_key = g_utf8_collate_key(contact->barejid, -1); if (name) { contact->name = strdup(name); contact->name_collate_key = g_utf8_collate_key(contact->name, -1); } else { contact->name = NULL; contact->name_collate_key = NULL; } contact->groups = groups; if (subscription) contact->subscription = strdup(subscription); else contact->subscription = strdup("none"); if (offline_message) contact->offline_message = strdup(offline_message); else contact->offline_message = NULL; contact->pending_out = pending_out; contact->last_activity = NULL; contact->available_resources = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)resource_destroy); contact->resource_ac = autocomplete_new(); return contact; }
static gboolean gtk_listbox_searchequal_callback(GtkTreeModel * WXUNUSED(model), gint WXUNUSED(column), const gchar* key, GtkTreeIter* iter, wxListBox* listbox) { wxTreeEntry* entry = GetEntry(listbox->m_liststore, iter, listbox); wxCHECK_MSG(entry, 0, wxT("Could not get entry")); wxGtkString keycollatekey(g_utf8_collate_key(key, -1)); return strcmp(keycollatekey, wx_tree_entry_get_collate_key(entry)) != 0; }
gboolean rb_string_list_equal (GList *a, GList *b) { GList *sorted_a_keys; GList *sorted_b_keys; GList *a_ptr, *b_ptr; gboolean ret = TRUE; if (a == b) return TRUE; if (g_list_length (a) != g_list_length (b)) return FALSE; for (sorted_a_keys = NULL; a; a = a->next) { sorted_a_keys = g_list_prepend (sorted_a_keys, g_utf8_collate_key (a->data, -1)); } for (sorted_b_keys = NULL; b; b = b->next) { sorted_b_keys = g_list_prepend (sorted_b_keys, g_utf8_collate_key (b->data, -1)); } sorted_a_keys = g_list_sort (sorted_a_keys, (GCompareFunc) strcmp); sorted_b_keys = g_list_sort (sorted_b_keys, (GCompareFunc) strcmp); for (a_ptr = sorted_a_keys, b_ptr = sorted_b_keys; a_ptr && b_ptr; a_ptr = a_ptr->next, b_ptr = b_ptr->next) { if (strcmp (a_ptr->data, b_ptr->data)) { ret = FALSE; break; } } g_list_foreach (sorted_a_keys, (GFunc) g_free, NULL); g_list_foreach (sorted_b_keys, (GFunc) g_free, NULL); g_list_free (sorted_a_keys); g_list_free (sorted_b_keys); return ret; }
void gtk_tree_entry_set_label (GtkTreeEntry* entry, const gchar* label) { g_assert(GTK_IS_TREE_ENTRY(entry)); /* free previous if it exists */ if(entry->label) { g_free(entry->label); g_free(entry->collate_key); } entry->label = g_strdup(label); entry->collate_key = g_utf8_collate_key(label, -1); /* -1 == null terminated */ }
/* Determine where, if at all, a UTF8 substring occurs within another * UTF8 string. Return a pointer to the start of the substring, or * NULL if not found. */ static gchar* find_utf8_substr(gchar *str, gchar *substr) { /* record the first character of substr for scanning */ gunichar first = g_utf8_get_char(substr) ; /* record the collation key for substr for comparison */ gchar* substr_key = g_utf8_collate_key(substr, -1) ; /* record the length of substr, in bytes, for comparison. do this by finding the length, in utf8 characters, converting that to a pointer, then using pointer arithmetic to find the byte length. */ gssize len = g_utf8_offset_to_pointer(substr, g_utf8_strlen(substr, -1)) - substr ; /* scan the string looking for 'first' */ for ( /* start at the first occurrence of 'first' */ str = g_utf8_strchr(str, -1, first) ; /* continue as long as 'first' was found */ str != NULL ; /* for the next iteration, advance to the next occurrence * of 'first' */ str = g_utf8_strchr(g_utf8_next_char(str), -1, first) ) { /* compute the collation key for the 'len'-length * substring located at 'str' */ gchar* this_key = g_utf8_collate_key(str, len) ; /* get our comparison value */ int this_comp = strcmp(substr_key, this_key) ; /* free the collation key */ g_free(this_key) ; /* if comparison was 0 (equal), break out of the scan loop */ if (this_comp == 0) { break ; /* out of for(...) loop */ } } /* free up the collation key */ g_free(substr_key) ; /* return the result */ return(str) ; }
gint utf8_compare(const gchar *s1, const gchar *s2, gboolean case_sensitive) { gchar *s1_key, *s2_key; gchar *s1_t, *s2_t; gint ret; g_assert(g_utf8_validate(s1, -1, NULL)); g_assert(g_utf8_validate(s2, -1, NULL)); if (!case_sensitive) { s1_t = g_utf8_casefold(s1, -1); s2_t = g_utf8_casefold(s2, -1); } else { s1_t = (gchar *) s1; s2_t = (gchar *) s2; } s1_key = g_utf8_collate_key(s1_t, -1); s2_key = g_utf8_collate_key(s2_t, -1); ret = strcmp(s1_key, s2_key); g_free(s1_key); g_free(s2_key); if (!case_sensitive) { g_free(s1_t); g_free(s2_t); } return ret; }
gint dh_link_compare (gconstpointer a, gconstpointer b) { DhLink *la = (DhLink *) a; DhLink *lb = (DhLink *) b; gint flags_diff; /* Sort deprecated hits last. */ flags_diff = (la->flags & DH_LINK_FLAGS_DEPRECATED) - (lb->flags & DH_LINK_FLAGS_DEPRECATED); if (flags_diff != 0) { return flags_diff; } /* Collation-based sorting */ if (G_UNLIKELY (!la->name_collation_key)) la->name_collation_key = g_utf8_collate_key (la->name, -1); if (G_UNLIKELY (!lb->name_collation_key)) lb->name_collation_key = g_utf8_collate_key (lb->name, -1); return strcmp (la->name_collation_key, lb->name_collation_key); }
char *token_collate_key ( const char *token, int case_sensitive ) { char *tmp, *compk; if ( case_sensitive ) { tmp = g_strdup ( token ); } else { tmp = g_utf8_casefold ( token, -1 ); } compk = g_utf8_collate_key ( tmp, -1 ); g_free ( tmp ); return compk; }
/** * Accepts incoming channel data from inbound.c, allocates new space for a * chanlistrow, adds it to our linked list and calls chanlist_place_row_in_gui. */ void fe_add_chan_list (server *serv, char *chan, char *users, char *topic) { auto len = strlen (chan) + 1; chanlistrow * next_row = new chanlistrow; next_row->topic = strip_color(topic, STRIP_ALL); glib_string collation_key(g_utf8_collate_key(chan, len - 1)); next_row->collation_key = collation_key ? collation_key.get() : chan; next_row->users = atoi (users); /* add this row to the data */ serv->gui->chanlist_data_stored_rows = g_slist_prepend (serv->gui->chanlist_data_stored_rows, next_row); /* _possibly_ add the row to the gui */ chanlist_place_row_in_gui (*serv->gui, next_row, FALSE); }
static void plug_in_menus_tree_insert (GTree *entries, const gchar *path, PlugInMenuEntry *entry) { gchar *strip = gimp_strip_uline (path); gchar *key; /* Append the procedure name to the menu path in order to get a unique * key even if two procedures are installed to the same menu entry. */ key = g_strconcat (strip, gimp_object_get_name (entry->proc), NULL); g_tree_insert (entries, g_utf8_collate_key (key, -1), entry); g_free (key); g_free (strip); }