#include <glib.h>
#include <gtk/gtk.h>
+#include <gtk/gtkmarshal.h>
#include <gdk/gdkkeysyms.h>
#include <time.h>
#include <stdlib.h>
#include <hildon-widgets/hildon-calendar-popup.h>
#include <hildon-widgets/gtk-infoprint.h>
#include <hildon-widgets/hildon-defines.h>
+#include <hildon-widgets/hildon-input-mode-hint.h>
#include "hildon-composite-widget.h"
+#include "hildon-marshalers.h"
#ifdef HAVE_CONFIG_H
#include<config.h>
#define MAX_DATE_LEN 256
#define ENTRY_BORDERS 11
#define DATE_EDITOR_HEIGHT 30
+#define BUTTON_SPACING 6
#define DAY_ENTRY_WIDTH 2
#define MONTH_ENTRY_WIDTH 2
static gboolean
hildon_date_editor_entry_released(GtkWidget * widget,
GdkEventButton * event, gpointer data);
-
static gboolean
hildon_date_editor_released(GtkWidget * widget, GdkEventButton * event,
gpointer data);
static gboolean
hildon_date_editor_keyrelease(GtkWidget * widget, GdkEventKey * event,
gpointer data);
+static void
+hildon_date_editor_entry_validate(GtkEditable *widget, gpointer data);
static gboolean
-hildon_date_editor_focus_out(GtkWidget * widget, GdkEventFocus * event,
- gpointer data);
+hildon_date_editor_entry_focus_out(GtkWidget * widget, GdkEventFocus * event,
+ gpointer data);
+
+static gboolean hildon_date_editor_date_error(HildonDateEditor *editor,
+ HildonDateEditorErrorType type);
+
+static gboolean hildon_date_editor_entry_focusin(GtkWidget * widget,
+ GdkEventFocus * event,
+ gpointer data);
+static void hildon_date_editor_get_property( GObject *object, guint param_id,
+ GValue *value, GParamSpec *pspec );
+static void hildon_date_editor_set_property (GObject *object, guint param_id,
+ const GValue *value, GParamSpec *pspec);
static gboolean
hildon_date_editor_mnemonic_activate(GtkWidget *widget, gboolean group_cycling);
static void hildon_date_editor_finalize(GObject * object);
+static gboolean
+_hildon_date_editor_entry_select_all(GtkWidget *widget);
+
+enum
+{
+ PROP_DAY = 1,
+ PROP_MONTH,
+ PROP_YEAR
+};
+
struct _HildonDateEditorPrivate {
guint year; /* current year in the entry */
guint month; /* current month in the entry */
GtkWidget *d_image; /* normal icon image */
GtkWidget *d_image_pressed;
guint locale_type;
+
+ gboolean skip_validation;
};
enum {
YEAR_MONTH_DAY
};
+enum {
+ DATE_ERROR,
+ LAST_SIGNAL
+};
+
+static guint date_editor_signals[LAST_SIGNAL] = { 0 };
+
GType hildon_date_editor_get_type(void)
{
static GType editor_type = 0;
{
GtkContainerClass *container_class = GTK_CONTAINER_CLASS(editor_class);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(editor_class);
-
+ GObjectClass *gobject_class = G_OBJECT_CLASS (editor_class);
+
parent_class = g_type_class_peek_parent(editor_class);
g_type_class_add_private(editor_class,
sizeof(HildonDateEditorPrivate));
+ gobject_class->set_property = hildon_date_editor_set_property;
+ gobject_class->get_property = hildon_date_editor_get_property;
widget_class->mnemonic_activate = hildon_date_editor_mnemonic_activate;
widget_class->size_request = hildon_date_editor_size_request;
widget_class->size_allocate = hildon_date_editor_size_allocate;
container_class->forall = hildon_child_forall;
GTK_OBJECT_CLASS(editor_class)->destroy = hildon_date_editor_destroy;
- G_OBJECT_CLASS(editor_class)->finalize = hildon_date_editor_finalize;
+ gobject_class->finalize = hildon_date_editor_finalize;
+
+ editor_class->date_error = hildon_date_editor_date_error;
+
+ date_editor_signals[DATE_ERROR] =
+ g_signal_new("date-error",
+ G_OBJECT_CLASS_TYPE(gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET(HildonDateEditorClass, date_error),
+ g_signal_accumulator_true_handled, NULL,
+ _hildon_marshal_BOOLEAN__INT,
+ G_TYPE_BOOLEAN, 1, G_TYPE_INT);
+
+ /**
+ * HildonDateEditor:year:
+ *
+ * Current year.
+ */
+ g_object_class_install_property( gobject_class, PROP_YEAR,
+ g_param_spec_uint("year",
+ "Current year",
+ "Current year",
+ 1, 2100,
+ 2005,
+ G_PARAM_READABLE | G_PARAM_WRITABLE) );
+
+ /**
+ * HildonControlbar:month:
+ *
+ * Current month.
+ */
+ g_object_class_install_property( gobject_class, PROP_MONTH,
+ g_param_spec_uint("month",
+ "Current month",
+ "Current month",
+ 1, 12,
+ 1,
+ G_PARAM_READABLE | G_PARAM_WRITABLE) );
+
+ /**
+ * HildonControlbar:day:
+ *
+ * Current day.
+ */
+ g_object_class_install_property( gobject_class, PROP_DAY,
+ g_param_spec_uint("day",
+ "Current day",
+ "Current day",
+ 1, 31,
+ 1,
+ G_PARAM_READABLE | G_PARAM_WRITABLE) );
}
static void hildon_date_editor_init(HildonDateEditor * editor)
/* make widgets */
priv->frame = gtk_frame_new(NULL);
+ gtk_container_set_border_width(GTK_CONTAINER(priv->frame), 0);
priv->d_entry = gtk_entry_new();
priv->m_entry = gtk_entry_new();
priv->y_entry = gtk_entry_new();
priv->editor_pressed = FALSE;
-
+ g_object_set (G_OBJECT(priv->d_entry), "input-mode",
+ HILDON_INPUT_MODE_HINT_NUMERIC, NULL);
+ g_object_set (G_OBJECT(priv->m_entry), "input-mode",
+ HILDON_INPUT_MODE_HINT_NUMERIC, NULL);
+ g_object_set (G_OBJECT(priv->y_entry), "input-mode",
+ HILDON_INPUT_MODE_HINT_NUMERIC, NULL);
+
/* set entry look */
gtk_entry_set_width_chars(GTK_ENTRY(priv->d_entry), DAY_ENTRY_WIDTH);
gtk_entry_set_width_chars(GTK_ENTRY(priv->m_entry), MONTH_ENTRY_WIDTH);
gtk_entry_set_has_frame(GTK_ENTRY(priv->m_entry), FALSE);
gtk_entry_set_has_frame(GTK_ENTRY(priv->y_entry), FALSE);
- priv->dm_delim = gtk_label_new("/");
- priv->my_delim = gtk_label_new("/");
+ priv->dm_delim = gtk_label_new(_("Ecdg_ti_date_editor_separator"));
+ priv->my_delim = gtk_label_new(_("Ecdg_ti_date_editor_separator"));
priv->d_box_date = gtk_hbox_new(FALSE, 0);
priv->d_event_box_image = gtk_event_box_new();
priv->d_image = gtk_image_new_from_icon_name("qgn_widg_datedit",
- HILDON_ICON_SIZE_WIDG);
+ HILDON_ICON_SIZE_WIDG);
priv->d_image_pressed = gtk_image_new_from_icon_name("qgn_widg_datedit_pr",
- HILDON_ICON_SIZE_WIDG);
+ HILDON_ICON_SIZE_WIDG);
g_object_ref(G_OBJECT(priv->d_image));
g_object_ref(G_OBJECT(priv->d_image_pressed));
gtk_object_sink(GTK_OBJECT(priv->d_image));
gtk_widget_show_all(priv->frame);
gtk_widget_show_all(priv->d_event_box_image);
- /* set signals */
+
+
+ /* image signal connects */
g_signal_connect(GTK_OBJECT(priv->d_event_box_image), "button_press_event",
G_CALLBACK(hildon_date_editor_icon_press), editor);
"button_release_event",
G_CALLBACK(hildon_date_editor_released), editor);
+ g_signal_connect(GTK_OBJECT(priv->d_event_box_image), "key-press-event",
+ G_CALLBACK(hildon_date_editor_keypress), editor);
+
+ g_signal_connect(GTK_OBJECT(priv->d_image), "key-press-event",
+ G_CALLBACK(hildon_date_editor_keypress), editor);
+
+
+ /* entry signal connects */
g_signal_connect(GTK_OBJECT(priv->d_entry), "button_release_event",
G_CALLBACK(hildon_date_editor_entry_released), editor);
+
+ g_signal_connect(GTK_OBJECT(priv->d_entry), "focus-in-event",
+ G_CALLBACK(hildon_date_editor_entry_focusin), editor);
g_signal_connect(GTK_OBJECT(priv->m_entry), "button_release_event",
G_CALLBACK(hildon_date_editor_entry_released), editor);
+ g_signal_connect(GTK_OBJECT(priv->m_entry), "focus-in-event",
+ G_CALLBACK(hildon_date_editor_entry_focusin), editor);
+
g_signal_connect(GTK_OBJECT(priv->y_entry), "button_release_event",
G_CALLBACK(hildon_date_editor_entry_released), editor);
+ g_signal_connect(GTK_OBJECT(priv->y_entry), "focus-in-event",
+ G_CALLBACK(hildon_date_editor_entry_focusin), editor);
+
g_signal_connect(GTK_OBJECT(priv->d_entry), "focus-out-event",
- G_CALLBACK(hildon_date_editor_focus_out), editor);
+ G_CALLBACK(hildon_date_editor_entry_focus_out), editor);
g_signal_connect(GTK_OBJECT(priv->m_entry), "focus-out-event",
- G_CALLBACK(hildon_date_editor_focus_out), editor);
+ G_CALLBACK(hildon_date_editor_entry_focus_out), editor);
g_signal_connect(GTK_OBJECT(priv->y_entry), "focus-out-event",
- G_CALLBACK(hildon_date_editor_focus_out), editor);
+ G_CALLBACK(hildon_date_editor_entry_focus_out), editor);
g_signal_connect(GTK_OBJECT(priv->d_entry), "key-press-event",
G_CALLBACK(hildon_date_editor_keypress), editor);
g_signal_connect(GTK_OBJECT(priv->y_entry), "key-release-event",
G_CALLBACK(hildon_date_editor_keyrelease), editor);
- g_signal_connect(GTK_OBJECT(priv->d_event_box_image), "key-press-event",
- G_CALLBACK(hildon_date_editor_keypress), editor);
+ g_signal_connect(GTK_OBJECT(priv->d_entry), "changed",
+ G_CALLBACK(hildon_date_editor_entry_validate), editor);
- g_signal_connect(GTK_OBJECT(priv->d_image), "key-press-event",
- G_CALLBACK(hildon_date_editor_keypress), editor);
+ g_signal_connect(GTK_OBJECT(priv->m_entry), "changed",
+ G_CALLBACK(hildon_date_editor_entry_validate), editor);
+
+ g_signal_connect(GTK_OBJECT(priv->y_entry), "changed",
+ G_CALLBACK(hildon_date_editor_entry_validate), editor);
hildon_date_editor_set_date(editor, priv->year, priv->month, priv->day);
gtk_widget_pop_composite_child();
}
+static void hildon_date_editor_set_property (GObject *object, guint param_id,
+ const GValue *value, GParamSpec *pspec)
+{
+ HildonDateEditor *editor = HILDON_DATE_EDITOR(object);
+ switch (param_id)
+ {
+ case PROP_YEAR:
+ hildon_date_editor_set_year (editor, g_value_get_uint(value));
+ break;
+
+ case PROP_MONTH:
+ hildon_date_editor_set_month (editor, g_value_get_uint(value));
+ break;
+
+ case PROP_DAY:
+ hildon_date_editor_set_day (editor, g_value_get_uint(value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
+ break;
+ }
+}
+
+static void hildon_date_editor_get_property( GObject *object, guint param_id,
+ GValue *value, GParamSpec *pspec )
+{
+ HildonDateEditor *editor = HILDON_DATE_EDITOR(object);
+ switch (param_id)
+ {
+ case PROP_YEAR:
+ g_value_set_uint (value, hildon_date_editor_get_year (editor));
+ break;
+
+ case PROP_MONTH:
+ g_value_set_uint (value, hildon_date_editor_get_month (editor));
+ break;
+
+ case PROP_DAY:
+ g_value_set_uint (value, hildon_date_editor_get_day (editor));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
+ break;
+ }
+}
+
static gboolean
hildon_date_editor_mnemonic_activate(GtkWidget *widget, gboolean group_cycling)
entry = priv->d_entry;
gtk_widget_grab_focus( entry );
- gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
+ g_idle_add((GSourceFunc)_hildon_date_editor_entry_select_all, entry);
return TRUE;
}
* if the date specified by the arguments is not valid, the
* function returns.
**/
-
void hildon_date_editor_set_date(HildonDateEditor * date,
guint year, guint month, guint day)
{
- HildonDateEditorPrivate *priv;
- gchar date_str[MAX_DATE_LEN + 1];
- GDate cur_date;
-
g_return_if_fail(date);
g_return_if_fail(HILDON_IS_DATE_EDITOR(date));
- priv = HILDON_DATE_EDITOR_GET_PRIVATE(date);
- g_date_clear(&cur_date, 1);
-
- /* validate given date */
- if (g_date_valid_dmy(day, month, year)) {
- if (priv->y_orig == 0) {
- priv->y_orig = year;
- priv->m_orig = month;
- priv->d_orig = day;
- }
-
- g_date_set_dmy(&cur_date, day, month, year);
- priv->day = day;
- priv->month = month;
- priv->year = year;
-
- /* write date to entries */
- g_date_strftime(date_str, MAX_DATE_LEN, "%d", &cur_date);
- gtk_entry_set_text(GTK_ENTRY(priv->d_entry), date_str);
-
- g_date_strftime(date_str, MAX_DATE_LEN, "%m", &cur_date);
- gtk_entry_set_text(GTK_ENTRY(priv->m_entry), date_str);
-
- g_date_strftime(date_str, MAX_DATE_LEN, "%EY", &cur_date);
- gtk_entry_set_text(GTK_ENTRY(priv->y_entry), date_str);
- }
+ hildon_date_editor_set_year(date, year);
+ hildon_date_editor_set_month(date, month);
+ hildon_date_editor_set_day(date, day);
}
/**
* This function returns the year, month, and day currently on the
* date editor.
**/
-
void hildon_date_editor_get_date(HildonDateEditor * date,
guint * year, guint * month, guint * day)
{
priv = HILDON_DATE_EDITOR_GET_PRIVATE(date);
- *year = priv->year;
- *month = priv->month;
- *day = priv->day;
+ /*dont know why these variable are used, i think it makes more
+ * sense to directly get the content from the current text entry field*/
+ *year = /*priv->year;*/
+ (guint) atoi(gtk_entry_get_text(GTK_ENTRY(priv->y_entry)));
+ *month = /*priv->month;*/
+ (guint) atoi(gtk_entry_get_text(GTK_ENTRY(priv->m_entry)));
+ *day = /*priv->day;*/
+ (guint) atoi(gtk_entry_get_text(GTK_ENTRY(priv->d_entry)));
}
static gboolean hildon_date_editor_icon_press(GtkWidget * widget,
HildonDateEditor *ed;
HildonDateEditorPrivate *priv;
- g_return_val_if_fail(widget, FALSE);
- g_return_val_if_fail(event, FALSE);
- g_return_val_if_fail(data, FALSE);
-
ed = HILDON_DATE_EDITOR(data);
priv = HILDON_DATE_EDITOR_GET_PRIVATE(ed);
if (priv->valid_value && event->button == 1) {
- GtkEntry *e = GTK_ENTRY(widget);
- gint start = 0, end = gtk_entry_get_max_length(e);
/* We might not get focus because unvalid values in entries */
if (GTK_WIDGET_HAS_FOCUS(widget))
- gtk_editable_select_region(GTK_EDITABLE(e), start, end);
+ g_idle_add((GSourceFunc)
+ _hildon_date_editor_entry_select_all, GTK_ENTRY(widget));
} else
priv->valid_value = TRUE;
return FALSE;
}
+static gboolean hildon_date_editor_entry_focusin(GtkWidget * widget,
+ GdkEventFocus * event,
+ gpointer data)
+{
+ if (!GTK_ENTRY(widget)->button)
+ {
+ g_idle_add((GSourceFunc)
+ _hildon_date_editor_entry_select_all, GTK_ENTRY(widget));
+ }
+
+ return FALSE;
+}
+
+
/* This handler is called from mainloop
after button exposes are processed */
static gboolean idle_popup(gpointer data)
return FALSE;
}
+static void
+hildon_date_editor_entry_validate(GtkEditable *widget, gpointer data)
+{
+ HildonDateEditor *ed;
+ HildonDateEditorPrivate *priv;
+
+ gint d, m, y;
+ gboolean r; /*return value storage needed, but no real use*/
+
+ g_return_if_fail(data);
+ g_return_if_fail(widget);
+
+ ed = HILDON_DATE_EDITOR(data);
+ priv = HILDON_DATE_EDITOR_GET_PRIVATE(ed);
+
+ /*if the field is empty, we skip the checking*/
+ if(gtk_entry_get_text(GTK_ENTRY(widget)) == NULL ||
+ *gtk_entry_get_text(GTK_ENTRY(widget)) == '\0')
+ return;
+
+ if(!priv->skip_validation) {
+ d = atoi(gtk_entry_get_text(GTK_ENTRY(priv->d_entry)));
+ m = atoi(gtk_entry_get_text(GTK_ENTRY(priv->m_entry)));
+ y = atoi(gtk_entry_get_text(GTK_ENTRY(priv->y_entry)));
+
+ /*NOTICE we could/should use hildon_date_editor_set_year and such functions
+ * to set the date, instead of use gtk_entry_set_text, and then change the priv member
+ * but hildon_date_editor_set_year and such functions check if the date is valid,
+ * we do want to do date validation check here according to spec*/
+ if(GTK_WIDGET(widget) == priv->d_entry)
+ {
+ if(d > 0 && d < 32) {
+ priv->day = d;
+ return;
+ }
+ else if(d < 1) {
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ MIN_DAY, &r);
+ gtk_entry_set_text(GTK_ENTRY(priv->d_entry), "01");
+ priv->day = priv->d_orig = 1;
+ }
+ else {
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ MAX_DAY, &r);
+ gtk_entry_set_text(GTK_ENTRY(priv->d_entry), "31");
+ priv->day = priv->d_orig = 31;
+ }
+ g_idle_add ((GSourceFunc)
+ _hildon_date_editor_entry_select_all,
+ priv->d_entry);
+ return;
+ }
+
+ if(GTK_WIDGET(widget) == priv->m_entry)
+ {
+ if(m > 0 && m < 13)
+ {
+ priv->month = m;
+ return;
+ }
+ else if(m < 1)
+ {
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ MIN_MONTH, &r);
+ gtk_entry_set_text(GTK_ENTRY(priv->m_entry), "01");
+ priv->month = priv->m_orig = 1;
+
+ }
+ else
+ {
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ MAX_MONTH, &r);
+ gtk_entry_set_text(GTK_ENTRY(priv->m_entry), "12");
+ priv->month = priv->m_orig = 12;
+ }
+
+ g_idle_add ((GSourceFunc)
+ _hildon_date_editor_entry_select_all,
+ priv->m_entry);
+ return;
+ }
+
+ if(GTK_WIDGET(widget) == priv->y_entry)
+ {
+ if(y >= 1 && y <= 2100) {
+ priv->year = y;
+ return;
+ }
+ else if(y < 1) {
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ MIN_YEAR, &r);
+ gtk_entry_set_text(GTK_ENTRY(priv->y_entry), "0001");
+ priv->year = priv->y_orig = 1;
+ }
+ /* y > 2100 */
+ else {
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ MAX_YEAR, &r);
+ gtk_entry_set_text(GTK_ENTRY(priv->y_entry), "2100");
+ priv->year = priv->y_orig = 2100;
+ }
+ g_idle_add ((GSourceFunc)
+ _hildon_date_editor_entry_select_all,
+ priv->y_entry);
+ return;
+ }
+ }
+}
+
static gboolean hildon_date_editor_keyrelease(GtkWidget * widget,
GdkEventKey * event,
gpointer data)
priv->editor_pressed = FALSE;
return TRUE;
}
- }
+ } else if (event->keyval == GDK_Escape)
+ priv->skip_validation = FALSE;
+
return FALSE;
}
GdkEventKey * event,
gpointer data)
{
+
HildonDateEditor *ed;
HildonDateEditorPrivate *priv;
gint pos;
priv = HILDON_DATE_EDITOR_GET_PRIVATE(ed);
pos = gtk_editable_get_position(GTK_EDITABLE(widget));
- if (event->keyval == GDK_KP_Enter ||
- event->keyval == GDK_Return || event->keyval == GDK_ISO_Enter) {
+ if (event->keyval == GDK_Return || event->keyval == GDK_ISO_Enter) {
if (!priv->editor_pressed) {
gtk_container_remove(GTK_CONTAINER(priv->d_event_box_image),
priv->d_image);
return FALSE;
}
+ if (event->keyval == GDK_KP_Enter)
+ return FALSE;
+
+
+
/* We don't want wrap */
if (event->keyval == GDK_KP_Left || event->keyval == GDK_Left)
if (pos == 0) {
case GDK_Down:
return FALSE;
+ case GDK_Escape:
+ priv->skip_validation = TRUE;
+ return FALSE;
+
/* select date */
default:
return TRUE;
}
}
-/* Entry looses focus. Validate the date */
-static gboolean hildon_date_editor_focus_out(GtkWidget * widget,
+static gboolean hildon_date_editor_entry_focus_out(GtkWidget * widget,
GdkEventFocus * event,
gpointer data)
{
- gint d, m, y;
- HildonDateEditor *ed;
- HildonDateEditorPrivate *priv;
- gchar new_val[5];
- GDate gd;
-
- g_return_val_if_fail(widget, FALSE);
- g_return_val_if_fail(data, FALSE);
-
- ed = HILDON_DATE_EDITOR(data);
- priv = HILDON_DATE_EDITOR_GET_PRIVATE(ed);
-
- /* deselect the entry */
- if (widget == priv->d_entry)
- gtk_editable_select_region(GTK_EDITABLE(priv->d_entry), 0, 0);
-
- if (widget == priv->m_entry)
- gtk_editable_select_region(GTK_EDITABLE(priv->m_entry), 0, 0);
-
- if (widget == priv->y_entry)
- gtk_editable_select_region(GTK_EDITABLE(priv->y_entry), 0, 0);
-
- g_date_clear(&gd, 1);
- g_date_set_time(&gd, time(NULL));
-
- /* get texts */
- d = atoi(gtk_entry_get_text(GTK_ENTRY(priv->d_entry)));
- m = atoi(gtk_entry_get_text(GTK_ENTRY(priv->m_entry)));
- y = atoi(gtk_entry_get_text(GTK_ENTRY(priv->y_entry)));
-
- /* if date is not valid, fix it */
- if (!g_date_valid_dmy(d, m, y)) {
- /* Year is illegal, year 0 is not allowed by this code */
- if ((g_utf8_strlen(gtk_entry_get_text(GTK_ENTRY(priv->y_entry)),
- -1) == 0) || (y == 0)) {
- gint end = gtk_entry_get_max_length(GTK_ENTRY(priv->y_entry));
-
- gtk_infoprint(NULL, "Set a value");
-
- /* set year to current year or to orignal value, if one exists
- */
- if (priv->y_orig == 0)
- y = g_date_get_year(&gd);
- else
- y = priv->y_orig;
-
- sprintf(new_val, "%02d", y);
- gtk_entry_set_text(GTK_ENTRY(priv->y_entry), new_val);
- gtk_widget_grab_focus(priv->y_entry);
-
- gtk_editable_select_region(GTK_EDITABLE(priv->y_entry),
- 0, end);
- priv->valid_value = FALSE;
- }
-
- /* month is illegal */
- else if ((g_utf8_strlen
- (gtk_entry_get_text(GTK_ENTRY(priv->m_entry)), -1) == 0)
- || (m == 0)) {
- gint end = gtk_entry_get_max_length(GTK_ENTRY(priv->m_entry));
+ HildonDateEditor *ed;
+ HildonDateEditorPrivate *priv;
+ gint d, m, y;
+ gboolean r; /*for the sake of signal emission*/
+ GDate gd;
- gtk_infoprintf(NULL, _("Ckct_ib_set_a_value_within_range"), 1, 12);
+ ed = HILDON_DATE_EDITOR(data);
+ priv = HILDON_DATE_EDITOR_GET_PRIVATE(ed);
- /* set month to current month or to orignal value, if one
- exists */
- if (priv->m_orig == 0)
- m = g_date_get_month(&gd);
- else
- m = priv->m_orig;
-
- sprintf(new_val, "%02d", m);
- gtk_entry_set_text(GTK_ENTRY(priv->m_entry), new_val);
- gtk_widget_grab_focus(priv->m_entry);
-
- gtk_editable_select_region(GTK_EDITABLE(priv->m_entry), 0,
- end);
- priv-> valid_value = FALSE;
- }
-
- /* day is illegal */
- else if ((g_utf8_strlen
- (gtk_entry_get_text(GTK_ENTRY(priv->d_entry)), -1) == 0)
- || (d == 0)) {
- gint end = gtk_entry_get_max_length(GTK_ENTRY(priv->d_entry));
-
- gtk_infoprintf(NULL, _("Ckct_ib_set_a_value_within_range"), 1, 31);
-
- /* set day to current day or to orginal value, if one exists */
- if (priv->d_orig == 0)
- d = g_date_get_day(&gd);
- else
- d = priv->d_orig;
-
- sprintf(new_val, "%02d", d);
- gtk_entry_set_text(GTK_ENTRY(priv->d_entry), new_val);
- gtk_widget_grab_focus(priv->d_entry);
-
- gtk_editable_select_region(GTK_EDITABLE(priv->d_entry), 0,
- end);
- priv->valid_value = FALSE;
- }
+ if (priv->skip_validation)
+ return FALSE;
- else {
- /* date is not valid. Check what's wrong and correct it */
- /* day entry was edited */
- if (widget == priv->d_entry) {
- gint l =
- gtk_entry_get_max_length(GTK_ENTRY(priv->d_entry));
- gint c;
-
- /* set day to 1 */
- if (d < 1) {
- d = 1;
- gtk_infoprint(NULL, "Minimum value is 1");
-
- sprintf(new_val, "%02d", d);
- gtk_entry_set_text(GTK_ENTRY(priv->d_entry),
- new_val);
- c = g_utf8_strlen(gtk_entry_get_text
- (GTK_ENTRY(priv->d_entry)), l);
- gtk_widget_grab_focus (priv->d_entry);
- gtk_editable_select_region(GTK_EDITABLE
- (priv->d_entry), 0, c);
- priv->valid_value = FALSE;
- }
- /* set day to max number of days in this month */
- else if (d > g_date_get_days_in_month(m,y)) {
- gchar info[256];
-
- d = g_date_get_days_in_month(m, y);
- g_snprintf(info,256, "Maximum value is %d", d);
- gtk_infoprint(NULL, info);
-
- sprintf(new_val, "%02d", d);
- gtk_entry_set_text(GTK_ENTRY(priv->d_entry),
- new_val);
- c = g_utf8_strlen(gtk_entry_get_text
- (GTK_ENTRY(priv->d_entry)), l);
- gtk_widget_grab_focus (priv->d_entry);
- gtk_editable_select_region(GTK_EDITABLE
- (priv->d_entry), 0, c);
- priv->valid_value = FALSE;
- }
- }
-
- /* month entry was edited */
- else if (widget == priv->m_entry) {
- gint l =
- gtk_entry_get_max_length(GTK_ENTRY(priv->m_entry));
- gint c;
-
- /* set month to 1 */
- if (m < 1) {
- gchar info[256];
-
- m = 1;
- g_snprintf(info,256, "Minimum value is 1");
- gtk_infoprint(NULL, info);
-
- sprintf(new_val, "%02d", m);
- gtk_entry_set_text(GTK_ENTRY(priv->m_entry),
- new_val);
- c = g_utf8_strlen(gtk_entry_get_text
- (GTK_ENTRY(priv->m_entry)), l);
- gtk_widget_grab_focus (priv->m_entry);
- gtk_editable_select_region(GTK_EDITABLE
- (priv->m_entry), 0, c);
- priv->valid_value = FALSE;
- }
- /* set month to 12 */
- else if (m > 12) {
- gchar info[256];
-
- m = 12;
- g_snprintf(info, 256, "Maximum value is %d", m);
- gtk_infoprint(NULL, info);
- sprintf(new_val, "%02d", m);
- gtk_entry_set_text(GTK_ENTRY(priv->m_entry),
- new_val);
- c = g_utf8_strlen(gtk_entry_get_text
- (GTK_ENTRY(priv->m_entry)), l);
- gtk_widget_grab_focus (priv->m_entry);
- gtk_editable_select_region(GTK_EDITABLE
- (priv->m_entry), 0, c);
- priv->valid_value = FALSE;
- }
- else if (d > g_date_get_days_in_month(m,y)) {
- gchar info[256];
-
- d = g_date_get_days_in_month(m, y);
- g_snprintf(info,256, "Maximum value is %d", d);
- gtk_infoprint(NULL, info);
-
- sprintf(new_val, "%02d", d);
- gtk_entry_set_text(GTK_ENTRY(priv->d_entry),
- new_val);
- c = g_utf8_strlen(gtk_entry_get_text
- (GTK_ENTRY(priv->d_entry)), l);
- gtk_widget_grab_focus (priv->d_entry);
- gtk_editable_select_region(GTK_EDITABLE
- (priv->d_entry), 0, c);
- priv->valid_value = FALSE;
- }
- }
- }
+ /*check if the calling entry is empty*/
+ if(gtk_entry_get_text(GTK_ENTRY(widget)) == NULL ||
+ *(gtk_entry_get_text(GTK_ENTRY(widget))) == '\0')
+ {
+ if(widget == priv->d_entry)
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ EMPTY_DAY, &r);
+ else if(widget == priv->m_entry)
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ EMPTY_MONTH, &r);
+ else
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ EMPTY_YEAR, &r);
+
+ return FALSE;
}
- priv->day = d;
- priv->month = m;
- priv->year = y;
-
- /* if month entry has only one character, prepend it with 0 */
- if (g_utf8_strlen(gtk_entry_get_text(GTK_ENTRY(priv->m_entry)), -1) ==
- 1) {
- sprintf(new_val, "%02d", m);
- gtk_entry_set_text(GTK_ENTRY(priv->m_entry), new_val);
+ /*date validation starts*/
+ d = atoi(gtk_entry_get_text(GTK_ENTRY(priv->d_entry)));
+ m = atoi(gtk_entry_get_text(GTK_ENTRY(priv->m_entry)));
+ y = atoi(gtk_entry_get_text(GTK_ENTRY(priv->y_entry)));
+
+ /*the only reason why a date is not valid is because that
+ * some months dont have 31st 30th or even 29th(since we
+ * have done max and min range checking for each field), for
+ * now we will only fix day field, if trying to fix day
+ * field fails to make the date valid, we will set the
+ * date to be current date, if any value is 0, that means
+ * this entry is empty, therefore skip validation*/
+
+ if(d != 0 && m != 0 && y != 0 && !g_date_valid_dmy(d, m, y))
+ {
+ gint new_d;
+ gint max_d;
+ gchar day_str[3];
+
+ g_signal_emit(ed, date_editor_signals[DATE_ERROR], 0,
+ INVALID_DATE, &r);
+
+ max_d = g_date_get_days_in_month(m,y);
+
+ if(priv->d_orig <= max_d && priv->d_orig > 0)
+ new_d = priv->d_orig;
+ else
+ new_d = priv->d_orig = max_d;
+
+ if(g_date_valid_dmy(new_d, m, y))
+ {
+ d = priv->day = new_d;
+ sprintf(day_str, "%02d", new_d);
+ gtk_entry_set_text(GTK_ENTRY(priv->d_entry), day_str);
+ }
+ else
+ {
+ g_date_clear(&gd, 1);
+ g_date_set_time(&gd, time(NULL));
+ d = g_date_get_year(&gd);
+ m = g_date_get_month(&gd);
+ y = g_date_get_day(&gd);
+ }
+
+ gtk_widget_grab_focus(priv->d_entry);
+ g_idle_add((GSourceFunc)
+ _hildon_date_editor_entry_select_all, priv->d_entry);
}
+ /*make sure to have 0 in front single digits*/
+ hildon_date_editor_set_date(ed, (guint) y, (guint) m, (guint) d);
+ return FALSE;
+}
- /* if day entry has only one character, prepend it with 0 */
- if (g_utf8_strlen(gtk_entry_get_text(GTK_ENTRY(priv->d_entry)), -1) ==
- 1) {
- sprintf(new_val, "%02d", d);
- gtk_entry_set_text(GTK_ENTRY(priv->d_entry), new_val);
+static gboolean
+hildon_date_editor_date_error(HildonDateEditor *editor,
+ HildonDateEditorErrorType type)
+{
+ switch(type)
+ {
+ case MAX_DAY:
+ gtk_infoprintf(NULL, _("Ckct_ib_maximum_value"), 31);
+ break;
+ case MAX_MONTH:
+ gtk_infoprintf(NULL, _("Ckct_ib_maximum_value"), 12);
+ break;
+ case MAX_YEAR:
+ gtk_infoprintf(NULL, _("Ckct_ib_maximum_value"), 2100);
+ break;
+ case MIN_DAY:
+ case MIN_MONTH:
+ case MIN_YEAR:
+ gtk_infoprintf(NULL, _("Ckct_ib_minimum_value"), 1);
+ break;
+ case EMPTY_DAY:
+ gtk_infoprintf(NULL, _("Ckct_ib_set_a_value_within_range"), 1, 31);
+ break;
+ case EMPTY_MONTH:
+ gtk_infoprintf(NULL, _("Ckct_ib_set_a_value_within_range"), 1, 12);
+ break;
+ case EMPTY_YEAR:
+ gtk_infoprintf(NULL, _("Ckct_ib_set_a_value_within_range"), 1, 2100);
+ break;
+ case INVALID_DATE:
+ gtk_infoprint(NULL, _("Ckct_ib_date_does_not_exist"));
+ break;
+ default:
+ /*default error message ?*/
+ break;
}
-
- return FALSE;
+ return TRUE;
}
static void hildon_date_editor_size_request(GtkWidget * widget,
gtk_widget_size_request(priv->d_event_box_image, &img_req);
/* calculate our size */
- requisition->width = f_req.width + img_req.width +
- widget->style->xthickness * 2;
+ requisition->width = f_req.width + img_req.width + BUTTON_SPACING;
requisition->height = DATE_EDITOR_HEIGHT;
}
widget->allocation = *allocation;
- gtk_widget_size_request(widget, &max_req);
+ gtk_widget_get_child_requisition(widget, &max_req);
- if (allocation->height > max_req.height)
- f_alloc.y = img_alloc.y = allocation->y +
- (allocation->height - max_req.height) / 2;
- else
- f_alloc.y = img_alloc.y = allocation->y;
+ f_alloc.y = img_alloc.y = allocation->y +
+ MAX(allocation->height - max_req.height, 0) / 2;
- if (allocation->width > max_req.width)
- f_alloc.x = img_alloc.x = allocation->x +
- (allocation->width - max_req.width) / 2;
- else
- f_alloc.x = img_alloc.x = allocation->x;
+ f_alloc.x = img_alloc.x = allocation->x +
+ MAX(allocation->width - max_req.width, 0) / 2;
/* allocate frame */
if (priv->frame)
gtk_widget_get_child_requisition(priv->d_event_box_image,
&req);
- img_alloc.x += f_alloc.width;
+ img_alloc.x += f_alloc.width + BUTTON_SPACING;
img_alloc.width = req.width;
img_alloc.height = max_req.height;
gtk_widget_size_allocate(priv->d_event_box_image, &img_alloc);
}
-/* -1 just to make it look nice -- Hildon --
- * Same y -value for the label, just does not look good enough.
- */
- priv->my_delim->allocation.y =
- priv->dm_delim->allocation.y = f_alloc.y - 1;
+ priv->dm_delim->allocation.height = max_req.height;
+ priv->my_delim->allocation.height = max_req.height;
+ priv->my_delim->allocation.y = priv->d_entry->allocation.y-5;
+ priv->dm_delim->allocation.y = priv->d_entry->allocation.y-5;
gtk_widget_size_allocate(priv->dm_delim, &priv->dm_delim->allocation);
gtk_widget_size_allocate(priv->my_delim, &priv->my_delim->allocation);
}
return digit_width;
}
+
+/**
+ * hildon_date_editor_set_year:
+ * @editor: the @HildonDateEditor widget
+ * @year: year
+ *
+ * This function sets the year shown in the editor.
+ *
+ * Return: Returns TRUE if the year is valid.
+ **/
+gboolean hildon_date_editor_set_year(HildonDateEditor *editor, guint year)
+{
+ HildonDateEditorPrivate *priv;
+ g_return_val_if_fail( HILDON_IS_DATE_EDITOR(editor), FALSE );
+ priv = HILDON_DATE_EDITOR_GET_PRIVATE(editor);
+
+ if (g_date_valid_dmy(priv->day, priv->month, year))
+ {
+ gchar str[MAX_DATE_LEN + 1];
+ priv->year = year;
+
+ sprintf(str, "%04d", year);
+ gtk_entry_set_text(GTK_ENTRY(priv->y_entry), str);
+
+ g_object_notify(G_OBJECT(editor), "year");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/**
+ * hildon_date_editor_set_month:
+ * @editor: the @HildonDateEditor widget
+ * @month: month
+ *
+ * This function sets the month shown in the editor.
+ *
+ * Return: Returns TRUE if the month is valid.
+ **/
+gboolean hildon_date_editor_set_month(HildonDateEditor *editor, guint month)
+{
+ HildonDateEditorPrivate *priv;
+ g_return_val_if_fail( HILDON_IS_DATE_EDITOR(editor), FALSE );
+ priv = HILDON_DATE_EDITOR_GET_PRIVATE(editor);
+
+ if (g_date_valid_dmy(priv->day, month, priv->year))
+ {
+ GDate date;
+ gchar str[MAX_DATE_LEN + 1];
+ priv->month = month;
+ g_date_set_dmy(&date, priv->day, month, priv->year);
+
+ g_date_strftime(str, MAX_DATE_LEN, "%m", &date);
+ gtk_entry_set_text(GTK_ENTRY(priv->m_entry), str);
+
+ g_object_notify(G_OBJECT(editor), "month");
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/**
+ * hildon_date_editor_set_day:
+ * @editor: the @HildonDateEditor widget
+ * @day: day
+ *
+ * This function sets the day shown in the editor.
+ *
+ * Return: Returns TRUE if the day is valid.
+ **/
+gboolean hildon_date_editor_set_day(HildonDateEditor *editor, guint day)
+{
+ HildonDateEditorPrivate *priv;
+
+ g_return_val_if_fail( HILDON_IS_DATE_EDITOR(editor), FALSE );
+ priv = HILDON_DATE_EDITOR_GET_PRIVATE(editor);
+
+ if (g_date_valid_dmy(day, priv->month, priv->year))
+ {
+ GDate date;
+ gchar str[MAX_DATE_LEN + 1];
+ priv->day = day;
+ g_date_set_dmy(&date, day, priv->month, priv->year);
+
+ g_date_strftime(str, MAX_DATE_LEN, "%d", &date);
+ gtk_entry_set_text(GTK_ENTRY(priv->d_entry), str);
+
+ g_object_notify(G_OBJECT(editor), "day");
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/**
+ * hildon_date_editor_get_year:
+ * @editor: the @HildonDateEditor widget
+ *
+ * This function gets the year shown in the editor.
+ *
+ * Return: Returns the current year shown in the editor.
+ **/
+guint hildon_date_editor_get_year(HildonDateEditor *editor)
+{
+ HildonDateEditorPrivate *priv;
+ g_return_val_if_fail( HILDON_IS_DATE_EDITOR(editor), 0 );
+ priv = HILDON_DATE_EDITOR_GET_PRIVATE(editor);
+ /*change to have the content in the entry*/
+ return (guint) atoi(gtk_entry_get_text(GTK_ENTRY(priv->y_entry)));
+}
+
+/**
+ * hildon_date_editor_get_month:
+ * @editor: the @HildonDateEditor widget
+ *
+ * This function gets the month shown in the editor.
+ *
+ * Return: Returns the current month shown in the editor.
+ **/
+
+guint hildon_date_editor_get_month(HildonDateEditor *editor)
+{
+ HildonDateEditorPrivate *priv;
+ g_return_val_if_fail( HILDON_IS_DATE_EDITOR(editor), 0 );
+ priv = HILDON_DATE_EDITOR_GET_PRIVATE(editor);
+ return (guint) atoi(gtk_entry_get_text(GTK_ENTRY(priv->m_entry)));
+}
+
+/**
+ * hildon_date_editor_get_day:
+ * @editor: the @HildonDateEditor widget
+ *
+ * This function gets the day shown in the editor.
+ *
+ * Return: Returns the current day shown in the editor.
+ **/
+
+guint hildon_date_editor_get_day(HildonDateEditor *editor)
+{
+ HildonDateEditorPrivate *priv;
+ g_return_val_if_fail( HILDON_IS_DATE_EDITOR(editor), 0 );
+ priv = HILDON_DATE_EDITOR_GET_PRIVATE(editor);
+ return (guint) atoi(gtk_entry_get_text(GTK_ENTRY(priv->d_entry)));
+}
+
+static gboolean
+_hildon_date_editor_entry_select_all (GtkWidget *widget)
+{
+ gtk_editable_select_region(GTK_EDITABLE(widget), 0, -1);
+ return FALSE;
+}