static gboolean
filter_zone (ClutterModel *model, ClutterModelIter *iter, gpointer user_data)
{
MnpWorldClockPrivate *priv = GET_PRIVATE (user_data);
char *name, *name_mem;
GWeatherLocation *loc;
gboolean is_first_word = TRUE, match;
int len;
char *key, *skey;
if (!priv->search_text || !*priv->search_text)
return TRUE;
skey = key = g_ascii_strdown(priv->search_text, -1);
clutter_model_iter_get (iter,
GWEATHER_LOCATION_ENTRY_COL_COMPARE_NAME, &name_mem,
GWEATHER_LOCATION_ENTRY_COL_LOCATION, &loc,
-1);
name = name_mem;
if (!loc) {
g_free (name_mem);
g_free (key);
return FALSE;
}
/* All but the last word in KEY must match a full word from NAME,
* in order (but possibly skipping some words from NAME).
*/
len = strcspn (key, " ");
while (key[len]) {
name = find_word (name, key, len, TRUE, is_first_word);
if (!name) {
g_free (name_mem);
g_free (skey);
return FALSE;
}
key += len;
while (*key && !g_unichar_isalpha (g_utf8_get_char (key)))
key = g_utf8_next_char (key);
while (*name && !g_unichar_isalpha (g_utf8_get_char (name)))
name = g_utf8_next_char (name);
len = strcspn (key, " ");
is_first_word = FALSE;
}
/* The last word in KEY must match a prefix of a following word in NAME */
match = find_word (name, key, strlen (key), FALSE, is_first_word) != NULL;
g_free (name_mem);
g_free (skey);
return match;
}
static void
cb_entry_insert_text (GtkEditable *editable,
gchar const *text,
gint len_bytes,
gint *pos_in_chars,
WBCGtk *wbcg)
{
char const *str = gtk_entry_get_text (GTK_ENTRY (editable));
int pos_in_bytes = g_utf8_offset_to_pointer (str, *pos_in_chars) - str;
if (wbcg->auto_completing &&
len_bytes != 0 &&
(!g_unichar_isalpha (g_utf8_get_char (text)) ||
*pos_in_chars != gtk_entry_get_text_length (GTK_ENTRY (editable)))) {
wbcg->auto_completing = FALSE;
}
if (wbcg->edit_line.full_content) {
(void)pango_attr_list_filter (wbcg->edit_line.cur_fmt,
cb_set_attr_list_len,
GINT_TO_POINTER (len_bytes));
go_pango_attr_list_open_hole (wbcg->edit_line.full_content,
pos_in_bytes, len_bytes);
pango_attr_list_splice (wbcg->edit_line.full_content,
wbcg->edit_line.cur_fmt,
pos_in_bytes, 0);
go_pango_attr_list_open_hole (wbcg->edit_line.markup,
pos_in_bytes, len_bytes);
pango_attr_list_splice (wbcg->edit_line.markup,
wbcg->edit_line.cur_fmt,
pos_in_bytes, 0);
}
}
void TextEdit::setFlags(int new_flags, bool revalidate)
{
if (new_flags == flags)
return;
flags = new_flags;
if (flags && revalidate) {
bool valid = true;
const char *p = getTextStart();
while (p < bufend - 1) {
gunichar uc = g_utf8_get_char(p);
if ((flags & FLAG_ALPHABETIC) && !g_unichar_isalpha(uc)) {
valid = false;
break;
}
if ((flags & FLAG_NUMERIC) && !g_unichar_isdigit(uc)) {
valid = false;
break;
}
if ((flags & FLAG_NOSPACE) && g_unichar_isspace(uc)) {
valid = false;
break;
}
if ((flags & FLAG_NOPUNCTUATION) && g_unichar_ispunct(uc)) {
valid = false;
break;
}
p = nextChar(p);
}
if (!valid)
clear();
}
}
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;
}
/*
* call-seq:
* utf8_titleize(string)
*
* Returns a title case string.
*
* Glib.utf8_titleize('привет всем') #=> Привет Всем
*/
static VALUE utf8_titleize(VALUE self, VALUE string)
{
VALUE result;
gchar *temp;
long index, length_in_bytes, length_in_chars;
gunichar *chars_as_ucs4, current_char;
gboolean first_character_of_word = TRUE;
Check_Type(string, T_STRING);
length_in_bytes = RSTRING_LEN(string);
if ((chars_as_ucs4 = g_utf8_to_ucs4(StringValuePtr(string), length_in_bytes, NULL, &length_in_chars, NULL))) {
for (index = 0; index < length_in_chars; index++) {
current_char = chars_as_ucs4[index];
if (first_character_of_word == TRUE && g_unichar_isalpha(current_char)) {
chars_as_ucs4[index] = g_unichar_totitle(current_char);
first_character_of_word = FALSE;
}
if (g_unichar_isspace(current_char) || g_unichar_ispunct(current_char)) {
first_character_of_word = TRUE;
}
}
temp = g_ucs4_to_utf8(chars_as_ucs4, -1, NULL, NULL, NULL);
result = rb_str_new2(temp);
g_free(chars_as_ucs4);
g_free(temp);
return result;
} else {
return Qnil;
}
}
static bool _tokenize_identifier(GSDLTokenizer *self, GSDLToken *result, gunichar c, GError **err) {
int length = 7;
char *output = result->val = g_malloc(length);
GUnicodeType type;
int i = g_unichar_to_utf8(c, output);
while (_peek(self, &c, err) && (c == '-' || c == '.' || g_unichar_isalpha(c) || g_unichar_isdigit(c) || (type = g_unichar_type(c)) == G_UNICODE_CURRENCY_SYMBOL || type == G_UNICODE_CONNECT_PUNCTUATION || type == G_UNICODE_LETTER_NUMBER || type == G_UNICODE_SPACING_MARK || type == G_UNICODE_NON_SPACING_MARK)) {
GROW_IF_NEEDED(output = result->val, i + 5, length);
_consume(self);
i += g_unichar_to_utf8(c, output + i);
}
FAIL_IF_ERR();
output[i] = '\0';
if (
strcmp(output, "true") == 0 ||
strcmp(output, "on") == 0 ||
strcmp(output, "false") == 0 ||
strcmp(output, "off") == 0) {
result->type = T_BOOLEAN;
} else if (strcmp(output, "null") == 0) {
result->type = T_NULL;
}
return true;
}
static gboolean
gimp_eevl_unit_identifier_start (gunichar c)
{
return (g_unichar_isalpha (c) ||
c == (gunichar) '%' ||
c == (gunichar) '\'');
}
static gchar *
e_name_western_get_one_prefix_at_str (gchar *str)
{
gchar *word;
gint i;
/*
* Check for prefixes from our table.
*/
for (i = 0; i < G_N_ELEMENTS (western_pfx_index); i++) {
gint pfx_words;
const gchar *prefix;
gchar *words;
gchar *folded_words;
prefix = western_pfx_table + western_pfx_index[i];
pfx_words = e_name_western_str_count_words (prefix);
words = e_name_western_get_words_at_idx (str, 0, pfx_words);
folded_words = g_utf8_casefold (words, -1);
if (!g_utf8_collate (folded_words, prefix)) {
g_free (folded_words);
return words;
}
g_free (folded_words);
g_free (words);
}
/*
* Check for prefixes we don't know about. These are always a
* sequence of more than one letters followed by a period.
*/
word = e_name_western_get_words_at_idx (str, 0, 1);
if (g_utf8_strlen (word, -1) > 2 &&
g_unichar_isalpha (g_utf8_get_char (word)) &&
g_unichar_isalpha (g_utf8_get_char (g_utf8_next_char (word))) &&
word[strlen (word) - 1] == '.')
return word;
g_free (word);
return NULL;
}
gboolean
alert_match_text (char *text, char *masks)
{
unsigned char *p = text;
unsigned char endchar;
int res;
if (masks[0] == 0)
return FALSE;
while (1)
{
if (*p >= '0' && *p <= '9')
{
p++;
continue;
}
/* if it's RFC1459 <special>, it can be inside a word */
switch (*p)
{
case '-':
case '[':
case ']':
case '\\':
case '`':
case '^':
case '{':
case '}':
case '_':
case '|':
p++;
continue;
}
/* if it's a 0, space or comma, the word has ended. */
if (*p == 0 || *p == ' ' || *p == ',' ||
/* if it's anything BUT a letter, the word has ended. */
(!g_unichar_isalpha (g_utf8_get_char (p))))
{
endchar = *p;
*p = 0;
res = alert_match_word (text, masks);
*p = endchar;
if (res)
return TRUE; /* yes, matched! */
text = p + g_utf8_skip[p[0]];
if (*p == 0)
return FALSE;
}
p += g_utf8_skip[p[0]];
}
}
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 void
gnc_price_cell_modify_verify (BasicCell *_cell,
const char *change,
int change_len,
const char *newval,
int newval_len,
int *cursor_position,
int *start_selection,
int *end_selection)
{
PriceCell *cell = (PriceCell *) _cell;
struct lconv *lc = gnc_localeconv ();
const char *toks = "+-*/=()_";
gunichar decimal_point;
gunichar thousands_sep;
const char *c;
gunichar uc;
/* accept the newval string if user action was delete */
if (change == NULL)
{
gnc_basic_cell_set_value_internal (_cell, newval);
cell->need_to_parse = TRUE;
return;
}
if (cell->print_info.monetary)
decimal_point = g_utf8_get_char(lc->mon_decimal_point);
else
decimal_point = g_utf8_get_char(lc->decimal_point);
if (cell->print_info.monetary)
thousands_sep = g_utf8_get_char(lc->mon_thousands_sep);
else
thousands_sep = g_utf8_get_char(lc->thousands_sep);
c = change;
while (*c)
{
uc = g_utf8_get_char (c);
if (!g_unichar_isdigit (uc) &&
!g_unichar_isspace (uc) &&
!g_unichar_isalpha (uc) &&
(decimal_point != uc) &&
(thousands_sep != uc) &&
(g_utf8_strchr (toks, -1, uc) == NULL))
return;
c = g_utf8_next_char (c);
}
gnc_basic_cell_set_value_internal (_cell, newval);
cell->need_to_parse = TRUE;
}
//Finds out if the result is EXACT_MATCH, START_WITH_MATCH, END_WITH_MATCH, ANY_MATCH
int get_jp_match_type(gchar *line, gchar *srchstrg, int offset) {
int srchstrglen;
srchstrglen = strlen(srchstrg);
if (offset == 0) { //can be EXACT or START_WITH
if ((*(line + srchstrglen)) == ' ') return EXACT_MATCH;
return START_WITH_MATCH;
}
else { //Check for Furigana
if (g_unichar_isalpha(g_utf8_get_char(g_utf8_prev_char(line + offset))) == FALSE) {
if (g_unichar_isalpha(g_utf8_get_char(line + offset + srchstrglen)) == FALSE) {
return EXACT_MATCH;
}
else return START_WITH_MATCH;
}
else { // has an alpha char before
if (g_unichar_isalpha(g_utf8_get_char(line + offset + srchstrglen)) == FALSE)
return END_WITH_MATCH;
}
}
if ((*(line + offset + srchstrglen)) == ' ') return END_WITH_MATCH;
return ANY_MATCH;
}
static char *
find_word (const char *full_name, const char *word, int word_len,
gboolean whole_word, gboolean is_first_word)
{
char *p = (char *)full_name - 1;
while ((p = strchr (p + 1, *word))) {
if (strncmp (p, word, word_len) != 0)
continue;
if (p > (char *)full_name) {
char *prev = g_utf8_prev_char (p);
/* Make sure p points to the start of a word */
if (g_unichar_isalpha (g_utf8_get_char (prev)))
continue;
/* If we're matching the first word of the key, it has to
* match the first word of the location, city, state, or
* country. Eg, it either matches the start of the string
* (which we already know it doesn't at this point) or
* it is preceded by the string ", " (which isn't actually
* a perfect test. FIXME)
*/
if (is_first_word) {
if (prev == (char *)full_name || strncmp (prev - 1, ", ", 2) != 0)
continue;
}
}
if (whole_word && g_unichar_isalpha (g_utf8_get_char (p + word_len)))
continue;
return p;
}
return NULL;
}
static gunichar
get_first_non_underscore_char (const char *str)
{
const char *p;
if (!str)
return 0;
for (p = str; p && *p; p = g_utf8_find_next_char (p, NULL))
{
gunichar ch;
ch = g_utf8_get_char (p);
if (g_unichar_isalpha (ch))
return ch;
}
return 0;
}
/**
* expr_name_validate:
* @name: tentative name
*
* returns TRUE if the given name is valid, FALSE otherwise.
*/
gboolean
expr_name_validate (const char *name)
{
const char *p;
GnmValue *v;
g_return_val_if_fail (name != NULL, FALSE);
if (name[0] == 0)
return FALSE;
v = value_new_from_string (VALUE_BOOLEAN, name, NULL, TRUE);
if (!v)
v = value_new_from_string (VALUE_BOOLEAN, name, NULL, FALSE);
if (v) {
value_release (v);
return FALSE;
}
/* Hmm... Now what? */
if (!g_unichar_isalpha (g_utf8_get_char (name)) &&
name[0] != '_')
return FALSE;
for (p = name; *p; p = g_utf8_next_char (p)) {
if (!g_unichar_isalnum (g_utf8_get_char (p)) &&
p[0] != '_')
return FALSE;
}
/* Make sure it's not A1 etc.*/
/* Note that we can't use our regular parsers */
/* since we also have to avoid names that may become */
/* sensible when the sheet size changes. */
if (!expr_name_validate_a1 (name))
return FALSE;
/* What about R1C1? */
if (!expr_name_validate_r1c1 (name))
return FALSE;
return TRUE;
}
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);
}
static gboolean
gtkspell_text_iter_backward_word_start(GtkTextIter *i) {
GtkTextIter iter;
if (!gtk_text_iter_backward_word_start(i))
return FALSE;
iter = *i;
if (gtk_text_iter_backward_char(&iter)) {
if (gtk_text_iter_get_char(&iter) == '\'') {
if (gtk_text_iter_backward_char(&iter)) {
if (g_unichar_isalpha(gtk_text_iter_get_char(&iter))) {
return (gtk_text_iter_backward_word_start(i));
}
}
}
}
return TRUE;
}
static gboolean
gtkspell_text_iter_forward_word_end(GtkTextIter *i) {
GtkTextIter iter;
/* heuristic:
* if we're on an singlequote/apostrophe and
* if the next letter is alphanumeric,
* this is an apostrophe. */
if (!gtk_text_iter_forward_word_end(i))
return FALSE;
if (gtk_text_iter_get_char(i) != '\'')
return TRUE;
iter = *i;
if (gtk_text_iter_forward_char(&iter)) {
if (g_unichar_isalpha(gtk_text_iter_get_char(&iter))) {
return (gtk_text_iter_forward_word_end(i));
}
}
return TRUE;
}
/** Examine an extension menu item and see if it needs to have an
* accelerator key assigned to it. If so, find the first character
* in the menu name that isn't already assigned as an accelerator in
* the same menu, assign it to this item, and add it to the map of
* already used accelerator keys. These maps are maintained per
* path, so accelerator keys may be duplicated across different menus
* but are guaranteed to be unique within any given menu.
*
* @param info A menu extension.
*
* @param table A hash table of accelerator maps. */
static void
gnc_menu_additions_assign_accel (ExtensionInfo *info, GHashTable *table)
{
gchar *map, *new_map, *new_label, *start, buf[16];
const gchar *ptr;
gunichar uni;
gint len;
gboolean map_allocated = FALSE;
ENTER("Checking %s/%s [%s]", info->path, info->ae.label, info->ae.name);
if (info->accel_assigned)
{
LEAVE("Already processed");
return;
}
/* Get map of used keys */
map = g_hash_table_lookup(table, info->path);
if (map == NULL)
{
map = g_strdup("");
map_allocated = TRUE;
}
DEBUG("map '%s', path %s", map, info->path);
for (ptr = info->ae.label; *ptr; ptr = g_utf8_next_char(ptr))
{
uni = g_utf8_get_char(ptr);
if (!g_unichar_isalpha(uni))
continue;
uni = g_unichar_tolower(uni);
len = g_unichar_to_utf8(uni, buf);
buf[len] = '\0';
DEBUG("Testing character '%s'", buf);
if (!g_utf8_strchr(map, -1, uni))
break;
}
if (ptr == NULL)
{
/* Ran out of characters. Nothing to do. */
info->accel_assigned = TRUE;
if (map_allocated)
{
g_free(map);
}
LEAVE("All characters already assigned");
return;
}
/* Now build a new string in the form "<start>_<end>". */
start = g_strndup(info->ae.label, ptr - info->ae.label);
DEBUG("start %p, len %ld, text '%s'", start, g_utf8_strlen(start, -1), start);
new_label = g_strconcat(start, "_", ptr, (gchar *)NULL);
g_free(start);
DEBUG("label '%s' -> '%s'", info->ae.label, new_label);
g_free((gchar *)info->ae.label);
info->ae.label = new_label;
/* Now build a new map. Old one freed automatically. */
new_map = g_strconcat(map, buf, (gchar *)NULL);
DEBUG("map '%s' -> '%s'", map, new_map);
g_hash_table_replace(table, info->path, new_map);
info->accel_assigned = TRUE;
if (map_allocated)
{
g_free(map);
}
LEAVE("assigned");
}
static void
property_dialog_add_cb (GtkWidget *button,
GtkWidget *dialog)
{
PlannerPropertyDialogPriv *priv;
MrpPropertyType type;
const gchar *label;
const gchar *name;
const gchar *description;
GladeXML *glade;
GtkWidget *label_entry;
GtkWidget *name_entry;
GtkWidget *add_dialog;
GtkWidget *w;
gint response;
gboolean finished = FALSE;
gunichar c;
gchar *filename;
priv = GET_PRIV (dialog);
filename = mrp_paths_get_glade_dir ("new-property.glade");
glade = glade_xml_new (filename,
NULL,
NULL);
g_free (filename);
add_dialog = glade_xml_get_widget (glade, "add_dialog");
label_entry = glade_xml_get_widget (glade, "label_entry");
name_entry = glade_xml_get_widget (glade, "name_entry");
g_signal_connect (label_entry,
"focus_out_event",
G_CALLBACK (property_dialog_label_changed_cb),
name_entry);
property_dialog_setup_option_menu (
glade_xml_get_widget (glade, "type_menu"),
G_CALLBACK (property_dialog_type_selected_cb),
add_dialog,
mrp_property_type_as_string (MRP_PROPERTY_TYPE_STRING),
MRP_PROPERTY_TYPE_STRING,
mrp_property_type_as_string (MRP_PROPERTY_TYPE_INT),
MRP_PROPERTY_TYPE_INT,
mrp_property_type_as_string (MRP_PROPERTY_TYPE_FLOAT),
MRP_PROPERTY_TYPE_FLOAT,
/* mrp_property_type_as_string (MRP_PROPERTY_TYPE_DATE), */
/* MRP_PROPERTY_TYPE_DATE, */
/* mrp_property_type_as_string (MRP_PROPERTY_TYPE_DURATION), */
/* MRP_PROPERTY_TYPE_DURATION, */
/* mrp_property_type_as_string (MRP_PROPERTY_TYPE_COST), */
/* MRP_PROPERTY_TYPE_COST, */
NULL);
while (!finished) {
response = gtk_dialog_run (GTK_DIALOG (add_dialog));
switch (response) {
case GTK_RESPONSE_OK:
label = gtk_entry_get_text (GTK_ENTRY (label_entry));
if (label == NULL || label[0] == 0) {
finished = FALSE;
break;
}
name = gtk_entry_get_text (GTK_ENTRY (name_entry));
if (name == NULL || name[0] == 0) {
finished = FALSE;
break;
}
c = g_utf8_get_char (name);
if (!g_unichar_isalpha (c)) {
GtkWidget *msg_dialog;
msg_dialog = gtk_message_dialog_new (
GTK_WINDOW (add_dialog),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_OK,
_("The name of the custom property needs to start with a letter."));
gtk_dialog_run (GTK_DIALOG (msg_dialog));
gtk_widget_destroy (msg_dialog);
finished = FALSE;
break;
}
w = glade_xml_get_widget (glade, "description_entry");
description = gtk_entry_get_text (GTK_ENTRY (w));
w = glade_xml_get_widget (glade, "type_menu");
type = property_dialog_get_selected (w);
if (type != MRP_PROPERTY_TYPE_NONE) {
property_cmd_add (priv->main_window,
priv->project,
priv->owner,
name,
type,
label,
description,
TRUE);
}
finished = TRUE;
break;
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CANCEL:
finished = TRUE;
break;
default:
break;
}
}
gtk_widget_destroy (add_dialog);
g_object_unref (glade);
}
/**********************************************************************
* Takes text and make a list of words, one per line, validating as UTF-8
*/
gchar *
velo_filter_utf8 (gchar * text)
{
gunichar uch;
gboolean is_searching_word;
struct INPUT_TEXT
{
gchar *pt;
gulong len;
guint nwords;
} raw;
struct FILTERED_TEXT
{
gchar *txt;
gulong i;
gulong len;
} flt;
raw.len = strlen (text);
/* Verify empty string
*/
if (raw.len == 0)
{
flt.txt = g_strdup ("01234\n56789\n43210\n98765\n:-)\n");
return (flt.txt);
}
/* Allocate memory space for the result
*/
flt.i = 0;
flt.len = raw.len + 1024;
flt.txt = g_malloc (flt.len);
raw.pt = text;
/* Filter
*/
raw.nwords = 0;
is_searching_word = TRUE;
while (raw.pt && raw.nwords < MAX_WORDS)
{
if (*raw.pt == '\0')
break;
/* Read valid utf8 char
*/
if ((uch = g_utf8_get_char_validated (raw.pt, -1)) == (gunichar) - 1
|| uch == (gunichar) - 2)
uch = L' ';
/* Increase the pointer for the input text
*/
raw.pt = g_utf8_find_next_char (raw.pt, NULL);
/* Verify memory space of output buffer
*/
if (flt.i < flt.len - 8)
{
flt.len += 1024;
flt.txt = g_realloc (flt.txt, flt.len);
}
/* Test alphabetic char to form a word
*/
if (g_unichar_isalpha (uch))
{
flt.i += g_unichar_to_utf8 (uch, &flt.txt[flt.i]);
is_searching_word = FALSE;
}
else if (!is_searching_word)
{
raw.nwords++;
flt.txt[flt.i++] = '\n';
is_searching_word = TRUE;
}
}
flt.txt[flt.i++] = '\0';
if (raw.nwords == 0)
{
g_free (flt.txt);
flt.txt = g_strdup ("01234\n56789\n43210\n98765\n:-)\n");
}
return (flt.txt);
}
/**
* wbcg_edit_start:
* @wbcg: The workbook to be edited.
* @blankp: If true, erase current cell contents first. If false, leave the
* contents alone.
* @cursorp: If true, create an editing cursor in the current sheet. (If
* false, the text will be editing in the edit box above the sheet,
* but this is not handled by this function.)
*
* Initiate editing of a cell in the sheet. Note that we have two modes of
* editing:
* 1) in-cell editing when you just start typing, and
* 2) above sheet editing when you hit F2.
*
* Returns TRUE if we did indeed start editing. Returns FALSE if the
* cell-to-be-edited was locked.
*/
gboolean
wbcg_edit_start (WBCGtk *wbcg,
gboolean blankp, gboolean cursorp)
{
/* We could save this, but the situation is rare, if confusing. */
static gboolean warn_on_text_format = TRUE;
SheetView *sv;
SheetControlGUI *scg;
GnmCell *cell;
char *text = NULL;
int col, row;
WorkbookView *wbv;
int cursor_pos = -1;
g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
if (wbcg_is_editing (wbcg))
return TRUE;
/* Avoid recursion, and do not begin editing if a guru is up */
if (wbcg->inside_editing || wbc_gtk_get_guru (wbcg) != NULL)
return TRUE;
wbcg->inside_editing = TRUE;
wbv = wb_control_view (GNM_WBC (wbcg));
sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
scg = wbcg_cur_scg (wbcg);
col = sv->edit_pos.col;
row = sv->edit_pos.row;
/* don't edit a locked cell */
/* TODO : extend this to disable edits that cannot succeed
* like editing a single cell of an array. I think we have enough
* information if we look at the selection.
*/
if (wb_view_is_protected (wbv, TRUE) &&
gnm_style_get_contents_locked (sheet_style_get (sv->sheet, col, row))) {
char *pos = g_strdup_printf ( _("%s!%s is locked"),
sv->sheet->name_quoted, cell_coord_name (col, row));
go_cmd_context_error_invalid (GO_CMD_CONTEXT (wbcg), pos,
wb_view_is_protected (wbv, FALSE)
? _("Unprotect the workbook to enable editing.")
: _("Unprotect the sheet to enable editing."));
wbcg->inside_editing = FALSE;
g_free (pos);
return FALSE;
}
cell = sheet_cell_get (sv->sheet, col, row);
if (cell &&
warn_on_text_format &&
go_format_is_text (gnm_cell_get_format (cell)) &&
(gnm_cell_has_expr (cell) || !VALUE_IS_STRING (cell->value))) {
gint res; /* Using GtkResponseType would yield a warning on the switch */
GtkWidget *check;
GtkWidget *align;
GtkWidget *d = gnm_message_dialog_create
(wbcg_toplevel (wbcg),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
_("You are about to edit a cell with \"text\" format."),
_("The cell does not currently contain text, though, so if "
"you go on editing then the contents will be turned into "
"text."));
gtk_dialog_add_button (GTK_DIALOG (d), GTK_STOCK_EDIT, GTK_RESPONSE_OK);
go_gtk_dialog_add_button
(GTK_DIALOG (d), _("Remove format"), GTK_STOCK_REMOVE,
GNM_RESPONSE_REMOVE);
gtk_dialog_add_button (GTK_DIALOG (d), GNM_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_CANCEL);
check = gtk_check_button_new_with_label (_("Show this dialog next time."));
g_signal_connect (check, "toggled", G_CALLBACK (cb_warn_toggled), &warn_on_text_format);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
align = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_container_add (GTK_CONTAINER (align), check);
gtk_widget_show_all (align);
gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (d))), align, TRUE, TRUE, 0);
res = go_gtk_dialog_run (GTK_DIALOG (d), wbcg_toplevel (wbcg));
switch (res) {
case GNM_RESPONSE_REMOVE: {
GnmStyle *style = gnm_style_new ();
gnm_style_set_format (style, go_format_general ());
if (!cmd_selection_format (GNM_WBC (wbcg),
style, NULL, NULL))
break;
/* Fall through. */
}
default:
case GTK_RESPONSE_CANCEL:
wbcg->inside_editing = FALSE;
return FALSE;
case GTK_RESPONSE_OK:
break;
}
}
gnm_app_clipboard_unant ();
if (blankp)
gtk_entry_set_text (wbcg_get_entry (wbcg), "");
else if (cell != NULL) {
gboolean quoted = FALSE;
text = gnm_cell_get_text_for_editing (cell, sv->sheet, "ed, &cursor_pos);
if (text)
gtk_entry_set_text (wbcg_get_entry (wbcg), text);
if (cell->value != NULL) {
GOFormat const *fmt = VALUE_FMT (cell->value);
if (fmt != NULL && go_format_is_markup (fmt)) {
PangoAttrList *markup =
pango_attr_list_copy ((PangoAttrList *)go_format_get_markup (fmt));
if (quoted)
go_pango_attr_list_open_hole (markup, 0, 1);
wbcg_edit_init_markup (wbcg, markup);
}
}
}
gnm_expr_entry_set_scg (wbcg->edit_line.entry, scg);
gnm_expr_entry_set_flags (wbcg->edit_line.entry,
GNM_EE_SHEET_OPTIONAL | GNM_EE_FORMULA_ONLY,
GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL | GNM_EE_FORMULA_ONLY | GNM_EE_FORCE_REL_REF | GNM_EE_FORCE_ABS_REF);
scg_edit_start (scg);
/* Redraw the cell contents in case there was a span */
sheet_redraw_region (sv->sheet, col, row, col, row);
if (cursorp && /* autocompletion code will not work in the edit line */
wbv->do_auto_completion &&
(text == NULL || g_unichar_isalpha (g_utf8_get_char (text)))) {
wbcg->auto_complete = gnm_complete_sheet_new (
sv->sheet, col, row,
workbook_edit_complete_notify, wbcg);
wbcg->auto_completing = TRUE;
wbcg->auto_max_size = 0;
} else
wbcg->auto_complete = NULL;
/* Give the focus to the edit line */
if (!cursorp)
gtk_window_set_focus (wbcg_toplevel (wbcg),
(GtkWidget *) wbcg_get_entry (wbcg));
wbcg->editing = TRUE;
wbcg->editing_sheet = sv->sheet;
wbcg->editing_cell = cell;
/* If this assert fails, it means editing was not shut down
* properly before
*/
g_return_val_if_fail (wbcg->edit_line.signal_changed == 0, TRUE);
wbcg->edit_line.signal_changed = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"changed",
G_CALLBACK (cb_entry_changed), wbcg);
wbcg->edit_line.signal_insert = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"insert-text",
G_CALLBACK (cb_entry_insert_text), wbcg);
wbcg->edit_line.signal_delete = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"delete-text",
G_CALLBACK (cb_entry_delete_text), wbcg);
wbcg->edit_line.signal_cursor_pos = g_signal_connect_swapped (
G_OBJECT (wbcg_get_entry (wbcg)),
"notify::cursor-position",
G_CALLBACK (cb_entry_cursor_pos), wbcg);
wbcg->edit_line.signal_selection_bound = g_signal_connect_swapped (
G_OBJECT (wbcg_get_entry (wbcg)),
"notify::selection-bound",
G_CALLBACK (cb_entry_cursor_pos), wbcg);
g_free (text);
wb_control_update_action_sensitivity (GNM_WBC (wbcg));
wbcg->inside_editing = FALSE;
gtk_editable_set_position (GTK_EDITABLE (wbcg_get_entry (wbcg)), cursor_pos);
return TRUE;
}
/**
* gsdl_tokenizer_next:
* @self: A valid %GSDLTokenizer.
* @result: (out callee-allocates): A %GSDLToken to initialize and fill in.
* @err: (out) (allow-none): Location to store any error, may be %NULL.
*
* Fetches the next token from the input. Depending on the source of input, may set an error in one
* of the %GSDL_SYNTAX_ERROR, %G_IO_CHANNEL_ERROR, or %G_CONVERT_ERROR domains.
*
* Returns: Whether a token could be successfully read.
*/
bool gsdl_tokenizer_next(GSDLTokenizer *self, GSDLToken **result, GError **err) {
gunichar c, nc;
int line;
int col;
retry:
line = self->line;
col = self->col;
if (!_read(self, &c, err)) return false;
if (G_UNLIKELY(c == EOF)) {
*result = _maketoken(T_EOF, line, col);
return true;
} else if (c == '\r') {
if (_peek(self, &c, err) && c == '\n') _consume(self);
*result = _maketoken('\n', line, col);
FAIL_IF_ERR();
return true;
} else if ((c == '/' && _peek(self, &nc, err) && nc == '/') || (c == '-' && _peek(self, &nc, err) && nc == '-') || c == '#') {
if (c != '#') _consume(self);
while (_peek(self, &c, err) && !(c == '\n' || c == EOF)) _consume(self);
goto retry;
} else if (c == '/' && _peek(self, &nc, err) && nc == '*') {
while (_read(self, &c, err)) {
if (c == EOF) {
_set_error(err,
self,
GSDL_SYNTAX_ERROR_UNEXPECTED_CHAR,
"Unterminated comment"
);
return false;
} else if (c == '*' && _peek(self, &c, err) && c == '/') {
_consume(self);
break;
}
}
goto retry;
} else if (c < 256 && strchr("-+:;./{}=\n", (char) c)) {
*result = _maketoken(c, line, col);
return true;
} else if (c < 256 && isdigit((char) c)) {
*result = _maketoken(T_NUMBER, line, col);
return _tokenize_number(self, *result, c, err);
} else if (g_unichar_isalpha(c) || g_unichar_type(c) == G_UNICODE_CONNECT_PUNCTUATION || g_unichar_type(c) == G_UNICODE_CURRENCY_SYMBOL) {
*result = _maketoken(T_IDENTIFIER, line, col);
return _tokenize_identifier(self, *result, c, err);
} else if (c == '[') {
*result = _maketoken(T_BINARY, line, col);
if (!_tokenize_binary(self, *result, err)) return false;
REQUIRE(_read(self, &c, err));
if (c == ']') {
return true;
} else {
_set_error(err,
self,
GSDL_SYNTAX_ERROR_MISSING_DELIMITER,
"Missing ']'"
);
return false;
}
} else if (c == '"') {
*result = _maketoken(T_STRING, line, col);
if (!_tokenize_string(self, *result, err)) return false;
REQUIRE(_read(self, &c, err));
if (c == '"') {
return true;
} else {
_set_error(err,
self,
GSDL_SYNTAX_ERROR_MISSING_DELIMITER,
"Missing '\"'"
);
return false;
}
} else if (c == '`') {
*result = _maketoken(T_STRING, line, col);
if (!_tokenize_backquote_string(self, *result, err)) return false;
REQUIRE(_read(self, &c, err));
if (c == '`') {
return true;
} else {
_set_error(err,
self,
GSDL_SYNTAX_ERROR_MISSING_DELIMITER,
"Missing '`'"
);
return false;
}
} else if (c == '\'') {
*result = _maketoken(T_CHAR, line, col);
(*result)->val = g_malloc0(4);
_read(self, &c, err);
if (c == '\\') {
_read(self, &c, err);
switch (c) {
case 'n': c = '\n'; break;
case 'r': c = '\r'; break;
case 't': c = '\t'; break;
case '"': c = '"'; break;
case '\'': c = '\''; break;
case '\\': c = '\\'; break;
}
}
g_unichar_to_utf8(c, (*result)->val);
REQUIRE(_read(self, &c, err));
if (c == '\'') {
return true;
} else {
_set_error(err,
self,
GSDL_SYNTAX_ERROR_MISSING_DELIMITER,
"Missing \"'\""
);
return false;
}
} else if (c == '\\' && _peek(self, &nc, err) && (nc == '\r' || nc == '\n')) {
_consume(self);
if (c == '\r') _read(self, &c, err);
goto retry;
} else if (c == ' ' || c == '\t') {
// Do nothing
goto retry;
} else {
_set_error(err,
self,
GSDL_SYNTAX_ERROR_UNEXPECTED_CHAR,
g_strdup_printf("Invalid character '%s'(%d)", g_ucs4_to_utf8(&c, 1, NULL, NULL, NULL), c)
);
return false;
}
}
gint
planner_parse_duration_with_day_length (const gchar *input,
gint day_length)
{
gchar *str;
gchar *p;
gchar *end_ptr;
gdouble dbl;
Unit unit;
gint total;
gint seconds_per_month;
gint seconds_per_week;
/* Hardcode these for now. */
seconds_per_week = day_length * 5;
seconds_per_month = day_length * 30;
str = g_utf8_casefold (input, -1);
if (!str) {
return 0;
}
total = 0;
p = str;
while (*p) {
while (*p && g_unichar_isalpha (g_utf8_get_char (p))) {
p = g_utf8_next_char (p);
}
if (*p == 0) {
break;
}
dbl = g_strtod (p, &end_ptr);
if (end_ptr == p) {
break;
}
if (end_ptr) {
unit = format_get_unit_from_string (end_ptr);
/* If no unit was specified and it was the first number
* in the input, treat it as "day".
*/
if (unit == UNIT_NONE && p == str) {
unit = UNIT_DAY;
}
total += format_multiply_with_unit (dbl,
unit,
seconds_per_month,
seconds_per_week,
day_length);
}
if (end_ptr && *end_ptr == 0) {
break;
}
p = end_ptr + 1;
}
g_free (str);
return total;
}
static gboolean
check_part (struct mime_text_part *part, gboolean raw_mode)
{
guchar *p, *p1;
gunichar c, t;
GUnicodeScript scc, sct;
guint32 mark = 0, total = 0, max = 0, i;
guint32 remain = part->content->len;
guint32 scripts[G_UNICODE_SCRIPT_NKO];
GUnicodeScript sel = 0;
p = part->content->data;
if (IS_PART_UTF (part) || raw_mode) {
while (remain > 1) {
if ((g_ascii_isalpha (*p) &&
(*(p + 1) & 0x80)) ||
((*p & 0x80) && g_ascii_isalpha (*(p + 1)))) {
mark++;
total++;
}
/* Current and next symbols are of one class */
else if (((*p & 0x80) &&
(*(p + 1) & 0x80)) ||
(g_ascii_isalpha (*p) && g_ascii_isalpha (*(p + 1)))) {
total++;
}
p++;
remain--;
}
}
else {
memset (&scripts, 0, sizeof (scripts));
while (remain > 0) {
c = g_utf8_get_char_validated (p, remain);
if (c == (gunichar) - 2 || c == (gunichar) - 1) {
/* Invalid characters detected, stop processing */
return FALSE;
}
scc = g_unichar_get_script (c);
if (scc < (gint)G_N_ELEMENTS (scripts)) {
scripts[scc]++;
}
p1 = g_utf8_next_char (p);
remain -= p1 - p;
p = p1;
if (remain > 0) {
t = g_utf8_get_char_validated (p, remain);
if (t == (gunichar) - 2 || t == (gunichar) - 1) {
/* Invalid characters detected, stop processing */
return FALSE;
}
sct = g_unichar_get_script (t);
if (g_unichar_isalpha (c) && g_unichar_isalpha (t)) {
/* We have two unicode alphanumeric characters, so we can check its script */
if (sct != scc) {
mark++;
}
total++;
}
p1 = g_utf8_next_char (p);
remain -= p1 - p;
p = p1;
}
}
/* Detect the mostly charset of this part */
for (i = 0; i < G_N_ELEMENTS (scripts); i++) {
if (scripts[i] > max) {
max = scripts[i];
sel = i;
}
}
part->script = sel;
}
if (total == 0) {
return 0;
}
return ((double)mark / (double)total) > chartable_module_ctx->threshold;
}
/**
* e_text_to_html_full:
* @input: a NUL-terminated input buffer
* @flags: some combination of the E_TEXT_TO_HTML_* flags defined
* in e-html-utils.h
* @color: color for citation highlighting
*
* This takes a buffer of text as input and produces a buffer of
* "equivalent" HTML, subject to certain transformation rules.
*
* The set of possible flags is:
*
* - E_TEXT_TO_HTML_PRE: wrap the output HTML in <PRE> and
* </PRE> Should only be used if @input is the entire
* buffer to be converted. If e_text_to_html is being called with
* small pieces of data, you should wrap the entire result in
* <PRE> yourself.
*
* - E_TEXT_TO_HTML_CONVERT_NL: convert "\n" to "<BR>n" on
* output. (Should not be used with E_TEXT_TO_HTML_PRE, since
* that would result in double-newlines.)
*
* - E_TEXT_TO_HTML_CONVERT_SPACES: convert a block of N spaces
* into N-1 non-breaking spaces and one normal space. A space
* at the start of the buffer is always converted to a
* non-breaking space, regardless of the following character,
* which probably means you don't want to use this flag on
* pieces of data that aren't delimited by at least line breaks.
*
* If E_TEXT_TO_HTML_CONVERT_NL and E_TEXT_TO_HTML_CONVERT_SPACES
* are both defined, then TABs will also be converted to spaces.
*
* - E_TEXT_TO_HTML_CONVERT_URLS: wrap <a href="..."> </a>
* around strings that look like URLs.
*
* - E_TEXT_TO_HTML_CONVERT_ADDRESSES: wrap <a href="mailto:...">
* </a> around strings that look like mail addresses.
*
* - E_TEXT_TO_HTML_MARK_CITATION: wrap <font color="...">
* </font> around citations (lines beginning with "> ", etc).
*
* - E_TEXT_TO_HTML_ESCAPE_8BIT: flatten everything to US-ASCII
*
* - E_TEXT_TO_HTML_CITE: quote the text with "> " at the start of each
* line.
*
* Returns: a newly-allocated string containing HTML
**/
gchar *
e_text_to_html_full (const gchar *input,
guint flags,
guint32 color)
{
const guchar *cur, *next, *linestart;
gchar *buffer = NULL;
gchar *out = NULL;
gint buffer_size = 0, col;
gboolean colored = FALSE, saw_citation = FALSE;
/* Allocate a translation buffer. */
buffer_size = strlen (input) * 2 + 5;
buffer = g_malloc (buffer_size);
out = buffer;
if (flags & E_TEXT_TO_HTML_PRE)
out += sprintf (out, "<PRE>");
col = 0;
for (cur = linestart = (const guchar *) input; cur && *cur; cur = next) {
gunichar u;
if (flags & E_TEXT_TO_HTML_MARK_CITATION && col == 0) {
saw_citation = is_citation (cur, saw_citation);
if (saw_citation) {
if (!colored) {
gchar font[25];
g_snprintf (font, 25, "<FONT COLOR=\"#%06x\">", color);
out = check_size (&buffer, &buffer_size, out, 25);
out += sprintf (out, "%s", font);
colored = TRUE;
}
} else if (colored) {
const gchar *no_font = "</FONT>";
out = check_size (&buffer, &buffer_size, out, 9);
out += sprintf (out, "%s", no_font);
colored = FALSE;
}
/* Display mbox-mangled ">From" as "From" */
if (*cur == '>' && !saw_citation)
cur++;
} else if (flags & E_TEXT_TO_HTML_CITE && col == 0) {
out = check_size (&buffer, &buffer_size, out, 5);
out += sprintf (out, "> ");
}
u = g_utf8_get_char ((gchar *) cur);
if (g_unichar_isalpha (u) &&
(flags & E_TEXT_TO_HTML_CONVERT_URLS)) {
gchar *tmpurl = NULL, *refurl = NULL, *dispurl = NULL;
if (!g_ascii_strncasecmp ((gchar *)cur, "http://", 7) ||
!g_ascii_strncasecmp ((gchar *)cur, "https://", 8) ||
!g_ascii_strncasecmp ((gchar *)cur, "ftp://", 6) ||
!g_ascii_strncasecmp ((gchar *)cur, "nntp://", 7) ||
!g_ascii_strncasecmp ((gchar *)cur, "mailto:", 7) ||
!g_ascii_strncasecmp ((gchar *)cur, "news:", 5) ||
!g_ascii_strncasecmp ((gchar *)cur, "file:", 5) ||
!g_ascii_strncasecmp ((gchar *)cur, "callto:", 7) ||
!g_ascii_strncasecmp ((gchar *)cur, "h323:", 5) ||
!g_ascii_strncasecmp ((gchar *)cur, "sip:", 4) ||
!g_ascii_strncasecmp ((gchar *)cur, "webcal:", 7)) {
tmpurl = url_extract (&cur, TRUE);
if (tmpurl) {
refurl = e_text_to_html (tmpurl, 0);
dispurl = g_strdup (refurl);
}
} else if (!g_ascii_strncasecmp ((gchar *)cur, "www.", 4) &&
is_url_char (*(cur + 4))) {
tmpurl = url_extract (&cur, FALSE);
if (tmpurl) {
dispurl = e_text_to_html (tmpurl, 0);
refurl = g_strdup_printf ("http://%s",
dispurl);
}
}
if (tmpurl) {
out = check_size (&buffer, &buffer_size, out,
strlen (refurl) +
strlen (dispurl) + 15);
out += sprintf (out,
"<a href=\"%s\">%s</a>",
refurl, dispurl);
col += strlen (tmpurl);
g_free (tmpurl);
g_free (refurl);
g_free (dispurl);
}
if (!*cur)
break;
u = g_utf8_get_char ((gchar *) cur);
}
if (u == '@' && (flags & E_TEXT_TO_HTML_CONVERT_ADDRESSES)) {
gchar *addr, *dispaddr, *outaddr;
addr = email_address_extract (&cur, &out, linestart);
if (addr) {
dispaddr = e_text_to_html (addr, 0);
outaddr = g_strdup_printf ("<a href=\"mailto:%s\">%s</a>",
addr, dispaddr);
out = check_size (&buffer, &buffer_size, out, strlen (outaddr));
out += sprintf (out, "%s", outaddr);
col += strlen (addr);
g_free (addr);
g_free (dispaddr);
g_free (outaddr);
if (!*cur)
break;
u = g_utf8_get_char ((gchar *) cur);
}
}
if (!g_unichar_validate (u)) {
/* Sigh. Someone sent undeclared 8-bit data.
* Assume it's iso-8859-1.
*/
u = *cur;
next = cur + 1;
} else
next = (const guchar *) g_utf8_next_char (cur);
out = check_size (&buffer, &buffer_size, out, 10);
switch (u) {
case '<':
strcpy (out, "<");
out += 4;
col++;
break;
case '>':
strcpy (out, ">");
out += 4;
col++;
break;
case '&':
strcpy (out, "&");
out += 5;
col++;
break;
case '"':
strcpy (out, """);
out += 6;
col++;
break;
case '\n':
if (flags & E_TEXT_TO_HTML_CONVERT_NL) {
strcpy (out, "<br>");
out += 4;
}
*out++ = *cur;
linestart = cur;
col = 0;
break;
case '\t':
if (flags & (E_TEXT_TO_HTML_CONVERT_SPACES |
E_TEXT_TO_HTML_CONVERT_NL)) {
do {
out = check_size (&buffer, &buffer_size,
out, 7);
strcpy (out, " ");
out += 6;
col++;
} while (col % 8);
break;
}
/* otherwise, FALL THROUGH */
case ' ':
if (flags & E_TEXT_TO_HTML_CONVERT_SPACES) {
if (cur == (const guchar *) input ||
*(cur + 1) == ' ' || *(cur + 1) == '\t' ||
*(cur - 1) == '\n') {
strcpy (out, " ");
out += 6;
col++;
break;
}
}
/* otherwise, FALL THROUGH */
default:
if ((u >= 0x20 && u < 0x80) ||
(u == '\r' || u == '\t')) {
/* Default case, just copy. */
*out++ = u;
} else {
if (flags & E_TEXT_TO_HTML_ESCAPE_8BIT)
*out++ = '?';
else
out += g_snprintf(out, 9, "&#%d;", u);
}
col++;
break;
}
}
out = check_size (&buffer, &buffer_size, out, 7);
if (flags & E_TEXT_TO_HTML_PRE)
strcpy (out, "</PRE>");
else
*out = '\0';
return buffer;
}
