GtkEntry change text on user input

Question

In a gui I want to modify the text a user inserts in a GtkEntry. eg if the user enters 'joHn doe', my gui should see this is not a nicely formatted name and changes this into 'John Doe'.

I connect the a handler to "changed" signal as described in eg GtkEntry text change signal. The problem that occurs is if I change the entry in my signal handler, the "changed" signal is emitted again and again until kingdom comes.

I currently prevent this by doing a string comparison, and I only change the text in the GtkEntryBuffer if the text "namified" version is unequal to the text inside the entry. However I feel like as programmer I should be able to change the the text inside the entry without that the changed handler is called over and over again.

The changed signal handler is:

void nameify_entry ( GtkEditable* editable, gpointer data )
{
    gchar* nameified;
    const gchar *entry_text;

    entry_text = gtk_entry_get_text( GTK_ENTRY(editable) );
    nameified = nameify(entry_text);

    /*is it possible to change the buffer without this using this string
      comparison, without the "change" signal being emitted over and over again?*/
    if ( g_strcmp0(entry_text, nameified) != 0 ){
        GtkEntryBuffer* buf = gtk_entry_get_buffer(GTK_ENTRY(editable) );
        gtk_entry_buffer_set_text( buf, nameified, -1 );
    }
    g_free(nameified);
}

and my nameify function is:

/*removes characters that should not belong to a name*/
gchar*
nameify ( const char* cstr )
{
    const char* c;
    gchar* ret_val;
    GString* s = g_string_new("");

    gboolean uppercase_next = TRUE;
    g_debug( "string = %s", cstr);

    for ( c = cstr; *c != '0'; c = g_utf8_next_char(c) ) {
        gunichar cp = g_utf8_get_char(c); 
        if ( cp == 0 ) break;
        if ( g_unichar_isalpha( cp ) ){
            if ( uppercase_next ){
                g_string_append_unichar( s, g_unichar_toupper(cp) );
                uppercase_next = FALSE;
            }
            else{
                g_string_append_unichar(s,g_unichar_tolower(cp));
            }
        }
        if ( cp == '-' ){
            g_string_append_unichar( s, cp);
            uppercase_next = TRUE;
        }
        if ( cp == ' '){
            g_string_append_unichar( s, cp);
            uppercase_next = TRUE;
        }
    }

    ret_val = s->str;
    g_string_free(s, FALSE);
    return ret_val;
}

any help is most welcome.

Answer 1

It's not really handy to connect to the 'changed' signal, but more appropriate to connect to the 'insert-text' signal. Even better to have the default 'insert-text' handler update the entry. Than use g_signal_connect_after on the 'insert-text' signal to update the text in the entry this prevents the changed signal to run infinitely. This should also be done to the 'delete-text' signal, because if a user deletes a capital letter, the capital should be removed and the second should be capitalized.

so on creation run:

g_signal_connect_after( entry, "insert-text", G_CALLBACK(name_insert_after), NULL );
g_signal_connect_after( entry, "delete-text", G_CALLBACK(name_delete_after), NULL );

Then you can have these signal handlers:

void
name_insert_after (GtkEditable* edit,
                   gchar* new_text,
                   gint new_length,
                   gpointer position,
                   gpointer data)
{
    /*prevent compiler warnings about unused variables*/
    (void) new_text; (void) new_length; (void) position; (void) data;
    const gchar* content = gtk_entry_get_text( GTK_ENTRY(edit) );
    gchar* modified = nameify( content);
    gtk_entry_set_text(GTK_ENTRY(edit),modified);
    g_free(modified);
}

void
name_delete_after (GtkEditable* edit,
                   gint start_pos,
                   gint end_pos,
                   gpointer data)
{
    /*no op cast to prevent compiler warnings*/
    (void) start_pos; (void) end_pos; (void) data;
    /*get text and modify the entry*/
    int cursor_pos = gtk_editable_get_position(edit);
    const gchar* content = gtk_entry_get_text( GTK_ENTRY(edit) );
    gchar* modified = nameify( content);
    gtk_entry_set_text(GTK_ENTRY(edit),modified);
    gtk_editable_set_position(edit, cursor_pos);
    g_free(modified);
}

and these can than be used with the nameify function in the original post. you might even provide a function pointer at the data instead of 'NULL' to use this one handler with different functions that are able to modify the string in the entry.

Answer 2

For your requirement insert-text signal seems more appropriate. insert-text is made available to make possible changes to the text before being entered. You can make use of the callback function template insert_text_handler part of the description of GtkEditable. You can make use of nameify with changes to the function (as you will not get the whole text but parts of text or chars; simplest modification could be to declare uppercase_next static) for making modification to the text.
Hope this helps!

Answer 3

The quickest solution in my opinion would be to temporarily block your callback from being called.

The g_signal_connect group of functions each return a "handler_id" of type gulong. You will have to store this id, pass it to your callback using the "userdata" argument (or just use a global static variable instead), then put your text manipulation code in between a g_signal_handler_block/g_signal_handler_unblock pair.

Answer 4

Connecting to insert-text and delete-text is the right idea but you want to connect using g_signal_connect. If you use g_signal_connect_after then the incorrect text has already been displayed before you correct it, which might cause the display to flicker. Also you need to block your signal handlers when calling gtk_entry_set_text as this emits delete-text followed by insert-text. If you don't block the signals you will recursively call your signal handlers. Remember GObject signals are just function calls. Emitting a signal is the same as calling the handlers directly from your code.

I would suggest having a handler for insert-text that looks to see if it needs to change the new input. If it does then create a new string and do this as per the GtkEditable documentation

g_signal_handlers_block_by_func (editable, insert_text_handler, data);
gtk_editable_insert_text (editable, new-text, g_strlen(new_text) , position);
g_signal_handlers_unblock_by_func (editable, insert_text_handler, data);

g_signal_stop_emission_by_name (editable, "insert_text");

If you don't need to change the input just return.

For the delete-text handler I'd look to see if you need to change the text (remembering that nothing will have been deleted yet) and if so update the whole string with

g_signal_handlers_block_by_func (editable, insert_text_handler, data);
g_signal_handlers_block_by_func (editable, delete_text_handler, data);
gtk_entry_set_text (GKT_ENTRY (editable), new-text);
g_signal_handlers_unblock_by_func (editable, delete_text_handler, data);
g_signal_handlers_unblock_by_func (editable, insert_text_handler, data);

g_signal_stop_emission_by_name (editable, "delete_text");

again just return if you don't need to change the text.

Answer 5

simpler than blocking and unblocking your signal just have a boolean:

myHandler(...){
static int recursing=0;
if(recursing){
    recursing=0;
    return;
}
... logic to decide if a change is needed
recursing=1;
gtk_entru_set_text(...);
... will recurse to your hander, which will clear the recursing variable and resume here
}