X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=src%2Fwidgets%2Fmodest-validating-entry.c;h=08994c3438e2b061a75ae3ce0fbdb7174527c7a2;hb=94a4612a68cf9129d80418e40d177911297b76e7;hp=b1d1191716b01570998dc241b2b0925f7a8ab8c2;hpb=7e7be75d6f353df4d1c605d5df3011457f51a926;p=modest diff --git a/src/widgets/modest-validating-entry.c b/src/widgets/modest-validating-entry.c index b1d1191..08994c3 100644 --- a/src/widgets/modest-validating-entry.c +++ b/src/widgets/modest-validating-entry.c @@ -12,14 +12,14 @@ #include #endif -G_DEFINE_TYPE (EasysetupValidatingEntry, easysetup_validating_entry, GTK_TYPE_ENTRY); +G_DEFINE_TYPE (ModestValidatingEntry, modest_validating_entry, GTK_TYPE_ENTRY); #define VALIDATING_ENTRY_GET_PRIVATE(o) \ - (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASYSETUP_TYPE_VALIDATING_ENTRY, EasysetupValidatingEntryPrivate)) + (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEST_TYPE_VALIDATING_ENTRY, ModestValidatingEntryPrivate)) -typedef struct _EasysetupValidatingEntryPrivate EasysetupValidatingEntryPrivate; +typedef struct _ModestValidatingEntryPrivate ModestValidatingEntryPrivate; -struct _EasysetupValidatingEntryPrivate +struct _ModestValidatingEntryPrivate { /* A list of gunichar, rather than char*, * because gunichar is easier to deal with internally, @@ -28,10 +28,16 @@ struct _EasysetupValidatingEntryPrivate GList *list_prevent; gboolean prevent_whitespace; + + EasySetupValidatingEntryFunc func; + gpointer func_user_data; + + EasySetupValidatingEntryMaxFunc max_func; + gpointer max_func_user_data; }; static void -easysetup_validating_entry_get_property (GObject *object, guint property_id, +modest_validating_entry_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { switch (property_id) { @@ -41,7 +47,7 @@ easysetup_validating_entry_get_property (GObject *object, guint property_id, } static void -easysetup_validating_entry_set_property (GObject *object, guint property_id, +modest_validating_entry_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { switch (property_id) { @@ -51,16 +57,16 @@ easysetup_validating_entry_set_property (GObject *object, guint property_id, } static void -easysetup_validating_entry_dispose (GObject *object) +modest_validating_entry_dispose (GObject *object) { - if (G_OBJECT_CLASS (easysetup_validating_entry_parent_class)->dispose) - G_OBJECT_CLASS (easysetup_validating_entry_parent_class)->dispose (object); + if (G_OBJECT_CLASS (modest_validating_entry_parent_class)->dispose) + G_OBJECT_CLASS (modest_validating_entry_parent_class)->dispose (object); } static void -easysetup_validating_entry_finalize (GObject *object) +modest_validating_entry_finalize (GObject *object) { - EasysetupValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (object); + ModestValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (object); /* Free the list and its items: */ if (priv->list_prevent) { @@ -68,20 +74,20 @@ easysetup_validating_entry_finalize (GObject *object) g_list_free (priv->list_prevent); } - G_OBJECT_CLASS (easysetup_validating_entry_parent_class)->finalize (object); + G_OBJECT_CLASS (modest_validating_entry_parent_class)->finalize (object); } static void -easysetup_validating_entry_class_init (EasysetupValidatingEntryClass *klass) +modest_validating_entry_class_init (ModestValidatingEntryClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (EasysetupValidatingEntryPrivate)); + g_type_class_add_private (klass, sizeof (ModestValidatingEntryPrivate)); - object_class->get_property = easysetup_validating_entry_get_property; - object_class->set_property = easysetup_validating_entry_set_property; - object_class->dispose = easysetup_validating_entry_dispose; - object_class->finalize = easysetup_validating_entry_finalize; + object_class->get_property = modest_validating_entry_get_property; + object_class->set_property = modest_validating_entry_set_property; + object_class->dispose = modest_validating_entry_dispose; + object_class->finalize = modest_validating_entry_finalize; } static gint @@ -101,8 +107,8 @@ on_insert_text(GtkEditable *editable, gint *position, gpointer user_data) { - EasysetupValidatingEntry *self = EASYSETUP_VALIDATING_ENTRY (user_data); - EasysetupValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (self); + ModestValidatingEntry *self = MODEST_VALIDATING_ENTRY (user_data); + ModestValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (self); if(!new_text_length) return; @@ -128,6 +134,10 @@ on_insert_text(GtkEditable *editable, GList *found = g_list_find_custom(priv->list_prevent, &one_char, &on_list_compare); if(found) { allow = FALSE; + if (priv->func) + { + priv->func(self, iter, priv->func_user_data); + } break; } } @@ -137,6 +147,10 @@ on_insert_text(GtkEditable *editable, gunichar one_char = g_utf8_get_char (iter); if (g_unichar_isspace (one_char)) { allow = FALSE; + if (priv->func) + { + priv->func(self, NULL, priv->func_user_data); + } break; } } @@ -146,6 +160,25 @@ on_insert_text(GtkEditable *editable, iter = g_utf8_find_next_char (iter, new_text + new_text_length); } + /* Prevent more than the max characters. + * The regular GtkEntry does this already, but we also want to call a specified callback, + * so that the application can show a warning dialog. */ + if(priv->max_func) { + const gint max_num = gtk_entry_get_max_length (GTK_ENTRY (self)); + if (max_num > 0) { + const gchar *existing_text = gtk_entry_get_text (GTK_ENTRY(self)); + const gint existing_length = existing_text ? g_utf8_strlen (existing_text, -1) : 0; + const gint new_length_chars = g_utf8_strlen (new_text, new_text_length); + + if ((existing_length + new_length_chars) > max_num) { + priv->max_func (self, priv->max_func_user_data); + /* We shouldn't need to stop the signal because the underlying code will check too. + * Well, that would maybe be a performance optimization, + * but it's generally safer not to interfere too much. */ + } + } + } + if(!allow) { /* The signal documentation says * "by connecting to this signal and then stopping the signal with @@ -154,10 +187,11 @@ on_insert_text(GtkEditable *editable, */ gtk_signal_emit_stop_by_name (GTK_OBJECT (self), "insert-text"); } + } static void -easysetup_validating_entry_init (EasysetupValidatingEntry *self) +modest_validating_entry_init (ModestValidatingEntry *self) { /* Connect to the GtkEditable::insert-text signal * so we can filter out some characters: @@ -166,19 +200,19 @@ easysetup_validating_entry_init (EasysetupValidatingEntry *self) g_signal_connect (G_OBJECT (self), "insert-text", (GCallback)&on_insert_text, self); } -EasysetupValidatingEntry* -easysetup_validating_entry_new (void) +ModestValidatingEntry* +modest_validating_entry_new (void) { - return g_object_new (EASYSETUP_TYPE_VALIDATING_ENTRY, NULL); + return g_object_new (MODEST_TYPE_VALIDATING_ENTRY, NULL); } /** Specify characters that may not be entered into this GtkEntry. * * list: A list of gchar* strings. Each one identifies a UTF-8 character. */ -void easysetup_validating_entry_set_unallowed_characters (EasysetupValidatingEntry *self, GList *list) +void modest_validating_entry_set_unallowed_characters (ModestValidatingEntry *self, GList *list) { - EasysetupValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (self); + ModestValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (self); /* Free the list and its items: */ if (priv->list_prevent) { @@ -203,8 +237,30 @@ void easysetup_validating_entry_set_unallowed_characters (EasysetupValidatingEnt /** Specify that no whitespace characters may be entered into this GtkEntry. * */ -void easysetup_validating_entry_set_unallowed_characters_whitespace (EasysetupValidatingEntry *self) +void modest_validating_entry_set_unallowed_characters_whitespace (ModestValidatingEntry *self) { - EasysetupValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (self); + ModestValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (self); priv->prevent_whitespace = TRUE; } + +/** Set a callback to be called when the maximum number of characters have been entered. + * This may be used to show an informative dialog. + */ +void modest_validating_entry_set_max_func (ModestValidatingEntry *self, EasySetupValidatingEntryMaxFunc func, gpointer user_data) +{ + ModestValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (self); + priv->max_func = func; + priv->max_func_user_data = user_data; +} + +/** Set a callback to be called when a character was prevented so that a + * note can be shown by the application to inform the user. For whitespaces, + * character will be NULL + */ +void modest_validating_entry_set_func (ModestValidatingEntry *self, EasySetupValidatingEntryFunc func, gpointer user_data) +{ + ModestValidatingEntryPrivate *priv = VALIDATING_ENTRY_GET_PRIVATE (self); + priv->func = func; + priv->func_user_data = user_data; +} +