From: Michael Dominic Kostrzewa Date: Wed, 3 Jan 2007 21:55:04 +0000 (+0000) Subject: Removing hildon-private.h. Cleaning up the time editor. X-Git-Tag: 2.1.66-1~1020 X-Git-Url: https://vcs.maemo.org/git/?a=commitdiff_plain;h=f02264990c6c09ed32dac9ff36f75e8c12f28046;p=hildon Removing hildon-private.h. Cleaning up the time editor. --- diff --git a/ChangeLog b/ChangeLog index 8fff6df..ccc75a6 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,16 @@ 2007-01-03 Michael Dominic Kostrzewa + * src/hildon-private.h: Removing. It was only holding one private + function which is now public (makes sense). + + * src/hildon-time-editor-private.h: + * src/hildon-time-editor.c: + * src/hildon-time-editor.h: + * src/hildon-time-picker.c: + * src/hildon-widgets.h: Cleaning up the time editor. + +2007-01-03 Michael Dominic Kostrzewa + * src/hildon-color-chooser-dialog.c: * src/hildon-color-chooser-dialog.h: * src/hildon-color-chooser.c: diff --git a/src/hildon-private.h b/src/hildon-private.h deleted file mode 100644 index 3d5da58..0000000 --- a/src/hildon-private.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * This file is part of hildon-libs - * - * Copyright (C) 2006 Nokia Corporation, all rights reserved. - * - * Contact: Michael Dominic Kostrzewa - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; version 2.1 of - * the License. - * - * This library is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA - * 02110-1301 USA - * - */ - - -#ifndef __HILDON_PRIVATE_H__ -#define __HILDON_PRIVATE_H__ - -#include - -G_BEGIN_DECLS - -void -_hildon_time_editor_get_time_separators(GtkLabel *hm_sep_label, - GtkLabel *ms_sep_label); - -G_END_DECLS -#endif /* __HILDON_PRIVATE_H__ */ diff --git a/src/hildon-time-editor-private.h b/src/hildon-time-editor-private.h new file mode 100644 index 0000000..fca2daf --- /dev/null +++ b/src/hildon-time-editor-private.h @@ -0,0 +1,85 @@ +/* + * This file is part of hildon-libs + * + * Copyright (C) 2005, 2006 Nokia Corporation, all rights reserved. + * + * Contact: Michael Dominic Kostrzewa + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; version 2.1 of + * the License. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifndef __HILDON_TIME_EDITOR_PRIVATE_H__ +#define __HILDON_TIME_EDITOR_PRIVATE_H__ + +#include + +G_BEGIN_DECLS + +#define HILDON_TIME_EDITOR_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\ + HILDON_TYPE_TIME_EDITOR, HildonTimeEditorPrivate)); + +/* Indices for h/m/s entries in priv->entries */ +enum { + ENTRY_HOURS, + ENTRY_MINS, + ENTRY_SECS, + + ENTRY_COUNT +}; + +typedef struct _HildonTimeEditorPrivate HildonTimeEditorPrivate; + +struct _HildonTimeEditorPrivate +{ + guint ticks; /* Current duration in seconds */ + + gchar *am_symbol; + gchar *pm_symbol; + + GtkWidget *iconbutton; /* button for icon */ + + GtkWidget *frame; /* frame around the entries */ + GtkWidget *entries[ENTRY_COUNT]; /* h, m, s entries */ + GtkWidget *hm_label; /* between hour and minute */ + GtkWidget *sec_label; /* between minute and second */ + GtkWidget *ampm_label; /* label for showing am or pm */ + + GtkWidget *error_widget; /* field to highlight in idle */ + GtkWidget *ampm_button; /* am/pm change button */ + + + gboolean duration_mode; /* In HildonDurationEditor mode */ + gboolean show_seconds; /* show seconds */ + gboolean show_hours; /* show hours */ + + gboolean ampm_pos_after; /* is am/pm shown after others */ + gboolean clock_24h; /* whether to show a 24h clock */ + gboolean am; /* TRUE == am, FALSE == pm */ + + guint duration_min; /* duration editor ranges */ + guint duration_max; /* duration editor ranges */ + + guint highlight_idle; + gboolean skipper; /* FIXME (MDK): To prevent us from looping inside the validation events. + When set to TRUE further validations (that can happen from-inside other + validations) are being skipped. Nasty hack to cope with a bad design. */ +}; + +G_END_DECLS + +#endif /* __HILDON_TIME_EDITOR_H__ */ diff --git a/src/hildon-time-editor.c b/src/hildon-time-editor.c index ab3758d..fd00872 100644 --- a/src/hildon-time-editor.c +++ b/src/hildon-time-editor.c @@ -35,236 +35,228 @@ * popups a #HildonTimePicker dialog. */ -#include -#include "hildon-time-editor.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "hildon-defines.h" -#include "hildon-time-picker.h" -#include "hildon-banner.h" -#include "hildon-input-mode-hint.h" -#include "hildon-private.h" -#include "hildon-composite-widget.h" -#include "hildon-marshalers.h" -#include "hildon-enum-types.h" - -#define _(String) dgettext(PACKAGE, String) - -#define HILDON_TIME_EDITOR_GET_PRIVATE(obj) \ - (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \ - HILDON_TYPE_TIME_EDITOR, HildonTimeEditorPrivate)); - -#define TICKS(h,m,s) ((h) * 3600 + (m) * 60 + (s)) - -#define TIME_EDITOR_HEIGHT 30 -#define ICON_PRESSED 4 -#define ICON_NAME "qgn_widg_timedit" -#define ICON_SIZE "timepicker-size" -#define MIN_DURATION 0 -#define MAX_DURATION TICKS(99, 59, 59) +#ifdef HAVE_CONFIG_H +#include +#endif -/* Default values for properties */ -#define HILDON_TIME_EDITOR_TICKS_VALUE 0 -#define HILDON_TIME_EDITOR_DURATION_MODE FALSE -#define HILDON_TIME_EDITOR_DURATION_LOWER_VALUE 0 -#define HILDON_TIME_EDITOR_DURATION_UPPER_VALUE TICKS(99, 59, 59) +#include "hildon-time-editor.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "hildon-defines.h" +#include "hildon-time-picker.h" +#include "hildon-banner.h" +#include "hildon-input-mode-hint.h" +#include "hildon-composite-widget.h" +#include "hildon-marshalers.h" +#include "hildon-enum-types.h" +#include "hildon-time-editor-private.h" -#define HOURS_MAX_24 23 -#define HOURS_MAX_12 12 -#define HOURS_MIN_24 0 -#define HOURS_MIN_12 1 -#define MINUTES_MAX 59 -#define SECONDS_MAX 59 -#define MINUTES_MIN 0 -#define SECONDS_MIN 0 +#define _(String) dgettext(PACKAGE, String) -static GtkContainerClass *parent_class; +#define TICKS(h,m,s) \ + ((h) * 3600 + (m) * 60 + (s)) -typedef struct _HildonTimeEditorPrivate HildonTimeEditorPrivate; +#define TIME_EDITOR_HEIGHT 30 -enum -{ - PROP_TICKS = 1, - PROP_DURATION_MODE, - PROP_DURATION_MIN, - PROP_DURATION_MAX, - PROP_SHOW_SECONDS, - PROP_SHOW_HOURS -}; +#define ICON_PRESSED 4 -/* Indices for h/m/s entries in priv->entries */ -enum { - ENTRY_HOURS, - ENTRY_MINS, - ENTRY_SECS, +#define ICON_NAME "qgn_widg_timedit" - ENTRY_COUNT -}; +#define ICON_SIZE "timepicker-size" -/* Signals */ -enum { - TIME_ERROR, - LAST_SIGNAL -}; +#define MIN_DURATION 0 -/* Error codes categories */ -enum { - MAX_VALUE, - MIN_VALUE, - WITHIN_RANGE, - NUM_ERROR_CODES -}; +#define MAX_DURATION TICKS(99, 59, 59) + +/* Default values for properties */ -static guint time_editor_signals[LAST_SIGNAL] = { 0 }; -static guint hour_errors[NUM_ERROR_CODES] = { HILDON_DATE_TIME_ERROR_MAX_HOURS, HILDON_DATE_TIME_ERROR_MIN_HOURS, HILDON_DATE_TIME_ERROR_EMPTY_HOURS }; -static guint min_errors[NUM_ERROR_CODES] = { HILDON_DATE_TIME_ERROR_MAX_MINS, HILDON_DATE_TIME_ERROR_MIN_MINS, HILDON_DATE_TIME_ERROR_EMPTY_MINS }; -static guint sec_errors[NUM_ERROR_CODES] = { HILDON_DATE_TIME_ERROR_MAX_SECS, HILDON_DATE_TIME_ERROR_MIN_SECS, HILDON_DATE_TIME_ERROR_EMPTY_SECS }; +#define HILDON_TIME_EDITOR_TICKS_VALUE 0 -struct _HildonTimeEditorPrivate { - guint ticks; /* Current duration in seconds */ +#define HILDON_TIME_EDITOR_DURATION_MODE FALSE - gchar *am_symbol; - gchar *pm_symbol; +#define HILDON_TIME_EDITOR_DURATION_LOWER_VALUE 0 - GtkWidget *iconbutton; /* button for icon */ +#define HILDON_TIME_EDITOR_DURATION_UPPER_VALUE TICKS(99, 59, 59) - GtkWidget *frame; /* frame around the entries */ - GtkWidget *entries[ENTRY_COUNT]; /* h, m, s entries */ - GtkWidget *hm_label; /* between hour and minute */ - GtkWidget *sec_label; /* between minute and second */ - GtkWidget *ampm_label; /* label for showing am or pm */ +#define HOURS_MAX_24 23 - GtkWidget *error_widget; /* field to highlight in idle */ - GtkWidget *ampm_button; /* am/pm change button */ +#define HOURS_MAX_12 12 +#define HOURS_MIN_24 0 - gboolean duration_mode; /* In HildonDurationEditor mode */ - gboolean show_seconds; /* show seconds */ - gboolean show_hours; /* show hours */ +#define HOURS_MIN_12 1 - gboolean ampm_pos_after; /* is am/pm shown after others */ - gboolean clock_24h; /* whether to show a 24h clock */ - gboolean am; /* TRUE == am, FALSE == pm */ +#define MINUTES_MAX 59 - guint duration_min; /* duration editor ranges */ - guint duration_max; /* duration editor ranges */ +#define SECONDS_MAX 59 - guint highlight_idle; - gboolean skipper; /* FIXME (MDK): To prevent us from looping inside the validation events. - When set to TRUE further validations (that can happen from-inside other validations) - are being skipped. Nasty hack to cope with a bad design. */ +#define MINUTES_MIN 0 + +#define SECONDS_MIN 0 + +static GtkContainerClass* parent_class; + +enum +{ + PROP_0, + PROP_TICKS, + PROP_DURATION_MODE, + PROP_DURATION_MIN, + PROP_DURATION_MAX, + PROP_SHOW_SECONDS, + PROP_SHOW_HOURS }; -/*** - * Widget functions - */ +/* Signals */ +enum { + TIME_ERROR, + LAST_SIGNAL +}; -static void hildon_time_editor_class_init (HildonTimeEditorClass *editor_class); -static void hildon_time_editor_init (HildonTimeEditor *editor); +/* Error codes categories */ +enum { + MAX_VALUE, + MIN_VALUE, + WITHIN_RANGE, + NUM_ERROR_CODES +}; -static void hildon_time_editor_finalize (GObject *obj_self); +static guint time_editor_signals[LAST_SIGNAL] = { 0 }; -static void hildon_time_editor_set_property(GObject *object, - guint param_id, - const GValue *value, - GParamSpec *pspec); +static guint hour_errors[NUM_ERROR_CODES] = { + HILDON_DATE_TIME_ERROR_MAX_HOURS, + HILDON_DATE_TIME_ERROR_MIN_HOURS, + HILDON_DATE_TIME_ERROR_EMPTY_HOURS }; -static void hildon_time_editor_get_property(GObject *object, - guint param_id, - GValue *value, - GParamSpec *pspec); +static guint min_errors[NUM_ERROR_CODES] = { + HILDON_DATE_TIME_ERROR_MAX_MINS, + HILDON_DATE_TIME_ERROR_MIN_MINS, + HILDON_DATE_TIME_ERROR_EMPTY_MINS }; -static void hildon_time_editor_forall(GtkContainer *container, - gboolean include_internals, - GtkCallback callback, - gpointer callback_data); - -static void hildon_time_editor_destroy(GtkObject * self); +static guint sec_errors[NUM_ERROR_CODES] = { + HILDON_DATE_TIME_ERROR_MAX_SECS, + HILDON_DATE_TIME_ERROR_MIN_SECS, + HILDON_DATE_TIME_ERROR_EMPTY_SECS }; -/*** - * Signal handlers - */ +static void +hildon_time_editor_class_init (HildonTimeEditorClass *editor_class); + +static void +hildon_time_editor_init (HildonTimeEditor *editor); -static gboolean hildon_time_editor_entry_focusout(GtkWidget *widget, - GdkEventFocus *event, - gpointer data); +static void +hildon_time_editor_finalize (GObject *obj_self); + +static void +hildon_time_editor_set_property (GObject *object, + guint param_id, + const GValue *value, + GParamSpec *pspec); -static gboolean hildon_time_editor_entry_focusin(GtkWidget *widget, - GdkEventFocus *event, - gpointer data); +static void +hildon_time_editor_get_property (GObject *object, + guint param_id, + GValue *value, + GParamSpec *pspec); -static gboolean hildon_time_editor_time_error(HildonTimeEditor *editor, - HildonDateTimeEditorError type); +static void +hildon_time_editor_forall (GtkContainer *container, + gboolean include_internals, + GtkCallback callback, + gpointer callback_data); + +static void +hildon_time_editor_destroy (GtkObject *self); -static gboolean hildon_time_editor_ampm_clicked(GtkWidget *widget, - gpointer data); +static gboolean +hildon_time_editor_entry_focus_out (GtkWidget *widget, + GdkEventFocus *event, + gpointer data); -static gboolean hildon_time_editor_icon_clicked(GtkWidget *widget, - gpointer data); +static gboolean +hildon_time_editor_entry_focus_in (GtkWidget *widget, + GdkEventFocus *event, + gpointer data); -static void hildon_time_editor_size_request(GtkWidget *widget, - GtkRequisition *requisition); +static gboolean +hildon_time_editor_time_error (HildonTimeEditor *editor, + HildonDateTimeEditorError type); -static void hildon_time_editor_size_allocate(GtkWidget *widget, - GtkAllocation *allocation); +static gboolean +hildon_time_editor_ampm_clicked (GtkWidget *widget, + gpointer data); -static gboolean hildon_time_editor_entry_keypress(GtkWidget *widget, - GdkEventKey *event, - gpointer data); +static gboolean +hildon_time_editor_icon_clicked (GtkWidget *widget, + gpointer data); -/*** - * Internal functions - */ +static void +hildon_time_editor_size_request (GtkWidget *widget, + GtkRequisition *requisition); -static gboolean hildon_time_editor_check_locale(HildonTimeEditor * editor); +static void +hildon_time_editor_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); -static -void hildon_time_editor_tap_and_hold_setup(GtkWidget * widget, - GtkWidget * menu, - GtkCallback func, - GtkWidgetTapAndHoldFlags flags); +static gboolean +hildon_time_editor_entry_keypress (GtkWidget *widget, + GdkEventKey *event, + gpointer data); + +static gboolean +hildon_time_editor_check_locale (HildonTimeEditor *editor); + +static void +hildon_time_editor_tap_and_hold_setup (GtkWidget *widget, + GtkWidget *menu, + GtkCallback func, + GtkWidgetTapAndHoldFlags flags); static void -hildon_time_editor_validate (HildonTimeEditor *editor, gboolean allow_intermediate); +hildon_time_editor_validate (HildonTimeEditor *editor, + gboolean allow_intermediate); -static void hildon_time_editor_set_to_current_time (HildonTimeEditor * editor); +static void +hildon_time_editor_set_to_current_time (HildonTimeEditor *editor); static gboolean -_hildon_time_editor_entry_select_all(GtkWidget *widget); +hildon_time_editor_entry_select_all (GtkWidget *widget); +static void +convert_to_12h (guint *h, + gboolean *am); -/*** - * Utility functions - */ - -static void convert_to_12h (guint *h, gboolean *am); -static void convert_to_24h (guint *h, gboolean am); +static void +convert_to_24h (guint *h, + gboolean am); -static void ticks_to_time (guint ticks, - guint *hours, - guint *minutes, - guint *seconds); +static void +ticks_to_time (guint ticks, + guint *hours, + guint *minutes, + guint *seconds); static void -hildon_time_editor_inserted_text (GtkEditable * editable, - gchar * new_text, - gint new_text_length, - gint * position, - gpointer user_data); - -GType hildon_time_editor_get_type(void) +hildon_time_editor_inserted_text (GtkEditable *editable, + gchar *new_text, + gint new_text_length, + gint *position, + gpointer user_data); + +GType G_GNUC_CONST +hildon_time_editor_get_type (void) { static GType editor_type = 0; - if (!editor_type) { + if (! editor_type) { static const GTypeInfo editor_info = { sizeof(HildonTimeEditorClass), NULL, /* base_init */ @@ -276,28 +268,30 @@ GType hildon_time_editor_get_type(void) 0, /* n_preallocs */ (GInstanceInitFunc) hildon_time_editor_init, }; - editor_type = g_type_register_static(GTK_TYPE_CONTAINER, - "HildonTimeEditor", - &editor_info, 0); + editor_type = g_type_register_static (GTK_TYPE_CONTAINER, + "HildonTimeEditor", + &editor_info, 0); } + return editor_type; } -static void hildon_time_editor_forall(GtkContainer * container, - gboolean include_internals, - GtkCallback callback, - gpointer callback_data) +static void +hildon_time_editor_forall (GtkContainer *container, + gboolean include_internals, + GtkCallback callback, + gpointer callback_data) { - HildonTimeEditor *editor; HildonTimeEditorPrivate *priv; - g_assert(HILDON_IS_TIME_EDITOR(container)); - g_assert(callback != NULL); + g_assert (HILDON_IS_TIME_EDITOR (container)); + g_assert (callback != NULL); - editor = HILDON_TIME_EDITOR(container); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (container); + + g_assert (priv); - if (!include_internals) + if (! include_internals) return; /* widget that are always shown */ @@ -305,176 +299,179 @@ static void hildon_time_editor_forall(GtkContainer * container, (*callback) (priv->frame, callback_data); } -static void hildon_time_editor_destroy(GtkObject * self) +static void +hildon_time_editor_destroy (GtkObject *self) { HildonTimeEditorPrivate *priv; - priv = HILDON_TIME_EDITOR_GET_PRIVATE(self); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (self); + g_assert (priv); if (priv->iconbutton) { - gtk_widget_unparent(priv->iconbutton); + gtk_widget_unparent (priv->iconbutton); priv->iconbutton = NULL; } if (priv->frame) { - gtk_widget_unparent(priv->frame); + gtk_widget_unparent (priv->frame); priv->frame = NULL; } - - if (GTK_OBJECT_CLASS(parent_class)->destroy) - GTK_OBJECT_CLASS(parent_class)->destroy(self); + if (GTK_OBJECT_CLASS (parent_class)->destroy) + GTK_OBJECT_CLASS (parent_class)->destroy (self); } static void -hildon_time_editor_class_init(HildonTimeEditorClass * editor_class) +hildon_time_editor_class_init (HildonTimeEditorClass *editor_class) { - GObjectClass *object_class = G_OBJECT_CLASS(editor_class); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(editor_class); - GtkContainerClass *container_class = GTK_CONTAINER_CLASS(editor_class); + GObjectClass *object_class = G_OBJECT_CLASS (editor_class); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (editor_class); + GtkContainerClass *container_class = GTK_CONTAINER_CLASS (editor_class); + + parent_class = g_type_class_peek_parent (editor_class); - parent_class = g_type_class_peek_parent(editor_class); + g_type_class_add_private (editor_class, sizeof (HildonTimeEditorPrivate)); - g_type_class_add_private(editor_class, - sizeof(HildonTimeEditorPrivate)); + object_class->get_property = hildon_time_editor_get_property; + object_class->set_property = hildon_time_editor_set_property; + widget_class->size_request = hildon_time_editor_size_request; + widget_class->size_allocate = hildon_time_editor_size_allocate; + widget_class->tap_and_hold_setup = hildon_time_editor_tap_and_hold_setup; + widget_class->focus = hildon_composite_widget_focus; - object_class->get_property = hildon_time_editor_get_property; - object_class->set_property = hildon_time_editor_set_property; - widget_class->size_request = hildon_time_editor_size_request; - widget_class->size_allocate = hildon_time_editor_size_allocate; - widget_class->tap_and_hold_setup = - hildon_time_editor_tap_and_hold_setup; - widget_class->focus = hildon_composite_widget_focus; + container_class->forall = hildon_time_editor_forall; + GTK_OBJECT_CLASS (editor_class)->destroy = hildon_time_editor_destroy; - container_class->forall = hildon_time_editor_forall; - GTK_OBJECT_CLASS(editor_class)->destroy = hildon_time_editor_destroy; + object_class->finalize = hildon_time_editor_finalize; - object_class->finalize = hildon_time_editor_finalize; + editor_class->time_error = hildon_time_editor_time_error; - editor_class->time_error = hildon_time_editor_time_error; - time_editor_signals[TIME_ERROR] = - g_signal_new("time-error", - G_OBJECT_CLASS_TYPE(object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET(HildonTimeEditorClass, time_error), - g_signal_accumulator_true_handled, NULL, - _hildon_marshal_BOOLEAN__ENUM, - G_TYPE_BOOLEAN, 1, HILDON_TYPE_DATE_TIME_EDITOR_ERROR); - - /** - * HildonTimeEditor:ticks: - * - * If editor is in duration mode, contains the duration seconds. - * If not, contains seconds since midnight. - */ - g_object_class_install_property( object_class, PROP_TICKS, - g_param_spec_uint("ticks", - "Duration value", - "Current value of duration", - 0, G_MAXUINT, - HILDON_TIME_EDITOR_TICKS_VALUE, - G_PARAM_READABLE | G_PARAM_WRITABLE) ); - - /** - * HildonTimeEditor:show_seconds: - * - * Controls whether seconds are shown in the editor - */ - g_object_class_install_property( object_class, PROP_SHOW_SECONDS, - g_param_spec_boolean("show_seconds", - "Show seconds property", - "Controls whether the seconds are shown in the editor", - FALSE, - G_PARAM_READABLE | G_PARAM_WRITABLE) ); - - /** - * HildonTimeEditor:show_hours: - * - * Controls whether hours are shown in the editor - */ - g_object_class_install_property( object_class, PROP_SHOW_HOURS, - g_param_spec_boolean("show_hours", - "Show hours field", - "Controls whether the hours field is shown in the editor", - TRUE, - G_PARAM_READABLE | G_PARAM_WRITABLE) ); - - /** - * HildonTimeEditor:duration_mode: - * - * Controls whether the TimeEditor is in duration mode - */ - g_object_class_install_property( object_class, PROP_DURATION_MODE, - g_param_spec_boolean("duration_mode", - "Duration mode", - "Controls whether the TimeEditor is in duration mode", - HILDON_TIME_EDITOR_DURATION_MODE, - G_PARAM_READABLE | G_PARAM_WRITABLE) ); - - /** - * HildonTimeEditor:duration_min: - * - * Minimum allowed duration value. - */ - g_object_class_install_property( object_class, PROP_DURATION_MIN, - g_param_spec_uint("duration_min", - "Minumum duration value", - "Smallest possible duration value", - MIN_DURATION, MAX_DURATION, - HILDON_TIME_EDITOR_DURATION_LOWER_VALUE, - G_PARAM_READABLE | G_PARAM_WRITABLE) ); - - /** - * HildonTimeEditor:duration_max: - * - * Maximum allowed duration value. - */ - g_object_class_install_property( object_class, PROP_DURATION_MAX, - g_param_spec_uint("duration_max", - "Maximum duration value", - "Largest possible duration value", - 0, G_MAXUINT, - HILDON_TIME_EDITOR_DURATION_UPPER_VALUE, - G_PARAM_READABLE | G_PARAM_WRITABLE) ); + g_signal_new ("time-error", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (HildonTimeEditorClass, time_error), + g_signal_accumulator_true_handled, NULL, + _hildon_marshal_BOOLEAN__ENUM, + G_TYPE_BOOLEAN, 1, HILDON_TYPE_DATE_TIME_EDITOR_ERROR); + + /** + * HildonTimeEditor:ticks: + * + * If editor is in duration mode, contains the duration seconds. + * If not, contains seconds since midnight. + */ + g_object_class_install_property (object_class, PROP_TICKS, + g_param_spec_uint ("ticks", + "Duration value", + "Current value of duration", + 0, G_MAXUINT, + HILDON_TIME_EDITOR_TICKS_VALUE, + G_PARAM_READABLE | G_PARAM_WRITABLE) ); + + /** + * HildonTimeEditor:show_seconds: + * + * Controls whether seconds are shown in the editor + */ + g_object_class_install_property (object_class, PROP_SHOW_SECONDS, + g_param_spec_boolean ("show_seconds", + "Show seconds property", + "Controls whether the seconds are shown in the editor", + FALSE, + G_PARAM_READABLE | G_PARAM_WRITABLE) ); + + /** + * HildonTimeEditor:show_hours: + * + * Controls whether hours are shown in the editor + */ + g_object_class_install_property (object_class, PROP_SHOW_HOURS, + g_param_spec_boolean ("show_hours", + "Show hours field", + "Controls whether the hours field is shown in the editor", + TRUE, + G_PARAM_READABLE | G_PARAM_WRITABLE) ); + + /** + * HildonTimeEditor:duration_mode: + * + * Controls whether the TimeEditor is in duration mode + */ + g_object_class_install_property (object_class, PROP_DURATION_MODE, + g_param_spec_boolean ("duration_mode", + "Duration mode", + "Controls whether the TimeEditor is in duration mode", + HILDON_TIME_EDITOR_DURATION_MODE, + G_PARAM_READABLE | G_PARAM_WRITABLE) ); + + /** + * HildonTimeEditor:duration_min: + * + * Minimum allowed duration value. + */ + g_object_class_install_property (object_class, PROP_DURATION_MIN, + g_param_spec_uint ("duration_min", + "Minumum duration value", + "Smallest possible duration value", + MIN_DURATION, MAX_DURATION, + HILDON_TIME_EDITOR_DURATION_LOWER_VALUE, + G_PARAM_READABLE | G_PARAM_WRITABLE) ); + + /** + * HildonTimeEditor:duration_max: + * + * Maximum allowed duration value. + */ + g_object_class_install_property (object_class, PROP_DURATION_MAX, + g_param_spec_uint ("duration_max", + "Maximum duration value", + "Largest possible duration value", + 0, G_MAXUINT, + HILDON_TIME_EDITOR_DURATION_UPPER_VALUE, + G_PARAM_READABLE | G_PARAM_WRITABLE) ); } -static -void hildon_time_editor_tap_and_hold_setup(GtkWidget * widget, - GtkWidget * menu, - GtkCallback func, - GtkWidgetTapAndHoldFlags flags) +static void +hildon_time_editor_tap_and_hold_setup (GtkWidget *widget, + GtkWidget *menu, + GtkCallback func, + GtkWidgetTapAndHoldFlags flags) { - HildonTimeEditorPrivate *priv = HILDON_TIME_EDITOR_GET_PRIVATE(widget); + HildonTimeEditorPrivate *priv = HILDON_TIME_EDITOR_GET_PRIVATE (widget); gint i; /* Forward this tap_and_hold_setup signal to all our child widgets */ for (i = 0; i < ENTRY_COUNT; i++) { - gtk_widget_tap_and_hold_setup(priv->entries[i], menu, func, - GTK_TAP_AND_HOLD_NO_SIGNALS); + gtk_widget_tap_and_hold_setup (priv->entries[i], menu, func, + GTK_TAP_AND_HOLD_NO_SIGNALS); } - gtk_widget_tap_and_hold_setup(priv->ampm_button, menu, func, - GTK_TAP_AND_HOLD_NO_SIGNALS); - gtk_widget_tap_and_hold_setup(priv->iconbutton, menu, func, - GTK_TAP_AND_HOLD_NONE); + gtk_widget_tap_and_hold_setup (priv->ampm_button, menu, func, + GTK_TAP_AND_HOLD_NO_SIGNALS); + gtk_widget_tap_and_hold_setup (priv->iconbutton, menu, func, + GTK_TAP_AND_HOLD_NONE); } -static void hildon_time_editor_entry_changed(GtkWidget *widget, gpointer data) +static void +hildon_time_editor_entry_changed (GtkWidget *widget, + gpointer data) { - g_assert(HILDON_IS_TIME_EDITOR(data)); - hildon_time_editor_validate(HILDON_TIME_EDITOR(data), TRUE); + g_assert (HILDON_IS_TIME_EDITOR (data)); + hildon_time_editor_validate (HILDON_TIME_EDITOR (data), TRUE); } -static void hildon_time_editor_init(HildonTimeEditor * editor) +static void +hildon_time_editor_init (HildonTimeEditor *editor) { HildonTimeEditorPrivate *priv; GtkWidget *hbox, *icon; gint i; - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); + + gtk_widget_push_composite_child (); - gtk_widget_push_composite_child(); - /* Setup defaults and create widgets */ priv->ticks = 0; priv->show_seconds = FALSE; @@ -490,200 +487,205 @@ static void hildon_time_editor_init(HildonTimeEditor * editor) priv->ampm_button = gtk_button_new(); priv->skipper = FALSE; - icon = gtk_image_new_from_icon_name(ICON_NAME, HILDON_ICON_SIZE_WIDG); - hbox = gtk_hbox_new(FALSE, 0); + icon = gtk_image_new_from_icon_name (ICON_NAME, HILDON_ICON_SIZE_WIDG); + hbox = gtk_hbox_new (FALSE, 0); - GTK_WIDGET_SET_FLAGS(editor, GTK_NO_WINDOW); - GTK_WIDGET_UNSET_FLAGS(priv->iconbutton, GTK_CAN_FOCUS | GTK_CAN_DEFAULT); - - gtk_container_set_border_width(GTK_CONTAINER(priv->frame), 0); + GTK_WIDGET_SET_FLAGS (editor, GTK_NO_WINDOW); + GTK_WIDGET_UNSET_FLAGS (priv->iconbutton, GTK_CAN_FOCUS | GTK_CAN_DEFAULT); - gtk_container_add(GTK_CONTAINER(priv->iconbutton), icon); - gtk_container_add(GTK_CONTAINER(priv->ampm_button), priv->ampm_label); - gtk_button_set_relief(GTK_BUTTON(priv->ampm_button), GTK_RELIEF_NONE); - gtk_button_set_focus_on_click(GTK_BUTTON(priv->ampm_button), FALSE); + gtk_container_set_border_width (GTK_CONTAINER(priv->frame), 0); + + gtk_container_add (GTK_CONTAINER (priv->iconbutton), icon); + gtk_container_add (GTK_CONTAINER (priv->ampm_button), priv->ampm_label); + gtk_button_set_relief(GTK_BUTTON (priv->ampm_button), GTK_RELIEF_NONE); + gtk_button_set_focus_on_click (GTK_BUTTON (priv->ampm_button), FALSE); /* Create hour, minute and second entries */ for (i = 0; i < ENTRY_COUNT; i++) { - priv->entries[i] = gtk_entry_new(); - - /* No frames for entries, so that they all appear to be inside one long entry */ - gtk_entry_set_has_frame(GTK_ENTRY(priv->entries[i]), FALSE); - - /* Set the entries to accept only numeric characters */ - g_object_set (priv->entries[i], "input-mode", - HILDON_INPUT_MODE_HINT_NUMERIC, NULL); - - /* The entry fields all take exactly two characters */ - gtk_entry_set_max_length (GTK_ENTRY(priv->entries[i]), 2); - gtk_entry_set_width_chars (GTK_ENTRY(priv->entries[i]), 2); - - g_signal_connect(priv->entries[i], "focus-in-event", - G_CALLBACK(hildon_time_editor_entry_focusin), editor); - g_signal_connect(priv->entries[i], "focus-out-event", - G_CALLBACK(hildon_time_editor_entry_focusout), editor); - g_signal_connect(priv->entries[i], "key-press-event", - G_CALLBACK(hildon_time_editor_entry_keypress), editor); - g_signal_connect(priv->entries[i], "changed", - G_CALLBACK(hildon_time_editor_entry_changed), editor); - - /* inserted signal sets time */ - g_signal_connect_after (G_OBJECT(priv->entries[i]), "insert_text", - G_CALLBACK (hildon_time_editor_inserted_text), - editor); + priv->entries[i] = gtk_entry_new (); + + /* No frames for entries, so that they all appear to be inside one long entry */ + gtk_entry_set_has_frame (GTK_ENTRY (priv->entries[i]), FALSE); + + /* Set the entries to accept only numeric characters */ + g_object_set (priv->entries[i], "input-mode", HILDON_INPUT_MODE_HINT_NUMERIC, NULL); + + /* The entry fields all take exactly two characters */ + gtk_entry_set_max_length (GTK_ENTRY (priv->entries[i]), 2); + gtk_entry_set_width_chars (GTK_ENTRY (priv->entries[i]), 2); + + g_signal_connect (priv->entries[i], "focus-in-event", + G_CALLBACK (hildon_time_editor_entry_focus_in), editor); + g_signal_connect (priv->entries[i], "focus-out-event", + G_CALLBACK (hildon_time_editor_entry_focus_out), editor); + g_signal_connect (priv->entries[i], "key-press-event", + G_CALLBACK (hildon_time_editor_entry_keypress), editor); + g_signal_connect (priv->entries[i], "changed", + G_CALLBACK (hildon_time_editor_entry_changed), editor); + + /* inserted signal sets time */ + g_signal_connect_after (G_OBJECT(priv->entries[i]), "insert_text", + G_CALLBACK (hildon_time_editor_inserted_text), + editor); } - + /* clicked signal for am/pm label */ - g_signal_connect(G_OBJECT(priv->ampm_button), "clicked", - G_CALLBACK(hildon_time_editor_ampm_clicked), editor); + g_signal_connect (G_OBJECT (priv->ampm_button), "clicked", + G_CALLBACK (hildon_time_editor_ampm_clicked), editor); /* clicked signal for icon */ - g_signal_connect(G_OBJECT(priv->iconbutton), "clicked", - G_CALLBACK(hildon_time_editor_icon_clicked), editor); + g_signal_connect (G_OBJECT (priv->iconbutton), "clicked", + G_CALLBACK (hildon_time_editor_icon_clicked), editor); /* Set ourself as the parent of all the widgets we created */ - gtk_widget_set_parent(priv->iconbutton, GTK_WIDGET(editor)); - gtk_box_pack_start(GTK_BOX(hbox), priv->entries[ENTRY_HOURS], FALSE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(hbox), priv->hm_label, FALSE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(hbox), priv->entries[ENTRY_MINS], FALSE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(hbox), priv->sec_label, FALSE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(hbox), priv->entries[ENTRY_SECS], FALSE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(hbox), priv->ampm_button, FALSE, FALSE, 0); - gtk_misc_set_padding(GTK_MISC(priv->ampm_label), 0, 0); + gtk_widget_set_parent (priv->iconbutton, GTK_WIDGET(editor)); + gtk_box_pack_start (GTK_BOX (hbox), priv->entries[ENTRY_HOURS], FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), priv->hm_label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), priv->entries[ENTRY_MINS], FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), priv->sec_label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), priv->entries[ENTRY_SECS], FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), priv->ampm_button, FALSE, FALSE, 0); + gtk_misc_set_padding (GTK_MISC (priv->ampm_label), 0, 0); - gtk_container_add(GTK_CONTAINER(priv->frame), hbox); + gtk_container_add (GTK_CONTAINER (priv->frame), hbox); /* Show created widgets */ - gtk_widget_set_parent(priv->frame, GTK_WIDGET(editor)); - gtk_widget_show_all(priv->frame); - gtk_widget_show_all(priv->iconbutton); + gtk_widget_set_parent (priv->frame, GTK_WIDGET(editor)); + gtk_widget_show_all (priv->frame); + gtk_widget_show_all (priv->iconbutton); /* Update AM/PM and time separators settings from locale */ - if (!hildon_time_editor_check_locale(editor)) { + if (! hildon_time_editor_check_locale (editor)) { /* Using 12h clock */ priv->clock_24h = FALSE; } else { - gtk_widget_hide(priv->ampm_button); + gtk_widget_hide (priv->ampm_button); } - - if (!priv->show_seconds) { - gtk_widget_hide(priv->sec_label); - gtk_widget_hide(priv->entries[ENTRY_SECS]); + + if (! priv->show_seconds) { + gtk_widget_hide (priv->sec_label); + gtk_widget_hide (priv->entries[ENTRY_SECS]); } /* set the default time to current time. */ hildon_time_editor_set_to_current_time (editor); - gtk_widget_pop_composite_child(); + gtk_widget_pop_composite_child (); } -static void hildon_time_editor_set_property (GObject *object, - guint param_id, - const GValue *value, - GParamSpec *pspec) +static void +hildon_time_editor_set_property (GObject *object, + guint param_id, + const GValue *value, + GParamSpec *pspec) { - HildonTimeEditor *time_editor = HILDON_TIME_EDITOR(object); - switch (param_id) - { - case PROP_TICKS: - hildon_time_editor_set_ticks (time_editor, g_value_get_uint(value)); - break; - - case PROP_SHOW_SECONDS: - hildon_time_editor_set_show_seconds (time_editor, g_value_get_boolean(value)); - break; - - case PROP_SHOW_HOURS: - hildon_time_editor_set_show_hours (time_editor, g_value_get_boolean(value)); - break; - - case PROP_DURATION_MODE: - hildon_time_editor_set_duration_mode (time_editor, g_value_get_boolean(value)); - break; - - case PROP_DURATION_MIN: - hildon_time_editor_set_duration_min (time_editor, g_value_get_uint(value)); - break; - - case PROP_DURATION_MAX: - hildon_time_editor_set_duration_max (time_editor, g_value_get_uint(value)); - break; - - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec); - break; - } + HildonTimeEditor *time_editor = HILDON_TIME_EDITOR (object); + + switch (param_id) + { + case PROP_TICKS: + hildon_time_editor_set_ticks (time_editor, g_value_get_uint(value)); + break; + + case PROP_SHOW_SECONDS: + hildon_time_editor_set_show_seconds (time_editor, g_value_get_boolean(value)); + break; + + case PROP_SHOW_HOURS: + hildon_time_editor_set_show_hours (time_editor, g_value_get_boolean(value)); + break; + + case PROP_DURATION_MODE: + hildon_time_editor_set_duration_mode (time_editor, g_value_get_boolean(value)); + break; + + case PROP_DURATION_MIN: + hildon_time_editor_set_duration_min (time_editor, g_value_get_uint(value)); + break; + + case PROP_DURATION_MAX: + hildon_time_editor_set_duration_max (time_editor, g_value_get_uint(value)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec); + break; + } } -static void hildon_time_editor_get_property (GObject *object, - guint param_id, - GValue *value, - GParamSpec *pspec) +static void +hildon_time_editor_get_property (GObject *object, + guint param_id, + GValue *value, + GParamSpec *pspec) { - HildonTimeEditor *time_editor = HILDON_TIME_EDITOR(object); - switch (param_id) - { - - case PROP_TICKS: - g_value_set_uint (value, hildon_time_editor_get_ticks (time_editor)); - break; - - case PROP_SHOW_SECONDS: - g_value_set_boolean (value, hildon_time_editor_get_show_seconds (time_editor)); - break; - - case PROP_SHOW_HOURS: - g_value_set_boolean (value, hildon_time_editor_get_show_hours (time_editor)); - break; - - case PROP_DURATION_MODE: - g_value_set_boolean (value, hildon_time_editor_get_duration_mode (time_editor)); - break; - - case PROP_DURATION_MIN: - g_value_set_uint (value, hildon_time_editor_get_duration_min (time_editor)); - break; - - case PROP_DURATION_MAX: - g_value_set_uint (value, hildon_time_editor_get_duration_max (time_editor)); - break; - - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec); - break; - } + HildonTimeEditor *time_editor = HILDON_TIME_EDITOR (object); + + switch (param_id) + { + + case PROP_TICKS: + g_value_set_uint (value, hildon_time_editor_get_ticks (time_editor)); + break; + + case PROP_SHOW_SECONDS: + g_value_set_boolean (value, hildon_time_editor_get_show_seconds (time_editor)); + break; + + case PROP_SHOW_HOURS: + g_value_set_boolean (value, hildon_time_editor_get_show_hours (time_editor)); + break; + + case PROP_DURATION_MODE: + g_value_set_boolean (value, hildon_time_editor_get_duration_mode (time_editor)); + break; + + case PROP_DURATION_MIN: + g_value_set_uint (value, hildon_time_editor_get_duration_min (time_editor)); + break; + + case PROP_DURATION_MAX: + g_value_set_uint (value, hildon_time_editor_get_duration_max (time_editor)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); + break; + } } -/** +/* * hildon_time_editor_new: * * This function creates a new time editor. * * Returns: pointer to a new #HildonTimeEditor widget */ - -GtkWidget *hildon_time_editor_new(void) +GtkWidget* +hildon_time_editor_new (void) { - return GTK_WIDGET(g_object_new(HILDON_TYPE_TIME_EDITOR, NULL)); + return GTK_WIDGET (g_object_new (HILDON_TYPE_TIME_EDITOR, NULL)); } -static void hildon_time_editor_finalize(GObject * obj_self) +static void +hildon_time_editor_finalize (GObject *obj_self) { - HildonTimeEditorPrivate *priv = HILDON_TIME_EDITOR_GET_PRIVATE(obj_self); + HildonTimeEditorPrivate *priv = HILDON_TIME_EDITOR_GET_PRIVATE (obj_self); + g_assert (priv); - g_free(priv->am_symbol); - g_free(priv->pm_symbol); + g_free (priv->am_symbol); + g_free (priv->pm_symbol); if (priv->highlight_idle) - g_source_remove(priv->highlight_idle); + g_source_remove (priv->highlight_idle); - if (G_OBJECT_CLASS(parent_class)->finalize) - G_OBJECT_CLASS(parent_class)->finalize(obj_self); + if (G_OBJECT_CLASS (parent_class)->finalize) + G_OBJECT_CLASS (parent_class)->finalize (obj_self); } /** - * _hildon_time_editor_get_time_separators: + * hildon_time_editor_get_time_separators: * @editor: the #HildonTimeEditor * @hm_sep_label: the label that will show the hour:minutes separator * @ms_sep_label: the label that will show the minutes:seconds separator @@ -694,8 +696,8 @@ static void hildon_time_editor_finalize(GObject * obj_self) * */ void -_hildon_time_editor_get_time_separators(GtkLabel *hm_sep_label, - GtkLabel *ms_sep_label) +hildon_time_editor_get_time_separators (GtkLabel *hm_sep_label, + GtkLabel *ms_sep_label) { gchar buffer[256]; gchar *separator; @@ -703,51 +705,51 @@ _hildon_time_editor_get_time_separators(GtkLabel *hm_sep_label, gchar *iter, *endp = NULL; /* Get localized time string */ - g_date_set_dmy(&locale_test_date, 1, 2, 1970); - (void) g_date_strftime(buffer, sizeof(buffer), "%X", &locale_test_date); + g_date_set_dmy (&locale_test_date, 1, 2, 1970); + (void) g_date_strftime (buffer, sizeof (buffer), "%X", &locale_test_date); if (hm_sep_label != NULL) - { + { /* Find h-m separator */ iter = buffer; - while (*iter && g_ascii_isdigit(*iter)) iter++; - + while (*iter && g_ascii_isdigit (*iter)) iter++; + /* Extract h-m separator*/ endp = iter; - while (*endp && !g_ascii_isdigit(*endp)) endp++; - separator = g_strndup(iter, endp - iter); - gtk_label_set_label(hm_sep_label, separator); - g_free(separator); - } + while (*endp && ! g_ascii_isdigit (*endp)) endp++; + separator = g_strndup (iter, endp - iter); + gtk_label_set_label (hm_sep_label, separator); + g_free (separator); + } if (ms_sep_label != NULL) - { + { /* Find m-s separator */ iter = endp; - while (*iter && g_ascii_isdigit(*iter)) iter++; - + while (*iter && g_ascii_isdigit (*iter)) iter++; + /* Extract m-s separator*/ endp = iter; - while (*endp && !g_ascii_isdigit(*endp)) endp++; - separator = g_strndup(iter, endp - iter); - gtk_label_set_label(ms_sep_label, separator); - g_free(separator); - } - + while (*endp && ! g_ascii_isdigit (*endp)) endp++; + separator = g_strndup (iter, endp - iter); + gtk_label_set_label (ms_sep_label, separator); + g_free (separator); + } } /* Convert ticks to H:M:S. Ticks = seconds since 00:00:00. */ -static void ticks_to_time (guint ticks, - guint *hours, - guint *minutes, - guint *seconds) +static void +ticks_to_time (guint ticks, + guint *hours, + guint *minutes, + guint *seconds) { - guint left; + guint left; - *hours = ticks / 3600; - left = ticks % 3600; - *minutes = left / 60; - *seconds = left % 60; + *hours = ticks / 3600; + left = ticks % 3600; + *minutes = left / 60; + *seconds = left % 60; } /** @@ -760,21 +762,23 @@ static void ticks_to_time (guint ticks, * to fix it. */ -void hildon_time_editor_set_ticks (HildonTimeEditor * editor, - guint ticks) +void +hildon_time_editor_set_ticks (HildonTimeEditor *editor, + guint ticks) { HildonTimeEditorPrivate *priv; guint i, h, m, s; gchar str[3]; - g_assert(HILDON_IS_TIME_EDITOR(editor)); + g_assert (HILDON_IS_TIME_EDITOR (editor)); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); /* Validate ticks. If it's too low or too high, set it to min/max value for the current mode. */ if (priv->duration_mode) - priv->ticks = CLAMP(ticks, priv->duration_min, priv->duration_max); + priv->ticks = CLAMP (ticks, priv->duration_min, priv->duration_max); else { /* Check that ticks value is valid. We only need to check that hours don't exceed 23. */ @@ -784,72 +788,70 @@ void hildon_time_editor_set_ticks (HildonTimeEditor * editor, priv->ticks = ticks; } - + /* Get the time in H:M:S. */ ticks_to_time (priv->ticks, &h, &m, &s); - - if (!priv->clock_24h && !priv->duration_mode) - { + + if (!priv->clock_24h && ! priv->duration_mode) + { /* Convert 24h H:M:S values to 12h mode, and update AM/PM state */ convert_to_12h (&h, &priv->am); - } + } /* Set H:M:S values to entries. We do not want to invoke validation callbacks (since they can cause new call to this function), so we block signals while setting values. */ for (i = 0; i < ENTRY_COUNT; i++) { - g_signal_handlers_block_by_func(priv->entries[i], - (gpointer) hildon_time_editor_entry_changed, editor); + g_signal_handlers_block_by_func(priv->entries[i], + (gpointer) hildon_time_editor_entry_changed, editor); - g_signal_handlers_block_by_func(priv->entries[i], - (gpointer) hildon_time_editor_inserted_text, editor); - - g_signal_handlers_block_by_func(priv->entries[i], - (gpointer) hildon_time_editor_entry_focusout, editor); + g_signal_handlers_block_by_func(priv->entries[i], + (gpointer) hildon_time_editor_inserted_text, editor); + g_signal_handlers_block_by_func(priv->entries[i], + (gpointer) hildon_time_editor_entry_focus_out, editor); } - g_snprintf(str, sizeof(str), "%02u", h); - gtk_entry_set_text(GTK_ENTRY(priv->entries[ENTRY_HOURS]), str); + g_snprintf (str, sizeof (str), "%02u", h); + gtk_entry_set_text (GTK_ENTRY (priv->entries[ENTRY_HOURS]), str); - g_snprintf(str, sizeof(str), "%02u", m); - gtk_entry_set_text(GTK_ENTRY(priv->entries[ENTRY_MINS]), str); + g_snprintf(str, sizeof (str), "%02u", m); + gtk_entry_set_text (GTK_ENTRY (priv->entries[ENTRY_MINS]), str); - g_snprintf(str, sizeof(str), "%02u", s); - gtk_entry_set_text(GTK_ENTRY(priv->entries[ENTRY_SECS]), str); + g_snprintf(str, sizeof (str), "%02u", s); + gtk_entry_set_text (GTK_ENTRY (priv->entries[ENTRY_SECS]), str); for (i = 0; i < ENTRY_COUNT; i++) { - g_signal_handlers_unblock_by_func(priv->entries[i], - (gpointer) hildon_time_editor_entry_changed, editor); - - g_signal_handlers_unblock_by_func(priv->entries[i], - (gpointer) hildon_time_editor_inserted_text, editor); + g_signal_handlers_unblock_by_func (priv->entries[i], + (gpointer) hildon_time_editor_entry_changed, editor); - g_signal_handlers_unblock_by_func(priv->entries[i], - (gpointer) hildon_time_editor_entry_focusout, editor); + g_signal_handlers_unblock_by_func (priv->entries[i], + (gpointer) hildon_time_editor_inserted_text, editor); - } + g_signal_handlers_unblock_by_func (priv->entries[i], + (gpointer) hildon_time_editor_entry_focus_out, editor); + } /* Update AM/PM label in case we're in 12h mode */ - gtk_label_set_label(GTK_LABEL(priv->ampm_label), - priv->am ? priv->am_symbol : priv->pm_symbol); - + gtk_label_set_label( GTK_LABEL (priv->ampm_label), + priv->am ? priv->am_symbol : priv->pm_symbol); + g_object_notify (G_OBJECT (editor), "ticks"); } static void -hildon_time_editor_set_to_current_time (HildonTimeEditor * editor) +hildon_time_editor_set_to_current_time (HildonTimeEditor *editor) { time_t now; const struct tm *tm; - now = time(NULL); - tm = localtime(&now); + now = time (NULL); + tm = localtime (&now); if (tm != NULL) - hildon_time_editor_set_time(editor, tm->tm_hour, tm->tm_min, tm->tm_sec); + hildon_time_editor_set_time (editor, tm->tm_hour, tm->tm_min, tm->tm_sec); } /** @@ -861,16 +863,16 @@ hildon_time_editor_set_to_current_time (HildonTimeEditor * editor) * * Returns: current duration in seconds */ - -guint hildon_time_editor_get_ticks (HildonTimeEditor * editor) +guint +hildon_time_editor_get_ticks (HildonTimeEditor *editor) { HildonTimeEditorPrivate *priv; - g_return_val_if_fail(editor, 0); - g_return_val_if_fail(HILDON_IS_TIME_EDITOR(editor), 0); + g_return_val_if_fail (HILDON_IS_TIME_EDITOR (editor), 0); priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); - + g_assert (priv); + return (priv->ticks); } @@ -881,28 +883,29 @@ guint hildon_time_editor_get_ticks (HildonTimeEditor * editor) * * This function shows or hides the seconds field. */ - -void hildon_time_editor_set_show_seconds (HildonTimeEditor * editor, - gboolean show_seconds) +void +hildon_time_editor_set_show_seconds (HildonTimeEditor *editor, + gboolean show_seconds) { HildonTimeEditorPrivate *priv; - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); if (show_seconds != priv->show_seconds) { priv->show_seconds = show_seconds; /* show/hide seconds field and its ':' label if the value changed. */ if (show_seconds) { - gtk_widget_show(priv->entries[ENTRY_SECS]); - gtk_widget_show(priv->sec_label); + gtk_widget_show (priv->entries[ENTRY_SECS]); + gtk_widget_show (priv->sec_label); } else { - gtk_widget_hide(priv->entries[ENTRY_SECS]); - gtk_widget_hide(priv->sec_label); + gtk_widget_hide (priv->entries[ENTRY_SECS]); + gtk_widget_hide (priv->sec_label); } - + g_object_notify (G_OBJECT (editor), "show_seconds"); } } @@ -916,13 +919,14 @@ void hildon_time_editor_set_show_seconds (HildonTimeEditor * editor, * * Returns: TRUE if the seconds are visible */ - -gboolean hildon_time_editor_get_show_seconds (HildonTimeEditor * editor) +gboolean +hildon_time_editor_get_show_seconds (HildonTimeEditor *editor) { HildonTimeEditorPrivate *priv; g_return_val_if_fail (HILDON_IS_TIME_EDITOR (editor), FALSE); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); return (priv->show_seconds); } @@ -935,15 +939,16 @@ gboolean hildon_time_editor_get_show_seconds (HildonTimeEditor * editor) * This function sets the duration editor mode in which the maximum hours * is 99. */ - -void hildon_time_editor_set_duration_mode (HildonTimeEditor * editor, - gboolean duration_mode) +void +hildon_time_editor_set_duration_mode (HildonTimeEditor *editor, + gboolean duration_mode) { HildonTimeEditorPrivate *priv; - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); if (duration_mode != priv->duration_mode) { priv->duration_mode = duration_mode; @@ -951,24 +956,23 @@ void hildon_time_editor_set_duration_mode (HildonTimeEditor * editor, if (duration_mode) { /* FIXME: Why do we reset the duration range here? Would change API, so won't touch this for now. */ - hildon_time_editor_set_duration_range(editor, MIN_DURATION, - MAX_DURATION); + hildon_time_editor_set_duration_range (editor, MIN_DURATION, MAX_DURATION); /* There's no AM/PM label or time picker icon in duration mode. Make sure they're hidden. */ - gtk_widget_hide(GTK_WIDGET(priv->ampm_label)); - gtk_widget_hide(GTK_WIDGET(priv->ampm_button)); - gtk_widget_hide(GTK_WIDGET(priv->iconbutton)); + gtk_widget_hide (GTK_WIDGET (priv->ampm_label)); + gtk_widget_hide (GTK_WIDGET (priv->ampm_button)); + gtk_widget_hide (GTK_WIDGET (priv->iconbutton)); /* Duration mode has seconds by default. */ - hildon_time_editor_set_show_seconds(editor, TRUE); + hildon_time_editor_set_show_seconds (editor, TRUE); } else { /* Make sure AM/PM label and time picker icons are visible if needed */ - if (!priv->clock_24h) - gtk_widget_show(GTK_WIDGET(priv->ampm_label)); + if (! priv->clock_24h) + gtk_widget_show (GTK_WIDGET (priv->ampm_label)); - gtk_widget_show(GTK_WIDGET(priv->ampm_button)); - gtk_widget_show(GTK_WIDGET(priv->iconbutton)); + gtk_widget_show (GTK_WIDGET (priv->ampm_button)); + gtk_widget_show (GTK_WIDGET (priv->iconbutton)); - /* Reset the ticks to current time. Anything set in duration mode + /* Reset the ticks to current time. Anything set in duration mode * is bound to be invalid or useless in time mode. */ hildon_time_editor_set_to_current_time (editor); @@ -987,13 +991,14 @@ void hildon_time_editor_set_duration_mode (HildonTimeEditor * editor, * * Returns: TRUE if the #HildonTimeEditor is in duration mode */ - -gboolean hildon_time_editor_get_duration_mode (HildonTimeEditor * editor) +gboolean +hildon_time_editor_get_duration_mode (HildonTimeEditor *editor) { HildonTimeEditorPrivate *priv; g_return_val_if_fail (HILDON_IS_TIME_EDITOR (editor), FALSE); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); return (priv->duration_mode); } @@ -1006,28 +1011,29 @@ gboolean hildon_time_editor_get_duration_mode (HildonTimeEditor * editor) * Sets the minimum allowed duration for the duration mode. * Note: Has no effect in time mode */ - -void hildon_time_editor_set_duration_min (HildonTimeEditor * editor, - guint duration_min) +void +hildon_time_editor_set_duration_min (HildonTimeEditor *editor, + guint duration_min) { HildonTimeEditorPrivate *priv; - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); - g_return_if_fail(duration_min >= MIN_DURATION); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); + g_return_if_fail (duration_min >= MIN_DURATION); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); - if( !priv->duration_mode ) - return; + if (! priv->duration_mode ) + return; priv->duration_min = duration_min; - + /* Clamp the current value to the minimum if necessary */ if (priv->ticks < duration_min) { hildon_time_editor_set_ticks (editor, duration_min); } - + g_object_notify (G_OBJECT (editor), "duration_min"); } @@ -1040,17 +1046,18 @@ void hildon_time_editor_set_duration_min (HildonTimeEditor * editor, * * Returns: minimum allowed duration in seconds */ - -guint hildon_time_editor_get_duration_min (HildonTimeEditor * editor) +guint +hildon_time_editor_get_duration_min (HildonTimeEditor *editor) { HildonTimeEditorPrivate *priv; - g_return_val_if_fail(HILDON_IS_TIME_EDITOR(editor), 0); + g_return_val_if_fail (HILDON_IS_TIME_EDITOR (editor), 0); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); - if( !priv->duration_mode ) - return (0); + if(! priv->duration_mode ) + return (0); return (priv->duration_min); } @@ -1063,28 +1070,29 @@ guint hildon_time_editor_get_duration_min (HildonTimeEditor * editor) * Sets the maximum allowed duration in seconds for the duration mode. * Note: Has no effect in time mode */ - -void hildon_time_editor_set_duration_max (HildonTimeEditor * editor, - guint duration_max) +void +hildon_time_editor_set_duration_max (HildonTimeEditor *editor, + guint duration_max) { HildonTimeEditorPrivate *priv; - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); - g_return_if_fail(duration_max <= MAX_DURATION); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); + g_return_if_fail (duration_max <= MAX_DURATION); priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + g_assert (priv); - if( !priv->duration_mode ) - return; + if (! priv->duration_mode) + return; priv->duration_max = duration_max; - + /* Clamp the current value to the maximum if necessary */ if (priv->ticks > duration_max) { hildon_time_editor_set_ticks (editor, duration_max); } - + g_object_notify (G_OBJECT (editor), "duration_max"); } @@ -1097,22 +1105,22 @@ void hildon_time_editor_set_duration_max (HildonTimeEditor * editor, * * Returns: maximum allowed duration in seconds */ - -guint hildon_time_editor_get_duration_max (HildonTimeEditor * editor) +guint +hildon_time_editor_get_duration_max (HildonTimeEditor * editor) { HildonTimeEditorPrivate *priv; - g_return_val_if_fail(HILDON_IS_TIME_EDITOR(editor), 0); + g_return_val_if_fail (HILDON_IS_TIME_EDITOR (editor), 0); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); - if( !priv->duration_mode ) - return (0); + if (! priv->duration_mode) + return (0); return (priv->duration_max); } - /** * hildon_time_editor_set_time: * @editor: the #HildonTimeEditor widget @@ -1124,11 +1132,13 @@ guint hildon_time_editor_get_duration_max (HildonTimeEditor * editor) * time specified by the arguments is invalid, it's fixed. * The time is assumed to be in 24h format. */ - -void hildon_time_editor_set_time(HildonTimeEditor * editor, guint hours, - guint minutes, guint seconds) +void +hildon_time_editor_set_time (HildonTimeEditor *editor, + guint hours, + guint minutes, + guint seconds) { - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); hildon_time_editor_set_ticks (editor, TICKS(hours, minutes, seconds)); } @@ -1143,19 +1153,20 @@ void hildon_time_editor_set_time(HildonTimeEditor * editor, guint hours, * Gets the time of the #HildonTimeEditor widget. The time returned is * always in 24h format. */ - -void hildon_time_editor_get_time(HildonTimeEditor * editor, - guint * hours, - guint * minutes, guint * seconds) +void +hildon_time_editor_get_time (HildonTimeEditor *editor, + guint *hours, + guint *minutes, + guint *seconds) { HildonTimeEditorPrivate *priv; - - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); - ticks_to_time (hildon_time_editor_get_ticks (editor), - hours, minutes, seconds); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); + + ticks_to_time (hildon_time_editor_get_ticks (editor), hours, minutes, seconds); } /** @@ -1166,25 +1177,27 @@ void hildon_time_editor_get_time(HildonTimeEditor * editor, * * Sets the duration editor time range of the #HildonTimeEditor widget. */ - -void hildon_time_editor_set_duration_range(HildonTimeEditor * editor, - guint min_seconds, - guint max_seconds) +void +hildon_time_editor_set_duration_range (HildonTimeEditor *editor, + guint min_seconds, + guint max_seconds) { HildonTimeEditorPrivate *priv; guint tmp; - - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); + + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); + /* Swap values if reversed */ if (min_seconds > max_seconds) - { + { tmp = max_seconds; max_seconds = min_seconds; min_seconds = tmp; - } - + } + hildon_time_editor_set_duration_max (editor, max_seconds); hildon_time_editor_set_duration_min (editor, min_seconds); @@ -1192,7 +1205,7 @@ void hildon_time_editor_set_duration_range(HildonTimeEditor * editor, /* Set minimum allowed value for duration editor. FIXME: Shouldn't it be changed only if it's not in range? Would change API, so won't touch this for now. */ - hildon_time_editor_set_ticks(editor, min_seconds); + hildon_time_editor_set_ticks (editor, min_seconds); } } @@ -1204,33 +1217,36 @@ void hildon_time_editor_set_duration_range(HildonTimeEditor * editor, * * Gets the duration editor time range of the #HildonTimeEditor widget. */ - -void hildon_time_editor_get_duration_range(HildonTimeEditor * editor, - guint * min_seconds, - guint * max_seconds) +void +hildon_time_editor_get_duration_range (HildonTimeEditor *editor, + guint *min_seconds, + guint *max_seconds) { HildonTimeEditorPrivate *priv; - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); *min_seconds = priv->duration_min; *max_seconds = priv->duration_max; } -static gboolean hildon_time_editor_check_locale(HildonTimeEditor * editor) +static gboolean +hildon_time_editor_check_locale (HildonTimeEditor *editor) { HildonTimeEditorPrivate *priv; - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); /* Update time separator symbols */ - _hildon_time_editor_get_time_separators(GTK_LABEL(priv->hm_label), GTK_LABEL(priv->sec_label)); - + hildon_time_editor_get_time_separators (GTK_LABEL (priv->hm_label), GTK_LABEL (priv->sec_label)); + /* Get AM/PM symbols. */ - priv->am_symbol = g_strdup(nl_langinfo(AM_STR)); - priv->pm_symbol = g_strdup(nl_langinfo(PM_STR)); + priv->am_symbol = g_strdup (nl_langinfo (AM_STR)); + priv->pm_symbol = g_strdup (nl_langinfo (PM_STR)); if (priv->am_symbol[0] == '\0') return TRUE; @@ -1239,63 +1255,66 @@ static gboolean hildon_time_editor_check_locale(HildonTimeEditor * editor) %p is the AM/PM string, so we assume that if the format string begins with %p it's in the beginning, and in any other case it's in the end (although that's not necessarily the case). */ - if (strncmp(nl_langinfo(T_FMT_AMPM), "%p", 2) == 0) + if (strncmp (nl_langinfo (T_FMT_AMPM), "%p", 2) == 0) priv->ampm_pos_after = FALSE; return FALSE; } } -static gboolean hildon_time_editor_entry_focusin(GtkWidget * widget, - GdkEventFocus * event, +static gboolean +hildon_time_editor_entry_focus_in (GtkWidget *widget, + GdkEventFocus *event, gpointer data) { - g_idle_add((GSourceFunc) _hildon_time_editor_entry_select_all, - GTK_ENTRY(widget)); + g_idle_add ((GSourceFunc) hildon_time_editor_entry_select_all, + GTK_ENTRY (widget)); return FALSE; } static gboolean -hildon_time_editor_time_error(HildonTimeEditor *editor, - HildonDateTimeEditorError type) +hildon_time_editor_time_error (HildonTimeEditor *editor, + HildonDateTimeEditorError type) { - return TRUE; + return TRUE; } /* Returns negative if we didn't get value, * and should stop further validation */ -static gint validated_conversion(HildonTimeEditorPrivate *priv, - GtkWidget *field, - gint min, - gint max, - gint def_value, - gboolean allow_intermediate, - guint *error_code, - GString *error_string) +static gint +validated_conversion (HildonTimeEditorPrivate *priv, + GtkWidget *field, + gint min, + gint max, + gint def_value, + gboolean allow_intermediate, + guint *error_code, + GString *error_string) { const gchar *text; gchar *tail; long value; - text = gtk_entry_get_text(GTK_ENTRY(field)); + text = gtk_entry_get_text (GTK_ENTRY (field)); if (text && text[0]) { /* Try to convert entry text to number */ - value = strtol(text, &tail, 10); + value = strtol (text, &tail, 10); /* Check if conversion succeeded */ if ((tail[0] == 0) && !(text[0] == '-')) { if (value > max) { - g_string_printf(error_string, _("ckct_ib_maximum_value"), max); + g_string_printf (error_string, _("ckct_ib_maximum_value"), max); priv->error_widget = field; *error_code = MAX_VALUE; return max; - } + } + if (value < min && !allow_intermediate) { - g_string_printf(error_string, _("ckct_ib_minimum_value"), min); + g_string_printf (error_string, _("ckct_ib_minimum_value"), min); priv->error_widget = field; *error_code = MIN_VALUE; return min; @@ -1303,39 +1322,41 @@ static gint validated_conversion(HildonTimeEditorPrivate *priv, return value; } + /* We'll handle failed conversions soon */ - else - { - if ((tail[0] == '-') || (text[0] == '-')) - { - g_string_printf(error_string, _("ckct_ib_minimum_value"), min); - priv->error_widget = field; - *error_code = MIN_VALUE; - return min; - } - } + else + { + if ((tail[0] == '-') || (text[0] == '-')) + { + g_string_printf (error_string, _("ckct_ib_minimum_value"), min); + priv->error_widget = field; + *error_code = MIN_VALUE; + return min; + } + } } else if (allow_intermediate) return -1; /* Empty field while user is still editing. No error, but cannot validate either... */ else /* Empty field: show error and set value to minimum allowed */ - { - g_string_printf(error_string, _("ckct_ib_set_a_value_within_range"), min, max); + { + g_string_printf (error_string, _("ckct_ib_set_a_value_within_range"), min, max); priv->error_widget = field; *error_code = WITHIN_RANGE; return def_value; - } + } /* Empty field and not allowed intermediated OR failed conversion */ - g_string_printf(error_string, _("ckct_ib_set_a_value_within_range"), min, max); + g_string_printf (error_string, _("ckct_ib_set_a_value_within_range"), min, max); priv->error_widget = field; *error_code = WITHIN_RANGE; return -1; } static void -hildon_time_editor_real_validate(HildonTimeEditor *editor, - gboolean allow_intermediate, GString *error_string) +hildon_time_editor_real_validate (HildonTimeEditor *editor, + gboolean allow_intermediate, + GString *error_string) { HildonTimeEditorPrivate *priv; guint h, m, s, ticks; @@ -1345,15 +1366,16 @@ hildon_time_editor_real_validate(HildonTimeEditor *editor, guint max_seconds, min_seconds, def_seconds; gboolean r; - g_assert(HILDON_IS_TIME_EDITOR(editor)); + g_assert (HILDON_IS_TIME_EDITOR (editor)); + + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); - /* Find limits for field based validation. */ if (priv->duration_mode) { - ticks_to_time(priv->duration_min, &min_hours, &min_minutes, &min_seconds); - ticks_to_time(priv->duration_max, &max_hours, &max_minutes, &max_seconds); + ticks_to_time (priv->duration_min, &min_hours, &min_minutes, &min_seconds); + ticks_to_time (priv->duration_max, &max_hours, &max_minutes, &max_seconds); } else { if (priv->clock_24h) { max_hours = HOURS_MAX_24; @@ -1364,27 +1386,27 @@ hildon_time_editor_real_validate(HildonTimeEditor *editor, } } - hildon_time_editor_get_time(editor, &def_hours, &def_minutes, &def_seconds); + hildon_time_editor_get_time (editor, &def_hours, &def_minutes, &def_seconds); /* Get time components from fields and validate them... */ if (priv->show_hours) { - h = validated_conversion(priv, priv->entries[ENTRY_HOURS], min_hours, max_hours, def_hours, - allow_intermediate, &error_code, error_string); - if (priv->error_widget == priv->entries[ENTRY_HOURS]) - g_signal_emit (editor, time_editor_signals [TIME_ERROR], 0, hour_errors[error_code], &r); + h = validated_conversion (priv, priv->entries[ENTRY_HOURS], min_hours, max_hours, def_hours, + allow_intermediate, &error_code, error_string); + if (priv->error_widget == priv->entries[ENTRY_HOURS]) + g_signal_emit (editor, time_editor_signals [TIME_ERROR], 0, hour_errors[error_code], &r); if ((gint) h < 0) return; } else h = 0; - m = validated_conversion(priv, priv->entries[ENTRY_MINS], MINUTES_MIN, MINUTES_MAX, def_minutes, - allow_intermediate, &error_code, error_string); + m = validated_conversion (priv, priv->entries[ENTRY_MINS], MINUTES_MIN, MINUTES_MAX, def_minutes, + allow_intermediate, &error_code, error_string); if (priv->error_widget == priv->entries[ENTRY_MINS]) - g_signal_emit (editor, time_editor_signals [TIME_ERROR], 0, min_errors[error_code], &r); + g_signal_emit (editor, time_editor_signals [TIME_ERROR], 0, min_errors[error_code], &r); if ((gint) m < 0) return; if (priv->show_seconds) { - s = validated_conversion(priv, priv->entries[ENTRY_SECS], SECONDS_MIN, SECONDS_MAX, def_seconds, - allow_intermediate, &error_code, error_string); - if (priv->error_widget == priv->entries[ENTRY_SECS]) - g_signal_emit (editor, time_editor_signals [TIME_ERROR], 0, sec_errors[error_code], &r); + s = validated_conversion (priv, priv->entries[ENTRY_SECS], SECONDS_MIN, SECONDS_MAX, def_seconds, + allow_intermediate, &error_code, error_string); + if (priv->error_widget == priv->entries[ENTRY_SECS]) + g_signal_emit (editor, time_editor_signals [TIME_ERROR], 0, sec_errors[error_code], &r); if ((gint) s < 0) return; } else s = 0; @@ -1396,67 +1418,69 @@ hildon_time_editor_real_validate(HildonTimeEditor *editor, if (ticks < priv->duration_min && !allow_intermediate) { - g_string_printf(error_string, - _("ckct_ib_min_allowed_duration_hts"), - min_hours, min_minutes, min_seconds); + g_string_printf (error_string, + _("ckct_ib_min_allowed_duration_hts"), + min_hours, min_minutes, min_seconds); hildon_time_editor_set_ticks (editor, priv->duration_min); priv->error_widget = priv->show_hours ? priv->entries[ENTRY_HOURS] : priv->entries[ENTRY_MINS]; - g_signal_emit (editor, time_editor_signals[TIME_ERROR], 0, HILDON_DATE_TIME_ERROR_MIN_DURATION, &r); + g_signal_emit (editor, time_editor_signals[TIME_ERROR], 0, HILDON_DATE_TIME_ERROR_MIN_DURATION, &r); return; } else if (ticks > priv->duration_max) { - g_string_printf(error_string, - _("ckct_ib_max_allowed_duration_hts"), - max_hours, max_minutes, max_seconds); + g_string_printf (error_string, + _("ckct_ib_max_allowed_duration_hts"), + max_hours, max_minutes, max_seconds); hildon_time_editor_set_ticks (editor, priv->duration_max); priv->error_widget = priv->show_hours ? priv->entries[ENTRY_HOURS] : priv->entries[ENTRY_MINS]; - g_signal_emit (editor, time_editor_signals[TIME_ERROR], 0, HILDON_DATE_TIME_ERROR_MAX_DURATION, &r); + g_signal_emit (editor, time_editor_signals[TIME_ERROR], 0, HILDON_DATE_TIME_ERROR_MAX_DURATION, &r); return; } } - else if (!priv->clock_24h) + else if (! priv->clock_24h) convert_to_24h (&h, priv->am); /* The only case when we do not want to refresh the time display, is when the user is editing a value (unless the value was out of bounds and we have to fix it) */ - if (!allow_intermediate || priv->error_widget) + if (! allow_intermediate || priv->error_widget) hildon_time_editor_set_time (editor, h, m, s); } /* Setting text to entries causes entry to recompute itself in idle callback, which remove selection. Because of this we need to do selection in idle as well. */ -static gboolean highlight_callback(gpointer data) +static gboolean +highlight_callback (gpointer data) { HildonTimeEditorPrivate *priv; GtkWidget *widget; gint i; - g_assert(HILDON_IS_TIME_EDITOR(data)); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(data); - + g_assert (HILDON_IS_TIME_EDITOR (data)); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (data); + g_assert (priv); + GDK_THREADS_ENTER (); - + widget = priv->error_widget; priv->error_widget = NULL; - if (GTK_IS_WIDGET(widget) == FALSE) - goto Done; + if (GTK_IS_WIDGET (widget) == FALSE) + goto Done; /* Avoid revalidation because it will issue the date_error signal twice when there is an empty field. We must block the signal for all the entries because we do not know where the focus comes from */ for (i = 0; i < ENTRY_COUNT; i++) - g_signal_handlers_block_by_func(priv->entries[i], - (gpointer) hildon_time_editor_entry_focusout, data); - gtk_editable_select_region(GTK_EDITABLE(widget), 0, -1); - gtk_widget_grab_focus(widget); + g_signal_handlers_block_by_func (priv->entries[i], + (gpointer) hildon_time_editor_entry_focus_out, data); + gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1); + gtk_widget_grab_focus (widget); for (i = 0; i < ENTRY_COUNT; i++) - g_signal_handlers_unblock_by_func(priv->entries[i], - (gpointer) hildon_time_editor_entry_focusout, data); + g_signal_handlers_unblock_by_func (priv->entries[i], + (gpointer) hildon_time_editor_entry_focus_out, data); Done: priv->highlight_idle = 0; @@ -1468,105 +1492,108 @@ Done: /* Update ticks from current H:M:S entries. If they're invalid, show an infoprint and update the fields unless they're empty. */ static void -hildon_time_editor_validate (HildonTimeEditor *editor, gboolean allow_intermediate) +hildon_time_editor_validate (HildonTimeEditor *editor, + gboolean allow_intermediate) { HildonTimeEditorPrivate *priv; GString *error_message; - g_assert(HILDON_IS_TIME_EDITOR(editor)); - + g_assert (HILDON_IS_TIME_EDITOR(editor)); priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + g_assert (priv); /* if there is already an error we do nothing until it will be managed by the idle */ if (priv->highlight_idle == 0 && priv->skipper == FALSE) - { + { priv->skipper = TRUE; - error_message = g_string_new(NULL); - hildon_time_editor_real_validate(editor, - allow_intermediate, error_message); - + error_message = g_string_new (NULL); + hildon_time_editor_real_validate (editor, + allow_intermediate, error_message); + if (priv->error_widget) - { - hildon_banner_show_information(priv->error_widget, NULL, - error_message->str); - - priv->highlight_idle = g_idle_add(highlight_callback, editor); - } + { + hildon_banner_show_information (priv->error_widget, NULL, + error_message->str); + + priv->highlight_idle = g_idle_add (highlight_callback, editor); + } priv->skipper = FALSE; - g_string_free(error_message, TRUE); - } + g_string_free (error_message, TRUE); + } } /* on inserted text, if entry has two digits, jumps to the next field. */ static void -hildon_time_editor_inserted_text (GtkEditable * editable, - gchar * new_text, - gint new_text_length, - gint * position, - gpointer user_data) +hildon_time_editor_inserted_text (GtkEditable *editable, + gchar *new_text, + gint new_text_length, + gint *position, + gpointer user_data) { - HildonTimeEditor *editor; - GtkEntry *entry; - gchar *value; - HildonTimeEditorPrivate *priv; + HildonTimeEditor *editor; + GtkEntry *entry; + gchar *value; + HildonTimeEditorPrivate *priv; - entry = GTK_ENTRY(editable); - editor = HILDON_TIME_EDITOR(user_data); + entry = GTK_ENTRY (editable); + editor = HILDON_TIME_EDITOR (user_data); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); - /* if there is already an error we don't have to do anything */ - if (!priv->error_widget) + /* if there is already an error we don't have to do anything */ + if (! priv->error_widget) { - - value = (gchar *) gtk_entry_get_text(entry); - - if (strlen(value) == 2) + value = (gchar *) gtk_entry_get_text (entry); + + if (strlen (value) == 2) { - if (GTK_WIDGET(editable) == priv->entries[ENTRY_HOURS]) + if (GTK_WIDGET (editable) == priv->entries[ENTRY_HOURS]) { - /* We already checked the input in changed signal, but - * now we will re-check it again in focus-out we - * intermediate flag set to FALSE */ - gtk_widget_grab_focus(priv->entries[ENTRY_MINS]); - *position = -1; + /* We already checked the input in changed signal, but + * now we will re-check it again in focus-out we + * intermediate flag set to FALSE */ + gtk_widget_grab_focus (priv->entries[ENTRY_MINS]); + *position = -1; } - else if (GTK_WIDGET(editable) == priv->entries[ENTRY_MINS] && - GTK_WIDGET_VISIBLE (priv->entries[ENTRY_SECS])) + else if (GTK_WIDGET (editable) == priv->entries[ENTRY_MINS] && + GTK_WIDGET_VISIBLE (priv->entries[ENTRY_SECS])) { - /* See above */ - gtk_widget_grab_focus(priv->entries[ENTRY_SECS]); - *position = -1; + /* See above */ + gtk_widget_grab_focus (priv->entries[ENTRY_SECS]); + *position = -1; } } } } -static gboolean hildon_time_editor_entry_focusout(GtkWidget * widget, - GdkEventFocus * event, - gpointer data) +static gboolean +hildon_time_editor_entry_focus_out (GtkWidget *widget, + GdkEventFocus *event, + gpointer data) { - g_assert(HILDON_IS_TIME_EDITOR(data)); + g_assert (HILDON_IS_TIME_EDITOR (data)); - /* Validate the given time and update ticks. */ - hildon_time_editor_validate(HILDON_TIME_EDITOR(data), FALSE); + /* Validate the given time and update ticks. */ + hildon_time_editor_validate (HILDON_TIME_EDITOR (data), FALSE); - return FALSE; + return FALSE; } static gboolean -hildon_time_editor_ampm_clicked(GtkWidget * widget, - gpointer data) +hildon_time_editor_ampm_clicked (GtkWidget *widget, + gpointer data) { HildonTimeEditor *editor; HildonTimeEditorPrivate *priv; - g_assert(GTK_IS_WIDGET(widget)); - g_assert(HILDON_IS_TIME_EDITOR(data)); + g_assert (GTK_IS_WIDGET (widget)); + g_assert (HILDON_IS_TIME_EDITOR (data)); - editor = HILDON_TIME_EDITOR(data); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + editor = HILDON_TIME_EDITOR (data); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); /* First validate the given time and update ticks. */ hildon_time_editor_validate (editor, FALSE); @@ -1574,16 +1601,18 @@ hildon_time_editor_ampm_clicked(GtkWidget * widget, /* Apply the AM/PM change by moving the current time by 12 hours */ if (priv->am) { /* 00:00 .. 11:59 -> 12:00 .. 23:59 */ - hildon_time_editor_set_ticks (editor, priv->ticks + 12*3600); + hildon_time_editor_set_ticks (editor, priv->ticks + 12 * 3600); } else { /* 12:00 .. 23:59 -> 00:00 .. 11:59 */ - hildon_time_editor_set_ticks (editor, priv->ticks - 12*3600); + hildon_time_editor_set_ticks (editor, priv->ticks - 12 * 3600); } + return FALSE; } static gboolean -hildon_time_editor_icon_clicked(GtkWidget * widget, gpointer data) +hildon_time_editor_icon_clicked (GtkWidget *widget, + gpointer data) { HildonTimeEditor *editor; GtkWidget *picker; @@ -1591,62 +1620,66 @@ hildon_time_editor_icon_clicked(GtkWidget * widget, gpointer data) guint h, m, s, result; HildonTimeEditorPrivate *priv; - g_assert(HILDON_IS_TIME_EDITOR(data)); + g_assert (HILDON_IS_TIME_EDITOR (data)); - editor = HILDON_TIME_EDITOR(data); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + editor = HILDON_TIME_EDITOR (data); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); /* icon is passive in duration editor mode */ - if (hildon_time_editor_get_duration_mode(editor)) + if (hildon_time_editor_get_duration_mode (editor)) return FALSE; /* Validate and do not launch if broken */ - hildon_time_editor_validate(HILDON_TIME_EDITOR(data), FALSE); + hildon_time_editor_validate (HILDON_TIME_EDITOR (data), FALSE); if (priv->error_widget != NULL) return FALSE; /* Launch HildonTimePicker dialog */ - parent = gtk_widget_get_ancestor(GTK_WIDGET(editor), GTK_TYPE_WINDOW); - picker = hildon_time_picker_new(GTK_WINDOW(parent)); + parent = gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW); + picker = hildon_time_picker_new (GTK_WINDOW (parent)); - hildon_time_editor_get_time(editor, &h, &m, &s); - hildon_time_picker_set_time(HILDON_TIME_PICKER(picker), h, m); + hildon_time_editor_get_time (editor, &h, &m, &s); + hildon_time_picker_set_time (HILDON_TIME_PICKER (picker), h, m); - result = gtk_dialog_run(GTK_DIALOG(picker)); + result = gtk_dialog_run (GTK_DIALOG (picker)); switch (result) { - case GTK_RESPONSE_OK: - case GTK_RESPONSE_ACCEPT: - /* Use the selected time */ - hildon_time_picker_get_time(HILDON_TIME_PICKER(picker), &h, &m); - hildon_time_editor_set_time(editor, h, m, 0); - break; - default: - break; + + case GTK_RESPONSE_OK: + case GTK_RESPONSE_ACCEPT: + /* Use the selected time */ + hildon_time_picker_get_time (HILDON_TIME_PICKER (picker), &h, &m); + hildon_time_editor_set_time (editor, h, m, 0); + break; + + default: + break; } - gtk_widget_destroy(picker); + gtk_widget_destroy (picker); return FALSE; } -static void hildon_time_editor_size_request(GtkWidget * widget, - GtkRequisition * requisition) +static void +hildon_time_editor_size_request (GtkWidget *widget, + GtkRequisition *requisition) { HildonTimeEditor *editor; HildonTimeEditorPrivate *priv; GtkRequisition req; - editor = HILDON_TIME_EDITOR(widget); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + editor = HILDON_TIME_EDITOR (widget); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); /* Get frame's size */ - gtk_widget_size_request(priv->frame, requisition); + gtk_widget_size_request (priv->frame, requisition); - if (GTK_WIDGET_VISIBLE(priv->iconbutton)) + if (GTK_WIDGET_VISIBLE (priv->iconbutton)) { - gtk_widget_size_request(priv->iconbutton, &req); + gtk_widget_size_request (priv->iconbutton, &req); /* Reserve space for icon */ requisition->width += req.width + ICON_PRESSED + - HILDON_MARGIN_DEFAULT; + HILDON_MARGIN_DEFAULT; } /* FIXME: It's evil to use hardcoded TIME_EDITOR_HEIGHT. For now we'll @@ -1655,35 +1688,38 @@ static void hildon_time_editor_size_request(GtkWidget * widget, requisition->height = TIME_EDITOR_HEIGHT; } -static void hildon_time_editor_size_allocate(GtkWidget * widget, - GtkAllocation * allocation) +static void +hildon_time_editor_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) { - HildonTimeEditorPrivate *priv = HILDON_TIME_EDITOR_GET_PRIVATE(widget); + HildonTimeEditorPrivate *priv = HILDON_TIME_EDITOR_GET_PRIVATE (widget); GtkAllocation alloc; GtkRequisition req, max_req; + g_assert (priv); + widget->allocation = *allocation; - gtk_widget_get_child_requisition(widget, &max_req); + gtk_widget_get_child_requisition (widget, &max_req); /* Center horizontally */ - alloc.x = allocation->x + MAX(allocation->width - max_req.width, 0) / 2; + alloc.x = allocation->x + MAX (allocation->width - max_req.width, 0) / 2; /* Center vertically */ - alloc.y = allocation->y + MAX(allocation->height - max_req.height, 0) / 2; - + alloc.y = allocation->y + MAX (allocation->height - max_req.height, 0) / 2; + /* allocate frame */ - gtk_widget_get_child_requisition(priv->frame, &req); + gtk_widget_get_child_requisition (priv->frame, &req); alloc.width = req.width; alloc.height = max_req.height; - gtk_widget_size_allocate(priv->frame, &alloc); + gtk_widget_size_allocate (priv->frame, &alloc); /* allocate icon */ - if (GTK_WIDGET_VISIBLE(priv->iconbutton)) { - gtk_widget_get_child_requisition(priv->iconbutton, &req); + if (GTK_WIDGET_VISIBLE (priv->iconbutton)) { + gtk_widget_get_child_requisition (priv->iconbutton, &req); alloc.x += alloc.width + HILDON_MARGIN_DEFAULT; alloc.width = req.width; - gtk_widget_size_allocate(priv->iconbutton, &alloc); + gtk_widget_size_allocate (priv->iconbutton, &alloc); } /* FIXME: ugly way to move labels up. They just don't seem move up @@ -1692,41 +1728,43 @@ static void hildon_time_editor_size_allocate(GtkWidget * widget, alloc = priv->ampm_label->allocation; alloc.y = allocation->y - 2; alloc.height = max_req.height + 2; - gtk_widget_size_allocate(priv->ampm_label, &alloc); + gtk_widget_size_allocate (priv->ampm_label, &alloc); alloc = priv->hm_label->allocation; alloc.y = allocation->y - 2; alloc.height = max_req.height + 2; - gtk_widget_size_allocate(priv->hm_label, &alloc); + gtk_widget_size_allocate (priv->hm_label, &alloc); alloc = priv->sec_label->allocation; alloc.y = allocation->y - 2; alloc.height = max_req.height + 2; - gtk_widget_size_allocate(priv->sec_label, &alloc); + gtk_widget_size_allocate (priv->sec_label, &alloc); } -static gboolean hildon_time_editor_entry_keypress(GtkWidget * widget, - GdkEventKey * event, - gpointer data) +static gboolean +hildon_time_editor_entry_keypress (GtkWidget *widget, + GdkEventKey *event, + gpointer data) { HildonTimeEditor *editor; HildonTimeEditorPrivate *priv; gint cursor_pos; gboolean r; - g_assert(GTK_IS_ENTRY(widget)); - g_assert(event != NULL); - g_assert(HILDON_IS_TIME_EDITOR(data)); + g_assert (GTK_IS_ENTRY (widget)); + g_assert (event != NULL); + g_assert (HILDON_IS_TIME_EDITOR (data)); - editor = HILDON_TIME_EDITOR(data); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); - cursor_pos = gtk_editable_get_position(GTK_EDITABLE(widget)); + editor = HILDON_TIME_EDITOR (data); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); + cursor_pos = gtk_editable_get_position (GTK_EDITABLE (widget)); /* Show error message in case the key pressed is not allowed (only digits and control characters are allowed )*/ - if (!g_unichar_isdigit(event->keyval) && !(event->keyval & 0xF000)) { - g_signal_emit(editor, time_editor_signals[TIME_ERROR], 0, HILDON_DATE_TIME_ERROR_INVALID_CHAR, &r); - hildon_banner_show_information(widget, NULL, _("ckct_ib_illegal_character")); + if (!g_unichar_isdigit (event->keyval) && ! (event->keyval & 0xF000)) { + g_signal_emit (editor, time_editor_signals[TIME_ERROR], 0, HILDON_DATE_TIME_ERROR_INVALID_CHAR, &r); + hildon_banner_show_information (widget, NULL, _("ckct_ib_illegal_character")); return TRUE; } @@ -1737,16 +1775,16 @@ static gboolean hildon_time_editor_entry_keypress(GtkWidget * widget, the time picker icon was clicked. Before opening the time picker the fields are first validated and fixed. */ hildon_time_editor_validate (editor, FALSE); - hildon_gtk_button_set_depressed(GTK_BUTTON(priv->iconbutton), TRUE); - hildon_time_editor_icon_clicked(widget, data); - hildon_gtk_button_set_depressed(GTK_BUTTON(priv->iconbutton), FALSE); + hildon_gtk_button_set_depressed (GTK_BUTTON (priv->iconbutton), TRUE); + hildon_time_editor_icon_clicked (widget, data); + hildon_gtk_button_set_depressed (GTK_BUTTON (priv->iconbutton), FALSE); return TRUE; case GDK_Left: /* left arrow pressed in the entry. If we are on first position, try to move to the previous field. */ if (cursor_pos == 0) { - (void) gtk_widget_child_focus(GTK_WIDGET(editor), GTK_DIR_LEFT); + (void) gtk_widget_child_focus (GTK_WIDGET (editor), GTK_DIR_LEFT); return TRUE; } break; @@ -1754,8 +1792,8 @@ static gboolean hildon_time_editor_entry_keypress(GtkWidget * widget, case GDK_Right: /* right arrow pressed in the entry. If we are on last position, try to move to the next field. */ - if (cursor_pos >= g_utf8_strlen(gtk_entry_get_text(GTK_ENTRY(widget)), -1)) { - (void) gtk_widget_child_focus(GTK_WIDGET(editor), GTK_DIR_RIGHT); + if (cursor_pos >= g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (widget)), -1)) { + (void) gtk_widget_child_focus (GTK_WIDGET (editor), GTK_DIR_RIGHT); return TRUE; } break; @@ -1767,36 +1805,35 @@ static gboolean hildon_time_editor_entry_keypress(GtkWidget * widget, return FALSE; } -/*** - * Utility functions - */ - static void -convert_to_12h (guint *h, gboolean *am) +convert_to_12h (guint *h, + gboolean *am) { - g_assert(0 <= *h && *h < 24); + g_assert (0 <= *h && *h < 24); - /* 00:00 to 00:59 add 12 hours */ - /* 01:00 to 11:59 straight to am */ - /* 12:00 to 12:59 straight to pm */ - /* 13:00 to 23:59 subtract 12 hours */ + /* 00:00 to 00:59 add 12 hours */ + /* 01:00 to 11:59 straight to am */ + /* 12:00 to 12:59 straight to pm */ + /* 13:00 to 23:59 subtract 12 hours */ - if ( *h == 0 ) { *am = TRUE; *h += 12;} - else if ( 1 <= *h && *h < 12 ) { *am = TRUE; } - else if ( 12 <= *h && *h < 13 ) { *am = FALSE; } - else { *am = FALSE; *h -= 12;} + if ( *h == 0 ) { *am = TRUE; *h += 12;} + else if ( 1 <= *h && *h < 12 ) { *am = TRUE; } + else if ( 12 <= *h && *h < 13 ) { *am = FALSE; } + else { *am = FALSE; *h -= 12;} } static void -convert_to_24h (guint *h, gboolean am) +convert_to_24h (guint *h, + gboolean am) { - if (*h == 12 && am) /* 12 midnight - 12:59 AM subtract 12 hours */ + if (*h == 12 && am) /* 12 midnight - 12:59 AM subtract 12 hours */ { - *h -= 12; + *h -= 12; } - else if (!am && 1 <= *h && *h < 12) /* 1:00 PM - 11:59 AM add 12 hours */ + + else if (! am && 1 <= *h && *h < 12) /* 1:00 PM - 11:59 AM add 12 hours */ { - *h += 12; + *h += 12; } } @@ -1807,29 +1844,30 @@ convert_to_24h (guint *h, gboolean am) * * This function shows or hides the hours field. * - * Since: 0.12.4 **/ -void hildon_time_editor_set_show_hours(HildonTimeEditor * editor, - gboolean show_hours) +void +hildon_time_editor_set_show_hours (HildonTimeEditor *editor, + gboolean show_hours) { HildonTimeEditorPrivate *priv; - g_return_if_fail(HILDON_IS_TIME_EDITOR(editor)); + g_return_if_fail (HILDON_IS_TIME_EDITOR (editor)); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); if (show_hours != priv->show_hours) { priv->show_hours = show_hours; /* show/hide hours field and its ':' label if the value changed. */ if (show_hours) { - gtk_widget_show(priv->entries[ENTRY_HOURS]); - gtk_widget_show(priv->hm_label); + gtk_widget_show (priv->entries[ENTRY_HOURS]); + gtk_widget_show (priv->hm_label); } else { - gtk_widget_hide(priv->entries[ENTRY_HOURS]); - gtk_widget_hide(priv->hm_label); + gtk_widget_hide (priv->entries[ENTRY_HOURS]); + gtk_widget_hide (priv->hm_label); } - + g_object_notify (G_OBJECT (editor), "show_hours"); } } @@ -1843,24 +1881,26 @@ void hildon_time_editor_set_show_hours(HildonTimeEditor * editor, * * Return value: TRUE if hours are visible. * - * Since: 0.12.4-1 **/ -gboolean hildon_time_editor_get_show_hours(HildonTimeEditor *editor) +gboolean +hildon_time_editor_get_show_hours (HildonTimeEditor *editor) { HildonTimeEditorPrivate *priv; g_return_val_if_fail (HILDON_IS_TIME_EDITOR (editor), FALSE); - priv = HILDON_TIME_EDITOR_GET_PRIVATE(editor); + priv = HILDON_TIME_EDITOR_GET_PRIVATE (editor); + g_assert (priv); return priv->show_hours; } /* Idle callback */ static gboolean -_hildon_time_editor_entry_select_all (GtkWidget *widget) +hildon_time_editor_entry_select_all (GtkWidget *widget) { - GDK_THREADS_ENTER (); - gtk_editable_select_region(GTK_EDITABLE(widget), 0, -1); - GDK_THREADS_LEAVE (); - return FALSE; + GDK_THREADS_ENTER (); + gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1); + GDK_THREADS_LEAVE (); + + return FALSE; } diff --git a/src/hildon-time-editor.h b/src/hildon-time-editor.h index 3118a2c..92e4517 100644 --- a/src/hildon-time-editor.h +++ b/src/hildon-time-editor.h @@ -22,102 +22,148 @@ * */ -#ifndef __HILDON_TIME_EDITOR_H__ -#define __HILDON_TIME_EDITOR_H__ +#ifndef __HILDON_TIME_EDITOR_H__ +#define __HILDON_TIME_EDITOR_H__ -#include +#include G_BEGIN_DECLS -#define HILDON_TYPE_TIME_EDITOR (hildon_time_editor_get_type()) +#define HILDON_TYPE_TIME_EDITOR \ + (hildon_time_editor_get_type()) -#define HILDON_TIME_EDITOR(obj) (GTK_CHECK_CAST (obj, HILDON_TYPE_TIME_EDITOR, HildonTimeEditor)) -#define HILDON_TIME_EDITOR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), HILDON_TYPE_TIME_EDITOR, HildonTimeEditorClass)) +#define HILDON_TIME_EDITOR(obj) \ + (GTK_CHECK_CAST (obj, HILDON_TYPE_TIME_EDITOR, HildonTimeEditor)) -#define HILDON_IS_TIME_EDITOR(obj) (GTK_CHECK_TYPE (obj, HILDON_TYPE_TIME_EDITOR)) -#define HILDON_IS_TIME_EDITOR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_TIME_EDITOR)) +#define HILDON_TIME_EDITOR_CLASS(klass) \ + (GTK_CHECK_CLASS_CAST ((klass), HILDON_TYPE_TIME_EDITOR, \ + HildonTimeEditorClass)) + +#define HILDON_IS_TIME_EDITOR(obj) \ + (GTK_CHECK_TYPE (obj, HILDON_TYPE_TIME_EDITOR)) + +#define HILDON_IS_TIME_EDITOR_CLASS(klass) \ + (GTK_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_TIME_EDITOR)) typedef enum { - HILDON_DATE_TIME_ERROR_NO_ERROR = -1, - HILDON_DATE_TIME_ERROR_MAX_HOURS, - HILDON_DATE_TIME_ERROR_MAX_MINS, - HILDON_DATE_TIME_ERROR_MAX_SECS, - HILDON_DATE_TIME_ERROR_MAX_DAY, - HILDON_DATE_TIME_ERROR_MAX_MONTH, - HILDON_DATE_TIME_ERROR_MAX_YEAR, - HILDON_DATE_TIME_ERROR_MIN_HOURS, - HILDON_DATE_TIME_ERROR_MIN_MINS, - HILDON_DATE_TIME_ERROR_MIN_SECS, - HILDON_DATE_TIME_ERROR_MIN_DAY, - HILDON_DATE_TIME_ERROR_MIN_MONTH, - HILDON_DATE_TIME_ERROR_MIN_YEAR, - HILDON_DATE_TIME_ERROR_EMPTY_HOURS, - HILDON_DATE_TIME_ERROR_EMPTY_MINS, - HILDON_DATE_TIME_ERROR_EMPTY_SECS, - HILDON_DATE_TIME_ERROR_EMPTY_DAY, - HILDON_DATE_TIME_ERROR_EMPTY_MONTH, - HILDON_DATE_TIME_ERROR_EMPTY_YEAR, - HILDON_DATE_TIME_ERROR_MIN_DURATION, - HILDON_DATE_TIME_ERROR_MAX_DURATION, - HILDON_DATE_TIME_ERROR_INVALID_CHAR, - HILDON_DATE_TIME_ERROR_INVALID_DATE, - HILDON_DATE_TIME_ERROR_INVALID_TIME -} HildonDateTimeEditorError; - -typedef struct _HildonTimeEditor HildonTimeEditor; -typedef struct _HildonTimeEditorClass HildonTimeEditorClass; - -struct _HildonTimeEditor { + HILDON_DATE_TIME_ERROR_NO_ERROR = -1, + HILDON_DATE_TIME_ERROR_MAX_HOURS, + HILDON_DATE_TIME_ERROR_MAX_MINS, + HILDON_DATE_TIME_ERROR_MAX_SECS, + HILDON_DATE_TIME_ERROR_MAX_DAY, + HILDON_DATE_TIME_ERROR_MAX_MONTH, + HILDON_DATE_TIME_ERROR_MAX_YEAR, + HILDON_DATE_TIME_ERROR_MIN_HOURS, + HILDON_DATE_TIME_ERROR_MIN_MINS, + HILDON_DATE_TIME_ERROR_MIN_SECS, + HILDON_DATE_TIME_ERROR_MIN_DAY, + HILDON_DATE_TIME_ERROR_MIN_MONTH, + HILDON_DATE_TIME_ERROR_MIN_YEAR, + HILDON_DATE_TIME_ERROR_EMPTY_HOURS, + HILDON_DATE_TIME_ERROR_EMPTY_MINS, + HILDON_DATE_TIME_ERROR_EMPTY_SECS, + HILDON_DATE_TIME_ERROR_EMPTY_DAY, + HILDON_DATE_TIME_ERROR_EMPTY_MONTH, + HILDON_DATE_TIME_ERROR_EMPTY_YEAR, + HILDON_DATE_TIME_ERROR_MIN_DURATION, + HILDON_DATE_TIME_ERROR_MAX_DURATION, + HILDON_DATE_TIME_ERROR_INVALID_CHAR, + HILDON_DATE_TIME_ERROR_INVALID_DATE, + HILDON_DATE_TIME_ERROR_INVALID_TIME +} HildonDateTimeEditorError; + +typedef struct _HildonTimeEditor HildonTimeEditor; + +typedef struct _HildonTimeEditorClass HildonTimeEditorClass; + +struct _HildonTimeEditor +{ GtkContainer parent; }; -struct _HildonTimeEditorClass { +struct _HildonTimeEditorClass +{ GtkContainerClass parent_class; - gboolean (*time_error) (HildonTimeEditor *editor, + gboolean (*time_error) (HildonTimeEditor *editor, HildonDateTimeEditorError type); }; -GType hildon_time_editor_get_type(void) G_GNUC_CONST; -GtkWidget *hildon_time_editor_new(void); +GType G_GNUC_CONST +hildon_time_editor_get_type (void); + +GtkWidget* +hildon_time_editor_new (void); + +void +hildon_time_editor_set_time (HildonTimeEditor *editor, + guint hours, + guint minutes, + guint seconds); +void +hildon_time_editor_get_time (HildonTimeEditor *editor, + guint *hours, + guint *minutes, + guint *seconds); -void hildon_time_editor_set_time (HildonTimeEditor * editor, - guint hours, - guint minutes, - guint seconds); +void +hildon_time_editor_set_duration_range (HildonTimeEditor *editor, + guint min_seconds, + guint max_seconds); -void hildon_time_editor_get_time (HildonTimeEditor * editor, - guint * hours, - guint * minutes, - guint * seconds); +void +hildon_time_editor_get_duration_range (HildonTimeEditor *editor, + guint *min_seconds, + guint *max_seconds); -void hildon_time_editor_set_duration_range (HildonTimeEditor * editor, - guint min_seconds, - guint max_seconds); +void +hildon_time_editor_set_ticks (HildonTimeEditor *editor, + guint ticks); -void hildon_time_editor_get_duration_range (HildonTimeEditor * editor, - guint * min_seconds, - guint * max_seconds); +guint +hildon_time_editor_get_ticks (HildonTimeEditor *editor); -void hildon_time_editor_set_ticks (HildonTimeEditor * editor, guint ticks); -guint hildon_time_editor_get_ticks (HildonTimeEditor * editor); +void +hildon_time_editor_set_show_seconds (HildonTimeEditor *editor, + gboolean show_seconds); -void hildon_time_editor_set_show_seconds (HildonTimeEditor * editor, gboolean show_seconds); -gboolean hildon_time_editor_get_show_seconds (HildonTimeEditor * editor); +gboolean +hildon_time_editor_get_show_seconds (HildonTimeEditor *editor); -void hildon_time_editor_set_show_hours (HildonTimeEditor * editor, gboolean show_hours); -gboolean hildon_time_editor_get_show_hours (HildonTimeEditor * editor); +void +hildon_time_editor_set_show_hours (HildonTimeEditor *editor, + gboolean show_hours); -void hildon_time_editor_set_duration_mode (HildonTimeEditor * editor, gboolean duration_mode); -gboolean hildon_time_editor_get_duration_mode (HildonTimeEditor * editor); +gboolean +hildon_time_editor_get_show_hours (HildonTimeEditor *editor); -void hildon_time_editor_set_duration_min (HildonTimeEditor * editor, guint duration_min); -guint hildon_time_editor_get_duration_min (HildonTimeEditor * editor); +void +hildon_time_editor_set_duration_mode (HildonTimeEditor *editor, + gboolean duration_mode); -void hildon_time_editor_set_duration_max (HildonTimeEditor * editor, guint duration_max); -guint hildon_time_editor_get_duration_max (HildonTimeEditor * editor); +gboolean +hildon_time_editor_get_duration_mode (HildonTimeEditor *editor); + +void +hildon_time_editor_set_duration_min (HildonTimeEditor *editor, + guint duration_min); + +guint +hildon_time_editor_get_duration_min (HildonTimeEditor *editor); + +void +hildon_time_editor_set_duration_max (HildonTimeEditor *editor, + guint duration_max); + +guint +hildon_time_editor_get_duration_max (HildonTimeEditor *editor); + +void +hildon_time_editor_get_time_separators (GtkLabel *hm_sep_label, + GtkLabel *ms_sep_label); G_END_DECLS -#endif /* __HILDON_TIME_EDITOR_H__ */ + +#endif /* __HILDON_TIME_EDITOR_H__ */ diff --git a/src/hildon-time-picker.c b/src/hildon-time-picker.c index 151057c..60e2330 100644 --- a/src/hildon-time-picker.c +++ b/src/hildon-time-picker.c @@ -39,7 +39,6 @@ #include "hildon-time-picker.h" #include "hildon-defines.h" -#include "hildon-private.h" #include #include #include @@ -50,6 +49,7 @@ #include #include #include "hildon-time-picker-private.h" +#include "hildon-time-editor.h" #define _(String) \ dgettext(PACKAGE, String) @@ -384,7 +384,7 @@ hildon_time_picker_init (HildonTimePicker *picker) /* Label between hour and minutes */ colon_label = gtk_label_new (NULL); - _hildon_time_editor_get_time_separators (GTK_LABEL(colon_label), NULL); + hildon_time_editor_get_time_separators (GTK_LABEL(colon_label), NULL); gtk_table_attach (table, colon_label, 2, 3, 1, 2, GTK_SHRINK, GTK_SHRINK, 6, 0); /* FIXME: magic */ diff --git a/src/hildon-widgets.h b/src/hildon-widgets.h index 10022b8..9581b80 100644 --- a/src/hildon-widgets.h +++ b/src/hildon-widgets.h @@ -45,8 +45,6 @@ #include "hildon-name-password-dialog.h" #include "hildon-note.h" #include "hildon-number-editor.h" -#include "hildon-plugin-widget.h" -#include "hildon-private.h" #include "hildon-program.h" #include "hildon-range-editor.h" #include "hildon-seekbar.h"