static void do_invert_case (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end) { GString *s = g_string_new (NULL); while (!gtk_text_iter_is_end (start) && !gtk_text_iter_equal (start, end)) { gunichar c, nc; c = gtk_text_iter_get_char (start); if (g_unichar_islower (c)) nc = g_unichar_toupper (c); else nc = g_unichar_tolower (c); g_string_append_unichar (s, nc); gtk_text_iter_forward_char (start); } gtk_text_buffer_delete_selection (buffer, TRUE, TRUE); gtk_text_buffer_insert_at_cursor (buffer, s->str, s->len); g_string_free (s, TRUE); }
static SearchCase inspect_case (const char *p, const char *pend) { gboolean is_upper = TRUE; gboolean is_capital = TRUE; gboolean has_letter = FALSE; gboolean expect_upper = TRUE; for (; p < pend; p = g_utf8_next_char (p)) { gunichar c = g_utf8_get_char (p); if (g_unichar_isalpha (c)) { has_letter = TRUE; if (!g_unichar_isupper (c)) { is_upper = FALSE; } if (expect_upper ? !g_unichar_isupper (c) : !g_unichar_islower (c)) { is_capital = FALSE; } expect_upper = FALSE; } else expect_upper = TRUE; } if (has_letter) { if (is_upper) return SC_Upper; if (is_capital) return SC_Capital; } return SC_Other; }
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); }
static gdouble quality_func (MatePasswordDialog *dialog, const char *text, gpointer ptr) { const char *p; gsize length; int uppercase = 0, symbols = 0, numbers = 0, strength; gunichar uc; if (text == NULL) return 0.0; /* Get the length */ length = g_utf8_strlen (text, -1); /* Count the number of number, symbols and uppercase chars */ for (p = text; *p; p = g_utf8_find_next_char (p, NULL)) { uc = g_utf8_get_char (p); if (g_unichar_isdigit (uc)) { numbers++; } else if (g_unichar_isupper (uc)) { uppercase++; } else if (g_unichar_islower (uc)) { /* Not counted */ } else if (g_unichar_isgraph (uc)) { symbols++; } } if (length > 5) length = 5; if (numbers > 3) numbers = 3; if (symbols > 3) symbols = 3; if (uppercase > 3) uppercase = 3; strength = (length * 10 - 20) + (numbers * 10) + (symbols * 15) + (uppercase * 10); strength = CLAMP (strength, 0, 100); return (double) strength / 100.0; }
/** * gnm_app_create_opener_filter: * @openers: (element-type GOFileOpener): a list of file openers. * * Creates a #GtkFileFilter from the list of file types supported by the * openers in the list. * Returns: (transfer full): the newly allocated #GtkFileFilter. **/ void * gnm_app_create_opener_filter (GList *openers) { /* See below. */ static const char *const bad_suffixes[] = { "txt", "html", "htm", "xml", NULL }; GtkFileFilter *filter = gtk_file_filter_new (); gboolean for_history = (openers == NULL); if (openers == NULL) openers = go_get_file_openers (); for (; openers; openers = openers->next) { GOFileOpener *opener = openers->data; if (opener != NULL) { const GSList *mimes = go_file_opener_get_mimes (opener); const GSList *suffixes = go_file_opener_get_suffixes (opener); if (!for_history) while (mimes) { const char *mime = mimes->data; /* * See 438918. Too many things * like *.xml and *.txt get added * to be useful for the file history */ gtk_file_filter_add_mime_type (filter, mime); if (0) g_print ("%s: Adding mime %s\n", go_file_opener_get_description (opener), mime); mimes = mimes->next; } while (suffixes) { const char *suffix = suffixes->data; GString *pattern; int i; if (for_history) for (i = 0; bad_suffixes[i]; i++) if (strcmp (suffix, bad_suffixes[i]) == 0) goto bad_suffix; /* Create "*.[xX][lL][sS]" */ pattern = g_string_new ("*."); while (*suffix) { gunichar uc = g_utf8_get_char (suffix); suffix = g_utf8_next_char (suffix); if (g_unichar_islower (uc)) { g_string_append_c (pattern, '['); g_string_append_unichar (pattern, uc); uc = g_unichar_toupper (uc); g_string_append_unichar (pattern, uc); g_string_append_c (pattern, ']'); } else g_string_append_unichar (pattern, uc); } gtk_file_filter_add_pattern (filter, pattern->str); if (0) g_print ("%s: Adding %s\n", go_file_opener_get_description (opener), pattern->str); g_string_free (pattern, TRUE); bad_suffix: suffixes = suffixes->next; } } } return filter; }
void CheckCapitalization::check_capitalization(vector < int >&chapters, vector < ustring > &verses, ustring & text, vector < size_t > &pointers, bool end_check) /* Check capitalization in text. If "end_check" is true, it also check for final sentence closing. */ { /* Note that this at first used gtk_text_iter_starts_sentence (&iter) and gtk_text_iter_ends_sentence (&iter), but these functions are not good enough, because do not work in several cases, like e.g. in the following line, it does not indicate the end of the sentence: As soon as the leaders of the tribes of Israel took their places, the Israelites said, “How could such a horrible thing happen?" Therefore we use other means to check sentences. */ // No check if there's no text. if (trim(text).empty()) return; // Some variables needed. bool expect_capital_now = false; bool expect_capital_caused_by_reference = false; gunichar previous_char = 0; int localchapter = 0; ustring localverse = "0"; GtkTextBuffer *textbuffer; textbuffer = gtk_text_buffer_new(NULL); gtk_text_buffer_set_text(textbuffer, text.c_str(), -1); GtkTextIter iter; gtk_text_buffer_get_start_iter(textbuffer, &iter); bool going = true; while (going) { // Get the unicode character. gunichar unichar = gtk_text_iter_get_char(&iter); // See whether to expect a capital now. if (punctuation_followed_by_capitals_set.find(unichar) != punctuation_followed_by_capitals_set.end()) { // Ok, expect capital. expect_capital_now = true; expect_capital_caused_by_reference = false; // Was this expectation caused by a reference? if (is_reference(iter)) expect_capital_caused_by_reference = true; } // If we expect a capital, and we find one, no longer look for one. if (expect_capital_now) { if (g_unichar_isupper(unichar)) { expect_capital_now = false; } } // If we expect a capital, and we get lower case, that might be trouble. if (expect_capital_now) { if (g_unichar_islower(unichar)) { // There is no trouble if it follows a character after which to ignore lower case. if (ignore_lower_case_following_set.find(previous_char) != ignore_lower_case_following_set.end()) { expect_capital_now = false; } // If the lowercase character follows an abbreviation, there is no trouble either. GtkTextIter iter2 = iter; gtk_text_iter_backward_word_start(&iter2); GtkTextIter iter3 = iter2; gtk_text_iter_forward_word_end(&iter3); gtk_text_iter_forward_char(&iter3); ustring abbreviation = gtk_text_iter_get_text(&iter2, &iter3); if (abbreviations.find(abbreviation) != abbreviations.end()) { expect_capital_now = false; } // If it follows a reference, there is no trouble. if (expect_capital_caused_by_reference) expect_capital_now = false; // Ok, give message. if (expect_capital_now) { // Determine chapter and verse. get_chapter_and_verse(chapters, verses, pointers, iter, localchapter, localverse); message(book, localchapter, localverse, _("Capital expected: ") + get_context(iter)); } // Only give one message about missing capitals in this context. expect_capital_now = false; } } // Store this characters as the previous characters for the next round. if (g_unichar_isgraph(unichar)) previous_char = unichar; // Next round. going = gtk_text_iter_forward_char(&iter); } // The sentence should be ended with proper punctuation. if (end_check) { if (expect_capital_now) if (g_unichar_isdigit(previous_char)) expect_capital_now = false; if (!expect_capital_now) { message(book, chapter, verse, _("Unended sentence: ") + get_context(iter)); } } // Free memory g_object_unref(textbuffer); }