Пример #1
0
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);
}
Пример #2
0
/**
 * 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;
}
Пример #3
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;
}
Пример #4
0
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;
}
Пример #5
0
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;
}
Пример #6
0
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;
}
Пример #7
0
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;
}
Пример #8
0
/**
 * 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;
}
Пример #9
0
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;
}
Пример #10
0
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;
}
Пример #11
0
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);
        }
    }
Пример #12
0
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;
}
Пример #13
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;
}
Пример #14
0
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);
}
Пример #15
0
/* 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);
}
Пример #17
0
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);
    }
}
Пример #18
0
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));
}
Пример #19
0
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);
}
Пример #20
0
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;
}
Пример #21
0
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;
}
Пример #22
0
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;
}
Пример #23
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;
}
Пример #24
0
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 */
}
Пример #25
0
/*  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) ;
}
Пример #26
0
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;
}
Пример #27
0
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);
}
Пример #28
0
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;
}
Пример #29
0
/**
 * 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);
}
Пример #30
0
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);
}