void send_edge_data_changed(Network *network, const GraphEdge *edge, gpointer user_data) { UiConnection *ui = (UiConnection *)user_data; // FIXME: remove once noflo-ui no longer needs it gchar *src_port = g_utf8_strup(edge->src_port, -1); gchar *tgt_port = g_utf8_strup(edge->tgt_port, -1); gchar *edge_id = g_strdup_printf("%s() %s -> %s %s()", edge->src_name, src_port, tgt_port, edge->tgt_name); g_free(src_port); g_free(tgt_port); gchar *url = ui_get_process_url(ui, network, edge->src_name); JsonObject *payload = graph_edge_to_json(edge); json_object_set_string_member(payload, "graph", network->graph->id); json_object_set_string_member(payload, "id", edge_id); JsonObject *data = json_object_new(); json_object_set_object_member(payload, "data", data); json_object_set_string_member(data, "url", url); json_object_set_string_member(data, "type", "previewurl"); g_free(url); if (ui->connection) { send_response(ui->connection, "network", "data", payload); } }
static gboolean part_list_filter_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer data) { char *part_name; const char *s; // Auxiliary parameters shall keep their number in upcase char *comp1, *comp2; Browser *br = (Browser *)data; s = gtk_entry_get_text (GTK_ENTRY (br->filter_entry)); // Without filter, the part is shown if (s == NULL) return TRUE; if (br->filter_len == 0) return TRUE; gtk_tree_model_get (model, iter, 0, &part_name, -1); if (part_name) { comp1 = g_utf8_strup (s, -1); comp2 = g_utf8_strup (part_name, -1); if (g_strrstr (comp2, comp1)) { g_free (comp1); g_free (comp2); return TRUE; } g_free (comp1); g_free (comp2); } return FALSE; }
static int plugin_compare(PurplePlugin *p1, PurplePlugin *p2) { char *s1 = g_utf8_strup(p1->info->name, -1); char *s2 = g_utf8_strup(p2->info->name, -1); int ret = g_utf8_collate(s1, s2); g_free(s1); g_free(s2); return ret; }
static gchar * xkl_create_description_from_list (const XklConfigItem * item, const XklConfigItem * subitem, const gchar * prop_name, const gchar * (*desc_getter) (const gchar * code)) { gchar *rv = NULL, *code = NULL; gchar **list = NULL; const gchar *desc; if (subitem != NULL) list = (gchar **) (g_object_get_data (G_OBJECT (subitem), prop_name)); if (list == NULL || *list == 0) list = (gchar **) (g_object_get_data (G_OBJECT (item), prop_name)); /* First try the parent id as such */ desc = desc_getter (item->name); if (desc != NULL) { rv = g_utf8_strup (desc, -1); } else { code = g_utf8_strup (item->name, -1); desc = desc_getter (code); if (desc != NULL) { rv = g_utf8_strup (desc, -1); } g_free (code); } if (list == NULL || *list == 0) return rv; while (*list != 0) { code = *list++; desc = desc_getter (code); if (desc != NULL) { gchar *udesc = g_utf8_strup (desc, -1); if (rv == NULL) { rv = udesc; } else { gchar *orv = rv; rv = g_strdup_printf ("%s %s", rv, udesc); g_free (orv); g_free (udesc); } } } return rv; }
static int plugin_compare(PurplePlugin *p1, PurplePlugin *p2) { char *s1 = g_utf8_strup(purple_plugin_info_get_name(purple_plugin_get_info(p1)), -1); char *s2 = g_utf8_strup(purple_plugin_info_get_name(purple_plugin_get_info(p2)), -1); int ret = g_utf8_collate(s1, s2); g_free(s1); g_free(s2); return ret; }
/* * meh_widget_text_reload writes the text on a texture and store it in the WidgetText. */ void meh_widget_text_reload(Window* window, WidgetText* text) { if (text->texture != NULL) { SDL_DestroyTexture(text->texture); } SDL_Color color = { text->r.value, text->g.value, text->b.value, text->a.value, }; gchar* to_render = text->text; if (text->uppercase) { to_render = g_utf8_strup(text->text, -1); } /* Render the text on a texture. */ if (!text->multi) { text->texture = meh_window_render_text_texture(window, text->font, to_render, color, -1.0f); } else { text->texture = meh_window_render_text_texture(window, text->font, to_render, color, meh_window_convert_width(window, text->w)); } if (text->uppercase) { g_free(to_render); } SDL_QueryTexture(text->texture, NULL, NULL, &text->tex_w, &text->tex_h); g_debug("Texture for text %s loaded (%dx%d).", text->text, text->tex_w, text->tex_h); /* restart the movement infos */ meh_widget_text_reset_move(text); }
static void doc_code_selection(Tdocument * doc, Treplace_mode mode) { gint start, end; if (doc_get_selection(doc, &start, &end)) { gchar *inbuf, *outbuf = NULL; inbuf = doc_get_chars(doc, start, end); switch (mode) { case mode_urlencode: outbuf = g_uri_escape_string(inbuf, NULL, FALSE); break; case mode_urldecode: outbuf = g_uri_unescape_string(inbuf, NULL); break; case mode_tolowercase: if (inbuf) outbuf = g_utf8_strdown(inbuf, -1); break; case mode_touppercase: if (inbuf) outbuf = g_utf8_strup(inbuf, -1); break; } g_free(inbuf); if (outbuf) { doc_replace_text(doc, outbuf, start, end); g_free(outbuf); } } }
static gchar* enchant_utf8_strtitle(const gchar*str, gssize len) { gunichar title_case_char; gchar* result; gchar* upperStr, * upperTail, * lowerTail; gchar title_case_utf8[7]; gint utf8len; upperStr = g_utf8_strup(str, len); /* for locale sensitive casing */ title_case_char = g_unichar_totitle(g_utf8_get_char(upperStr)); utf8len = g_unichar_to_utf8(title_case_char, title_case_utf8); title_case_utf8[utf8len] = '\0'; upperTail = g_utf8_next_char(upperStr); lowerTail = g_utf8_strdown(upperTail, -1); result = g_strconcat(title_case_utf8, lowerTail, NULL); g_free(upperStr); g_free(lowerTail); return result; }
static char * userinfo_hash(PurpleAccount *account, const char *who) { char key[256]; g_snprintf(key, sizeof(key), "%s - %s", purple_account_get_username(account), purple_normalize(account, who)); return g_utf8_strup(key, -1); }
static void xkb_layout_filter_changed (GtkBuilder * chooser_dialog) { GtkTreeModelFilter *filtered_model = GTK_TREE_MODEL_FILTER (gtk_builder_get_object (chooser_dialog, "filtered_layout_list_model")); GtkWidget *xkb_layout_filter = CWID ("xkb_layout_filter"); const gchar *pattern = gtk_entry_get_text (GTK_ENTRY (xkb_layout_filter)); gchar *upattern = g_utf8_strup (pattern, -1); if (!g_strcmp0 (pattern, "")) { g_object_set (G_OBJECT (xkb_layout_filter), "secondary-icon-name", "edit-find-symbolic", "secondary-icon-activatable", FALSE, "secondary-icon-sensitive", FALSE, NULL); } else { g_object_set (G_OBJECT (xkb_layout_filter), "secondary-icon-name", "edit-clear-symbolic", "secondary-icon-activatable", TRUE, "secondary-icon-sensitive", TRUE, NULL); } if (search_pattern_list != NULL) g_strfreev (search_pattern_list); search_pattern_list = g_strsplit (upattern, " ", -1); g_free (upattern); gtk_tree_model_filter_refilter (filtered_model); }
void on_protocol_edit_ok_clicked (GtkButton * button, gpointer user_data) { gchar *proto_string; GtkTreePath *gpath = NULL; GtkTreeViewColumn *gcol = NULL; GtkTreeIter it; GtkComboBoxEntry *cbox; EATreePos ep; if (!get_color_store (&ep)) return; /* gets the row (path) at cursor */ gtk_tree_view_get_cursor (ep.gv, &gpath, &gcol); if (!gpath) return; /* no row selected */ if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (ep.gs), &it, gpath)) return; /* path not found */ cbox = GTK_COMBO_BOX_ENTRY(glade_xml_get_widget (appdata.xml, "protocol_entry")); proto_string = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cbox)); proto_string = g_utf8_strup (proto_string, -1); proto_string = remove_spaces(proto_string); cbox_add_select(cbox, proto_string); gtk_list_store_set (ep.gs, &it, 2, proto_string, -1); g_free (proto_string); gtk_widget_hide (glade_xml_get_widget (appdata.xml, "protocol_edit_dialog")); colors_changed = TRUE; color_list_to_pref (); } /* on_protocol_edit_ok_clicked */
/** * seahorse_util_string_up_first: * @orig: The utf8 string to work with * * Upper case the first char in the UTF8 string * * Returns: a new string, with the first char upper cased. The returned string * should be freed with #g_free when no longer needed. */ gchar* seahorse_util_string_up_first (const gchar *orig) { gchar *t, *t2, *ret; if (g_utf8_validate (orig, -1, NULL)) { t = g_utf8_find_next_char (orig, NULL); if (t != NULL) { t2 = g_utf8_strup (orig, t - orig); ret = g_strdup_printf ("%s%s", t2, t); g_free (t2); /* Can't find first UTF8 char */ } else { ret = g_strdup (orig); } /* Just use ASCII functions when not UTF8 */ } else { ret = g_strdup (orig); ret[0] = g_ascii_toupper (ret[0]); } return ret; }
void search_foreach(playlist_t * pl, GPatternSpec * pattern, GtkTreeIter * list_iter, int album_node) { char text[MAXLEN]; char * tmp = NULL; playlist_data_t * pldata; gtk_tree_model_get(GTK_TREE_MODEL(pl->store), list_iter, PL_COL_DATA, &pldata, -1); if (album_node) { snprintf(text, MAXLEN-1, "%s: %s", pldata->artist, pldata->album); } else { playlist_data_get_display_name(text, pldata); } if (casesens) { tmp = strdup(text); } else { tmp = g_utf8_strup(text, -1); } if (g_pattern_match_string(pattern, tmp)) { GtkTreeIter iter; GtkTreePath * path; path = gtk_tree_model_get_path(GTK_TREE_MODEL(pl->store), list_iter); gtk_list_store_append(search_store, &iter); gtk_list_store_set(search_store, &iter, 0, text, 1, (gpointer)path, 2, pl->name, 3, (gpointer)pl, -1); } g_free(tmp); }
/* Implementations of locale-specific operations; these are used * in the implementation of String.localeCompare(), Date.toLocaleDateString(), * and so forth. We take the straight-forward approach of converting * to UTF-8, using the appropriate GLib functions, and converting * back if necessary. */ static JSBool gjs_locale_to_upper_case (JSContext *context, JSString *src, jsval *retval) { JSBool success = JS_FALSE; char *utf8 = NULL; char *upper_case_utf8 = NULL; if (!gjs_string_to_utf8(context, STRING_TO_JSVAL(src), &utf8)) goto out; upper_case_utf8 = g_utf8_strup (utf8, -1); if (!gjs_string_from_utf8(context, upper_case_utf8, -1, retval)) goto out; success = JS_TRUE; out: g_free(utf8); g_free(upper_case_utf8); return success; }
static void contact_draw (EContact *contact, EContactPrintContext *ctxt) { GtkPageSetup *setup; gdouble page_height; gchar *file_as; gboolean new_section = FALSE; setup = gtk_print_context_get_page_setup (ctxt->context); page_height = gtk_page_setup_get_page_height (setup, GTK_UNIT_POINTS); file_as = e_contact_get (contact, E_CONTACT_FILE_AS); if (file_as != NULL) { gchar *section; gsize width; width = g_utf8_next_char (file_as) - file_as; section = g_utf8_strup (file_as, width); new_section = (ctxt->section == NULL || g_utf8_collate (ctxt->section, section) != 0); if (new_section) { g_free (ctxt->section); ctxt->section = section; } else g_free (section); } if (new_section) { if (!ctxt->first_contact) { if (ctxt->style->sections_start_new_page) e_contact_start_new_page (ctxt); else if ((ctxt->y + e_contact_get_contact_height ( contact, ctxt)) > page_height) e_contact_start_new_column (ctxt); } if (ctxt->style->letter_headings) e_contact_print_letter_heading (ctxt, ctxt->section); ctxt->first_section = FALSE; } else if (!ctxt->first_contact && ((ctxt->y + e_contact_get_contact_height (contact, ctxt)) > page_height)) { e_contact_start_new_column (ctxt); if (ctxt->style->letter_headings) e_contact_print_letter_heading (ctxt, ctxt->section); } e_contact_print_contact (contact, ctxt); ctxt->first_contact = FALSE; }
void on_toggle_case1_activate(GtkMenuItem *menuitem, gpointer user_data) { GeanyDocument *doc = document_get_current(); ScintillaObject *sci; gchar *text; gboolean keep_sel = TRUE; g_return_if_fail(doc != NULL); sci = doc->editor->sci; if (! sci_has_selection(sci)) { keybindings_send_command(GEANY_KEY_GROUP_SELECT, GEANY_KEYS_SELECT_WORD); keep_sel = FALSE; } /* either we already had a selection or we created one for current word */ if (sci_has_selection(sci)) { gchar *result = NULL; gint cmd = SCI_LOWERCASE; gboolean rectsel = (gboolean) scintilla_send_message(sci, SCI_SELECTIONISRECTANGLE, 0, 0); text = sci_get_selection_contents(sci); if (utils_str_has_upper(text)) { if (rectsel) cmd = SCI_LOWERCASE; else result = g_utf8_strdown(text, -1); } else { if (rectsel) cmd = SCI_UPPERCASE; else result = g_utf8_strup(text, -1); } if (result != NULL) { sci_replace_sel(sci, result); g_free(result); if (keep_sel) sci_set_selection_start(sci, sci_get_current_position(sci) - strlen(text)); } else sci_send_command(sci, cmd); g_free(text); } }
gchar * mousepad_util_utf8_strcapital (const gchar *str) { gunichar c; const gchar *p; gchar *buf; GString *result; gboolean upper = TRUE; g_return_val_if_fail (g_utf8_validate (str, -1, NULL), NULL); /* create a new string */ result = g_string_sized_new (strlen (str)); /* walk though the string */ for (p = str; *p != '\0'; p = g_utf8_next_char (p)) { /* get the unicode char */ c = g_utf8_get_char (p); /* only change the case of alpha chars */ if (g_unichar_isalpha (c)) { /* check case */ if (upper ? g_unichar_isupper (c) : g_unichar_islower (c)) { /* currect case is already correct */ g_string_append_unichar (result, c); } else { /* convert the case of the char and append it */ buf = upper ? g_utf8_strup (p, 1) : g_utf8_strdown (p, 1); g_string_append (result, buf); g_free (buf); } /* next char must be lowercase */ upper = FALSE; } else { /* append the char */ g_string_append_unichar (result, c); /* next alpha char uppercase after a space */ upper = g_unichar_isspace (c); } } /* return the result */ return g_string_free (result, FALSE); }
/* * call-seq: * utf8_upcase(string) * * Returns the string in capitals if they are are available for the supplied characters. * * Glib.utf8_upcase('Sluß') #=> SLUSS */ static VALUE utf8_upcase(VALUE self, VALUE string) { VALUE result; gchar *temp; Check_Type(string, T_STRING); temp = g_utf8_strup(StringValuePtr(string), RSTRING_LEN(string)); result = rb_str_new2(temp); free(temp); return result; }
static void filter_changed (GtkBuilder *builder) { GtkTreeModelFilter *filtered_model; GtkTreeView *tree_view; GtkTreeSelection *selection; GtkTreeIter selected_iter; GtkWidget *filter_entry; const gchar *pattern; gchar *upattern; filter_entry = WID ("input_source_filter"); pattern = gtk_entry_get_text (GTK_ENTRY (filter_entry)); upattern = g_utf8_strup (pattern, -1); if (!g_strcmp0 (pattern, "")) g_object_set (G_OBJECT (filter_entry), "secondary-icon-name", "edit-find-symbolic", "secondary-icon-activatable", FALSE, "secondary-icon-sensitive", FALSE, NULL); else g_object_set (G_OBJECT (filter_entry), "secondary-icon-name", "edit-clear-symbolic", "secondary-icon-activatable", TRUE, "secondary-icon-sensitive", TRUE, NULL); if (search_pattern_list != NULL) g_strfreev (search_pattern_list); search_pattern_list = g_strsplit (upattern, " ", -1); g_free (upattern); filtered_model = GTK_TREE_MODEL_FILTER (gtk_builder_get_object (builder, "filtered_input_source_model")); gtk_tree_model_filter_refilter (filtered_model); tree_view = GTK_TREE_VIEW (WID ("filtered_input_source_list")); selection = gtk_tree_view_get_selection (tree_view); if (gtk_tree_selection_get_selected (selection, NULL, &selected_iter)) { GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (filtered_model), &selected_iter); gtk_tree_view_scroll_to_cell (tree_view, path, NULL, TRUE, 0.5, 0.5); gtk_tree_path_free (path); } else { GtkTreeIter iter; if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (filtered_model), &iter)) gtk_tree_selection_select_iter (selection, &iter); } }
fs_value fn_ucase(fs_query *q, fs_value v) { if (!fs_is_plain_or_string(v)) { return fs_value_error(FS_ERROR_INVALID_TYPE, NULL); } v = fs_value_fill_lexical(q, v); char *lex = g_utf8_strup(v.lex, -1); fs_query_add_freeable(q, lex); fs_value ret = fs_value_plain(lex); ret.attr = v.attr; return ret; }
RESULT test_utf8_strcase_each (const gchar *src, const gchar *expected, gboolean strup) { gchar *tmp; glong len, len2; RESULT r; len = utf8_byteslen (src); tmp = strup ? g_utf8_strup (src, len) : g_utf8_strdown (src, len); len2 = utf8_byteslen (tmp); r = compare_strings_utf8_RESULT (expected, tmp, len < len2 ? len2 : len); g_free (tmp); return r; }
static char * get_type_name (char *filename) { char *ext; ext = strrchr (filename, '.'); if (!ext) return g_strdup (_("Unknown")); ext = g_utf8_strup (ext + 1, -1); if (strcmp (ext, "BMP") == 0) { g_free (ext); return g_strdup (_("Bitmap Image")); } else if (strcmp (ext, "JPG") == 0) { g_free (ext); return g_strdup (_("JPEG Image")); } else if (strcmp (ext, "GIF") == 0) { g_free (ext); return g_strdup (_("GIF Image")); } else if (strcmp (ext, "PNG") == 0) { g_free (ext); return g_strdup (_("PNG Image")); } else if (strcmp (ext, "TXT") == 0) { g_free (ext); return g_strdup (_("Text File")); } else if (strcmp (ext, "WAV") == 0) { g_free (ext); return g_strdup (_("Wave Sound")); } else if (strcmp (ext, "MP3") == 0) { g_free (ext); return g_strdup (_("MP3 Music")); } else if (strcmp (ext, "SPR") == 0) { g_free (ext); return g_strdup (_("Sprite Data")); } else if (strcmp (ext, "XML") == 0) { g_free (ext); return g_strdup (_("XML Document")); } else return ext; }
static void xsltp_extension_string_uc(xmlXPathParserContextPtr ctxt, int nargs) { xmlChar *str; if (nargs != 1) { xmlXPathSetArityError(ctxt); return; } str = xmlXPathPopString(ctxt); xmlXPathReturnString(ctxt, (xmlChar *) g_utf8_strup((const gchar *) str, -1)); xmlFree(str); }
static gboolean is_date_column(sqlite3_stmt* query, int i) { gboolean res; const char* column_type = sqlite3_column_decltype(query, i); char* column_type_up = (column_type == NULL)? NULL: g_utf8_strup(column_type, -1); if((column_type_up != NULL) && (strcmp(column_type_up, "DATE") == 0)) res = TRUE; else res = FALSE; g_free(column_type_up); return res; }
static gboolean xkb_filter_layouts (GtkTreeModel * model, GtkTreeIter * iter, gpointer data) { gchar *desc = NULL, *country_desc = NULL, *language_desc = NULL, **pattern; gboolean rv = TRUE; if (search_pattern_list == NULL || search_pattern_list[0] == NULL) return TRUE; gtk_tree_model_get (model, iter, COMBO_BOX_MODEL_COL_SORT, &desc, COMBO_BOX_MODEL_COL_COUNTRY_DESC, &country_desc, COMBO_BOX_MODEL_COL_LANGUAGE_DESC, &language_desc, -1); pattern = search_pattern_list; do { gboolean is_pattern_found = FALSE; gchar *udesc = g_utf8_strup (desc, -1); if (udesc != NULL && g_strstr_len (udesc, -1, *pattern)) { is_pattern_found = TRUE; } else if (country_desc != NULL && g_strstr_len (country_desc, -1, *pattern)) { is_pattern_found = TRUE; } else if (language_desc != NULL && g_strstr_len (language_desc, -1, *pattern)) { is_pattern_found = TRUE; } g_free (udesc); if (!is_pattern_found) { rv = FALSE; break; } } while (*++pattern != NULL); g_free (desc); g_free (country_desc); g_free (language_desc); return rv; }
SWORD_NAMESPACE_START char *GS_StringMgr::upperUTF8(char *text, unsigned int maxlen) const { if ((text == NULL) || (*text == '\0')) { return g_strdup(""); } if (maxlen == 0) maxlen = strlen(text); char *upper_str = g_utf8_strup(text, -1); unsigned int newlen = strlen(upper_str); if (newlen >= maxlen) newlen = maxlen; memcpy(text, upper_str, newlen); //text[newlen] = 0; // be sure we're null terminated. g_free(upper_str); return text; }
int main() { static char buffer[1048576]; size_t read_bytes = fread(buffer, 1, sizeof(buffer) - 1, stdin); printf("%zu\n", read_bytes); if (read_bytes < 1) { return EXIT_FAILURE; } size_t data_bytes = read_bytes; char* buffer_pointer = buffer; g_free(g_utf8_strup(buffer_pointer, data_bytes)); g_free(g_utf8_strdown(buffer_pointer, data_bytes)); g_free(g_utf8_normalize(buffer_pointer, data_bytes, G_NORMALIZE_DEFAULT)); g_free(g_utf8_collate_key(buffer_pointer, data_bytes)); g_free(g_utf8_collate_key_for_filename(buffer_pointer, data_bytes)); return EXIT_SUCCESS; }
static EnchantTrie* enchant_trie_get_subtrie(EnchantTrie* trie, EnchantTrieMatcher* matcher, char** nxtChS) { EnchantTrie* subtrie; if(trie->subtries == NULL || *nxtChS == NULL) return NULL; subtrie = g_hash_table_lookup(trie->subtries,*nxtChS); if(subtrie == NULL && matcher->mode == case_insensitive) { char* nxtChSUp = g_utf8_strup(*nxtChS, -1); /* we ignore the title case scenario since that will give us an edit_distance of one which is acceptable since this mode is used for suggestions*/ g_free(*nxtChS); *nxtChS = nxtChSUp; subtrie = g_hash_table_lookup(trie->subtries,nxtChSUp); } return subtrie; }
gchar * mousepad_util_utf8_stropposite (const gchar *str) { gunichar c; const gchar *p; gchar *buf; GString *result; g_return_val_if_fail (g_utf8_validate (str, -1, NULL), NULL); /* create a new string */ result = g_string_sized_new (strlen (str)); /* walk though the string */ for (p = str; *p != '\0'; p = g_utf8_next_char (p)) { /* get the unicode char */ c = g_utf8_get_char (p); /* only change the case of alpha chars */ if (g_unichar_isalpha (c)) { /* get the opposite case of the char */ if (g_unichar_isupper (c)) buf = g_utf8_strdown (p, 1); else buf = g_utf8_strup (p, 1); /* append to the buffer */ g_string_append (result, buf); g_free (buf); } else { /* append the char */ g_string_append_unichar (result, c); } } /* return the result */ return g_string_free (result, FALSE); }
/* Class methods */ static LibBalsaABErr libbalsa_address_book_rubrica_load(LibBalsaAddressBook * ab, const gchar * filter, LibBalsaAddressBookLoadFunc callback, gpointer data) { LibBalsaAddressBookRubrica *ab_rubrica = LIBBALSA_ADDRESS_BOOK_RUBRICA(ab); LibBalsaAddressBookText *ab_text = LIBBALSA_ADDRESS_BOOK_TEXT(ab); LibBalsaABErr load_res; gchar *filter_hi = NULL; GSList *list; g_return_val_if_fail(ab_text->path != NULL, LBABERR_CANNOT_READ); /* try to load the xml file if necessary */ load_res = lbab_rubrica_load_xml(ab_rubrica, NULL); if (load_res != LBABERR_OK) return load_res; if (filter) filter_hi = g_utf8_strup(filter, -1); for (list = ab_text->item_list; list; list = list->next) { LibBalsaAddress *address = LIBBALSA_ADDRESS(list->data); if (!address) continue; if (callback && (!filter_hi || lbab_rubrica_starts_from(address->last_name, filter_hi) || lbab_rubrica_starts_from(address->full_name, filter_hi))) callback(ab, address, data); } if (callback) callback(ab, NULL, data); g_free(filter_hi); return LBABERR_OK; }