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);
}
